lamindb 1.11a1__py3-none-any.whl → 1.11.2__py3-none-any.whl

lamindb/models/artifact.py

@@ -8,10 +8,9 @@ from typing import TYPE_CHECKING, Any, Literal, Union, overload
 
 import fsspec
 import lamindb_setup as ln_setup
-import numpy as np
 import pandas as pd
 from anndata import AnnData
-from django.db import connections, models
+from django.db import ProgrammingError, connections, models
 from django.db.models import CASCADE, PROTECT, Q
 from django.db.models.functions import Length
 from lamin_utils import colors, logger
@@ -33,7 +32,7 @@ from lamindb.base.fields import (
     CharField,
     ForeignKey,
 )
-from lamindb.errors import FieldValidationError, UnknownStorageLocation
+from lamindb.errors import FieldValidationError, NoWriteAccess, UnknownStorageLocation
 from lamindb.models.query_set import QuerySet
 
 from ..base.users import current_user_id
@@ -69,7 +68,6 @@ from ..models._is_versioned import (
 from ._django import get_artifact_with_related, get_collection_with_related
 from ._feature_manager import (
     FeatureManager,
-    filter_base,
     get_label_links,
 )
 from ._is_versioned import IsVersioned
@@ -296,6 +294,7 @@ def process_data(
 
 def get_stat_or_artifact(
     path: UPath,
+    storage: Record,
     key: str | None = None,
     check_hash: bool = True,
     is_replace: bool = False,
@@ -333,14 +332,14 @@ def get_stat_or_artifact(
     else:
         result = (
             Artifact.objects.using(instance)
-            .filter(Q(hash=hash) | Q(key=key, storage=settings.storage.record))
+            .filter(Q(hash=hash) | Q(key=key, storage=storage))
             .order_by("-created_at")
             .all()
         )
         artifact_with_same_hash_exists = result.filter(hash=hash).count() > 0
         if not artifact_with_same_hash_exists and len(result) > 0:
             logger.important(
-                f"creating new artifact version for key='{key}' (storage: '{settings.storage.root_as_str}')"
+                f"creating new artifact version for key='{key}' (storage: '{storage.root}')"
             )
             previous_artifact_version = result[0]
     if artifact_with_same_hash_exists:
@@ -418,24 +417,6 @@ def get_artifact_kwargs_from_data(
         skip_check_exists,
         is_replace=is_replace,
     )
-    stat_or_artifact = get_stat_or_artifact(
-        path=path,
-        key=key,
-        instance=using_key,
-        is_replace=is_replace,
-    )
-    if isinstance(stat_or_artifact, Artifact):
-        existing_artifact = stat_or_artifact
-        if run is not None:
-            existing_artifact._populate_subsequent_runs(run)
-        return existing_artifact, None
-    else:
-        size, hash, hash_type, n_files, revises = stat_or_artifact
-
-    if revises is not None:  # update provisional_uid
-        provisional_uid, revises = create_uid(revises=revises, version=version)
-        if settings.cache_dir in path.parents:
-            path = path.rename(path.with_name(f"{provisional_uid}{suffix}"))
 
     check_path_in_storage = False
     if use_existing_storage_key:
@@ -456,6 +437,26 @@ def get_artifact_kwargs_from_data(
     else:
         storage = storage
 
+    stat_or_artifact = get_stat_or_artifact(
+        path=path,
+        storage=storage,
+        key=key,
+        instance=using_key,
+        is_replace=is_replace,
+    )
+    if isinstance(stat_or_artifact, Artifact):
+        existing_artifact = stat_or_artifact
+        if run is not None:
+            existing_artifact._populate_subsequent_runs(run)
+        return existing_artifact, None
+    else:
+        size, hash, hash_type, n_files, revises = stat_or_artifact
+
+    if revises is not None:  # update provisional_uid
+        provisional_uid, revises = create_uid(revises=revises, version=version)
+        if settings.cache_dir in path.parents:
+            path = path.rename(path.with_name(f"{provisional_uid}{suffix}"))
+
     log_storage_hint(
         check_path_in_storage=check_path_in_storage,
         storage=storage,
@@ -1033,7 +1034,7 @@ def delete_permanently(artifact: Artifact, storage: bool, using_key: str):
         delete_in_storage = storage is None or storage
     else:
         # for artifacts with non-virtual semantic storage keys (key is not None)
-        # ask for extra-confirmation
+        # ask for extra-confirmation if storage is None
         if storage is None:
             response = input(
                 f"Are you sure to want to delete {path}? (y/n) You can't undo"
@@ -1887,42 +1888,8 @@ class Artifact(SQLRecord, IsVersioned, TracksRun, TracksUpdates):
                 ln.Arfifact.filter(cell_type_by_model__name="T cell")
 
         """
-        from .query_set import QuerySet
-
-        if expressions:
-            keys_normalized = [key.split("__")[0] for key in expressions]
-            field_or_feature_or_param = keys_normalized[0].split("__")[0]
-            if field_or_feature_or_param in Artifact.__get_available_fields__():
-                qs = QuerySet(model=cls).filter(*queries, **expressions)
-                if not any(e.startswith("kind") for e in expressions):
-                    return qs.exclude(kind="__lamindb_run__")
-                else:
-                    return qs
-            elif all(
-                features_validated := Feature.validate(
-                    keys_normalized, field="name", mute=True
-                )
-            ):
-                return filter_base(Artifact, **expressions)
-            else:
-                features = ", ".join(
-                    sorted(np.array(keys_normalized)[~features_validated])
-                )
-                message = f"feature names: {features}"
-                avail_fields = cls.__get_available_fields__()
-                if "_branch_code" in avail_fields:
-                    avail_fields.remove("_branch_code")  # backward compat
-                fields = ", ".join(sorted(avail_fields))
-                raise InvalidArgument(
-                    f"You can query either by available fields: {fields}\n"
-                    f"Or fix invalid {message}"
-                )
-        else:
-            return (
-                QuerySet(model=cls)
-                .filter(*queries, **expressions)
-                .exclude(kind="__lamindb_run__")
-            )
+        # from Registry metaclass
+        return type(cls).filter(cls, *queries, **expressions)
 
     @classmethod
     def from_dataframe(
@@ -3107,8 +3074,12 @@ def _track_run_input(
                 )
                 data.save()
                 is_valid = True
+            data_run_id, run_id = data.run_id, run.id
+            different_runs = (data_run_id != run_id) or (
+                data_run_id is None and run_id is None
+            )
             return (
-                data.run_id != run.id
+                different_runs
                 and not data._state.adding  # this seems duplicated with data._state.db is None
                 and is_valid
             )
@@ -3153,8 +3124,9 @@ def _track_run_input(
     if track_run_input:
         if run is None:
             raise ValueError("No run context set. Call `ln.track()`.")
-        # avoid adding the same run twice
-        run.save()
+        if run._state.adding:
+            # avoid adding the same run twice
+            run.save()
         if data_class_name == "artifact":
             IsLink = run.input_artifacts.through
             links = [
@@ -3166,7 +3138,41 @@ def _track_run_input(
                 IsLink(run_id=run.id, collection_id=data_id)
                 for data_id in input_data_ids
             ]
-        IsLink.objects.bulk_create(links, ignore_conflicts=True)
+        try:
+            IsLink.objects.bulk_create(links, ignore_conflicts=True)
+        except ProgrammingError as e:
+            if "new row violates row-level security policy" in str(e):
+                instance = setup_settings.instance
+                available_spaces = instance.available_spaces
+                if available_spaces is None:
+                    raise NoWriteAccess(
+                        f"You’re not allowed to write to the instance {instance.slug}.\n"
+                        "Please contact administrators of the instance if you need write access."
+                    ) from None
+                write_access_spaces = (
+                    available_spaces["admin"] + available_spaces["write"]
+                )
+                no_write_access_spaces = {
+                    data_space
+                    for data in input_data
+                    if (data_space := data.space) not in write_access_spaces
+                }
+                if (run_space := run.space) not in write_access_spaces:
+                    no_write_access_spaces.add(run_space)
+                if len(no_write_access_spaces) > 1:
+                    name_msg = ", ".join(
+                        f"'{space.name}'" for space in no_write_access_spaces
+                    )
+                    space_msg = "spaces"
+                else:
+                    name_msg = f"'{no_write_access_spaces.pop().name}'"
+                    space_msg = "space"
+                raise NoWriteAccess(
+                    f"You’re not allowed to write to the {space_msg} {name_msg}.\n"
+                    f"Please contact administrators of the {space_msg} if you need write access."
+                ) from None
+            else:
+                raise e
 
 
 # privates currently dealt with separately

lamindb/models/artifact_set.py

@@ -28,6 +28,7 @@ UNORDERED_WARNING = (
 )
 
 
+# maybe make this abstract
 class ArtifactSet(Iterable):
     """Abstract class representing sets of artifacts returned by queries.
 
@@ -127,6 +128,11 @@ class ArtifactSet(Iterable):
 
 def artifacts_from_path(artifacts: ArtifactSet, path: UPathStr) -> ArtifactSet:
     """Returns artifacts in the query set that are registered for the provided path."""
+    from lamindb.models import BasicQuerySet, QuerySet
+
+    # not QuerySet but only BasicQuerySet
+    assert isinstance(artifacts, BasicQuerySet) and not isinstance(artifacts, QuerySet)  # noqa: S101
+
     upath = UPath(path)
 
     path_str = upath.as_posix()
@@ -135,12 +141,15 @@ def artifacts_from_path(artifacts: ArtifactSet, path: UPathStr) -> ArtifactSet:
     stem_len = len(stem)
 
     if stem_len == 16:
-        qs = artifacts.filter(  # type: ignore
+        qs = artifacts.filter(
             Q(_key_is_virtual=True) | Q(key__isnull=True),
             uid__startswith=stem,
         )
     elif stem_len == 20:
-        qs = artifacts.filter(Q(_key_is_virtual=True) | Q(key__isnull=True), uid=stem)  # type: ignore
+        qs = artifacts.filter(
+            Q(_key_is_virtual=True) | Q(key__isnull=True),
+            uid=stem,
+        )
     else:
         qs = None
 
@@ -148,7 +157,7 @@ def artifacts_from_path(artifacts: ArtifactSet, path: UPathStr) -> ArtifactSet:
         return qs
 
     qs = (
-        artifacts.filter(_key_is_virtual=False)  # type: ignore
+        artifacts.filter(_key_is_virtual=False)
         .alias(
             db_path=Concat("storage__root", Value("/"), "key", output_field=TextField())
         )

lamindb/models/query_set.py

@@ -5,7 +5,7 @@ from collections import UserList
 from collections.abc import Iterable
 from collections.abc import Iterable as IterableType
 from datetime import datetime, timezone
-from typing import TYPE_CHECKING, Any, Generic, NamedTuple, TypeVar, Union
+from typing import TYPE_CHECKING, Any, Generic, NamedTuple, TypeVar
 
 import pandas as pd
 from django.core.exceptions import FieldError
@@ -16,7 +16,7 @@ from lamin_utils import logger
 from lamindb_setup.core import deprecated
 from lamindb_setup.core._docs import doc_args
 
-from ..errors import DoesNotExist
+from ..errors import DoesNotExist, MultipleResultsFound
 from ._is_versioned import IsVersioned
 from .can_curate import CanCurate, _inspect, _standardize, _validate
 from .query_manager import _lookup, _search
@@ -28,10 +28,6 @@ if TYPE_CHECKING:
 T = TypeVar("T")
 
 
-class MultipleResultsFound(Exception):
-    pass
-
-
 pd.set_option("display.max_columns", 200)
 
 
@@ -63,15 +59,28 @@ def get_keys_from_df(data: list, registry: SQLRecord) -> list[str]:
     return keys
 
 
-def one_helper(self: QuerySet | SQLRecordList, does_not_exist_msg: str | None = None):
-    if isinstance(self, SQLRecord):
-        not_exists = len(self) == 0
-    else:
-        not_exists = not self.exists()  # type: ignore
+def one_helper(
+    self: QuerySet | SQLRecordList,
+    does_not_exist_msg: str | None = None,
+    raise_doesnotexist: bool = True,
+    not_exists: bool | None = None,
+    raise_multipleresultsfound: bool = True,
+):
+    if not_exists is None:
+        if isinstance(self, SQLRecordList):
+            not_exists = len(self) == 0
+        else:
+            not_exists = not self.exists()  # type: ignore
     if not_exists:
-        raise DoesNotExist(does_not_exist_msg)
+        if raise_doesnotexist:
+            raise DoesNotExist(does_not_exist_msg)
+        else:
+            return None
     elif len(self) > 1:
-        raise MultipleResultsFound(self)
+        if raise_multipleresultsfound:
+            raise MultipleResultsFound(self)
+        else:
+            return self[0]
     else:
         return self[0]
 
@@ -88,7 +97,7 @@ def get_backward_compat_filter_kwargs(queryset, expressions):
             "visibility": "branch_id",
             "_branch_code": "branch_id",
         }
-    elif queryset.model == Artifact:
+    elif queryset.model is Artifact:
         name_mappings = {
             "visibility": "branch_id",
             "_branch_code": "branch_id",
@@ -146,19 +155,29 @@ def process_expressions(queryset: QuerySet, expressions: dict) -> dict:
         expressions,
     )
     if issubclass(queryset.model, SQLRecord):
-        # branch_id is set to 1 unless expressions contains id or uid
-        if not (
-            "id" in expressions
-            or "uid" in expressions
-            or "uid__startswith" in expressions
-        ):
-            if not any(e.startswith("branch_id") for e in expressions):
-                expressions["branch_id"] = 1  # default branch_id
-            # if branch_id is None, do not apply a filter
-            # otherwise, it would mean filtering for NULL values, which doesn't make
-            # sense for a non-NULLABLE column
-            elif "branch_id" in expressions and expressions["branch_id"] is None:
-                expressions.pop("branch_id")
+        # branch_id is set to 1 unless expressions contains id, uid or hash
+        id_uid_hash = {"id", "uid", "hash", "id__in", "uid__in", "hash__in"}
+        if not any(expression in id_uid_hash for expression in expressions):
+            expressions_have_branch = False
+            branch_branch_id = {"branch", "branch_id"}
+            branch_branch_id__ = ("branch__", "branch_id__")
+            for expression in expressions:
+                if expression in branch_branch_id or expression.startswith(
+                    branch_branch_id__
+                ):
+                    expressions_have_branch = True
+                    break
+            if not expressions_have_branch:
+                # TODO: should be set to the current default branch
+                expressions["branch_id"] = 1
+            else:
+                # if branch_id is None, do not apply a filter
+                # otherwise, it would mean filtering for NULL values, which doesn't make
+                # sense for a non-NULLABLE column
+                if "branch_id" in expressions and expressions["branch_id"] is None:
+                    expressions.pop("branch_id")
+                if "branch" in expressions and expressions["branch"] is None:
+                    expressions.pop("branch")
     if queryset._db is not None:
         # only check for database mismatch if there is a defined database on the
         # queryset
@@ -173,52 +192,64 @@ def process_expressions(queryset: QuerySet, expressions: dict) -> dict:
 
 
 def get(
-    registry_or_queryset: Union[type[SQLRecord], BasicQuerySet],
+    registry_or_queryset: Registry | BasicQuerySet,
     idlike: int | str | None = None,
     **expressions,
 ) -> SQLRecord:
     if isinstance(registry_or_queryset, BasicQuerySet):
+        # not QuerySet but only BasicQuerySet
+        assert not isinstance(registry_or_queryset, QuerySet)  # noqa: S101
+
         qs = registry_or_queryset
         registry = qs.model
     else:
         qs = BasicQuerySet(model=registry_or_queryset)
         registry = registry_or_queryset
+
     if isinstance(idlike, int):
-        return BasicQuerySet.get(qs, id=idlike)
+        return qs.get(id=idlike)
     elif isinstance(idlike, str):
         NAME_FIELD = (
             registry._name_field if hasattr(registry, "_name_field") else "name"
         )
         DOESNOTEXIST_MSG = f"No record found with uid '{idlike}'. Did you forget a keyword as in {registry.__name__}.get({NAME_FIELD}='{idlike}')?"
+        # this is the case in which the user passes an under-specified uid
         if issubclass(registry, IsVersioned) and len(idlike) <= registry._len_stem_uid:
-            qs = BasicQuerySet.filter(qs, uid__startswith=idlike, is_latest=True)
-            return one_helper(qs, DOESNOTEXIST_MSG)
+            new_qs = qs.filter(uid__startswith=idlike, is_latest=True)
+            not_exists = None
+            if not new_qs.exists():
+                # also try is_latest is False due to nothing found
+                new_qs = qs.filter(uid__startswith=idlike, is_latest=False)
+            else:
+                not_exists = False
+            # it doesn't make sense to raise MultipleResultsFound when querying with an
+            # underspecified uid
+            return one_helper(
+                new_qs,
+                DOESNOTEXIST_MSG,
+                not_exists=not_exists,
+                raise_multipleresultsfound=False,
+            )
         else:
-            qs = BasicQuerySet.filter(qs, uid__startswith=idlike)
+            qs = qs.filter(uid__startswith=idlike)
             return one_helper(qs, DOESNOTEXIST_MSG)
     else:
         assert idlike is None  # noqa: S101
         expressions = process_expressions(qs, expressions)
-        # don't want branch_id here in .get(), only in .filter()
-        expressions.pop("branch_id", None)
         # inject is_latest for consistency with idlike
         is_latest_was_not_in_expressions = "is_latest" not in expressions
         if issubclass(registry, IsVersioned) and is_latest_was_not_in_expressions:
             expressions["is_latest"] = True
         try:
-            return BasicQuerySet.get(qs, **expressions)
+            return qs.get(**expressions)
         except registry.DoesNotExist as e:
             # handle the case in which the is_latest injection led to a missed query
             if "is_latest" in expressions and is_latest_was_not_in_expressions:
                 expressions.pop("is_latest")
-                result = (
-                    BasicQuerySet.filter(qs, **expressions)
-                    .order_by("-created_at")
-                    .first()
-                )
+                result = qs.filter(**expressions).order_by("-created_at").first()
                 if result is not None:
                     return result
-            raise registry.DoesNotExist from e
+            raise e
 
 
 class SQLRecordList(UserList, Generic[T]):
@@ -390,6 +421,9 @@ def get_feature_annotate_kwargs(
     # Prepare Django's annotate for features
     annotate_kwargs = {}
     for link_attr, feature_type in link_attributes_on_models.items():
+        if link_attr == "links_project" and registry is Record:
+            # we're only interested in values_project when "annotating" records
+            continue
         annotate_kwargs[f"{link_attr}__feature__name"] = F(
             f"{link_attr}__feature__name"
         )
@@ -645,6 +679,27 @@ def process_cols_from_include(
     return result
 
 
+def _queryset_class_factory(
+    registry: Registry, queryset_cls: type[models.QuerySet]
+) -> type[models.QuerySet]:
+    from lamindb.models import Artifact, ArtifactSet
+
+    # If the model is Artifact, create a new class
+    # for BasicQuerySet or QuerySet that inherits from ArtifactSet.
+    # This allows to add artifact specific functionality to all classes
+    # inheriting from BasicQuerySet.
+    # Thus all query sets of artifacts (and only of artifacts)
+    # will have functions from ArtifactSet.
+    if registry is Artifact and not issubclass(queryset_cls, ArtifactSet):
+        new_cls = type(
+            "Artifact" + queryset_cls.__name__, (queryset_cls, ArtifactSet), {}
+        )
+    else:
+        new_cls = queryset_cls
+
+    return new_cls
+
+
 class BasicQuerySet(models.QuerySet):
     """Sets of records returned by queries.
 
@@ -660,19 +715,23 @@ class BasicQuerySet(models.QuerySet):
     """
 
     def __new__(cls, model=None, query=None, using=None, hints=None):
-        from lamindb.models import Artifact, ArtifactSet
-
-        # If the model is Artifact, create a new class
-        # for BasicQuerySet or QuerySet that inherits from ArtifactSet.
-        # This allows to add artifact specific functionality to all classes
-        # inheriting from BasicQuerySet.
-        # Thus all query sets of artifacts (and only of artifacts)
-        # will have functions from ArtifactSet.
-        if model is Artifact and not issubclass(cls, ArtifactSet):
-            new_cls = type("Artifact" + cls.__name__, (cls, ArtifactSet), {})
-        else:
-            new_cls = cls
-        return object.__new__(new_cls)
+        # see comments in _queryset_class_factory
+        return object.__new__(_queryset_class_factory(model, cls))
+
+    def _to_class(
+        self, cls: type[models.QuerySet], copy: bool = True
+    ) -> models.QuerySet:
+        qs = self.all() if copy else self
+        qs.__class__ = cls
+        return qs
+
+    def _to_basic(self, copy: bool = True) -> BasicQuerySet:
+        cls = _queryset_class_factory(self.model, BasicQuerySet)
+        return self._to_class(cls, copy)
+
+    def _to_non_basic(self, copy: bool = True) -> QuerySet:
+        cls = _queryset_class_factory(self.model, QuerySet)
+        return self._to_class(cls, copy)
 
     @doc_args(SQLRecord.to_dataframe.__doc__)
     def to_dataframe(
@@ -750,17 +809,46 @@ class BasicQuerySet(models.QuerySet):
     ) -> pd.DataFrame:
         return self.to_dataframe(include, features)
 
-    def delete(self, *args, **kwargs):
-        """Delete all records in the query set."""
+    def delete(self, *args, permanent: bool | None = None, **kwargs):
+        """Delete all records in the query set.
+
+        Args:
+            permanent: Whether to permanently delete the record (skips trash).
+                Is only relevant for records that have the `branch` field.
+
+        Note:
+            Calling `delete()` twice on the same queryset does NOT permanently delete in bulk operations.
+            Use `permanent=True` for actual deletion.
+
+        Examples:
+
+            For any `QuerySet` object `qs`, call:
+
+            >>> qs.delete()
+        """
         from lamindb.models import Artifact, Collection, Run, Storage, Transform
 
-        # both Transform & Run might reference artifacts
-        if self.model in {Artifact, Collection, Transform, Run, Storage}:
+        # all these models have non-trivial delete behavior, hence we need to handle in a loop
+        if self.model in {Artifact, Collection, Transform, Run}:
+            for record in self:
+                record.delete(*args, permanent=permanent, **kwargs)
+        elif self.model is Storage:  # storage does not have soft delete
+            if permanent is False:
+                logger.warning(
+                    "the Storage registry doesn't support soft delete, hard deleting"
+                )
             for record in self:
-                logger.important(f"deleting {record}")
-                record.delete(*args, **kwargs)
+                record.delete()
         else:
-            super().delete(*args, **kwargs)
+            if not permanent and hasattr(self.model, "branch_id"):
+                logger.warning("moved records to trash (branch_id = -1)")
+                self.update(branch_id=-1)
+            else:
+                if permanent is False:
+                    logger.warning(
+                        f"model {self.model.__name__} doesn't support soft delete, hard deleting"
+                    )
+                super().delete(*args, **kwargs)
 
     def to_list(self, field: str | None = None) -> list[SQLRecord] | list[str]:
         """Populate an (unordered) list with the results.
@@ -802,12 +890,7 @@ class BasicQuerySet(models.QuerySet):
             >>> ULabel.filter(name="benchmark").one_or_none()
             >>> ULabel.filter(name="non existing label").one_or_none()
         """
-        if not self.exists():
-            return None
-        elif len(self) == 1:
-            return self[0]
-        else:
-            raise MultipleResultsFound(self.all())
+        return one_helper(self, raise_doesnotexist=False)
 
     def latest_version(self) -> QuerySet:
         """Filter every version family by latest version."""
@@ -884,18 +967,18 @@ class QuerySet(BasicQuerySet):
         """Query a single record. Raises error if there are more or none."""
         is_run_input = expressions.pop("is_run_input", False)
 
+        # artifacts_from_path and get accept only BasicQuerySet
+        qs = self._to_class(BasicQuerySet, copy=True)
+
         if path := expressions.pop("path", None):
             from .artifact_set import ArtifactSet, artifacts_from_path
 
             if not isinstance(self, ArtifactSet):
                 raise ValueError("Querying by path is only possible for artifacts.")
-
-            qs = artifacts_from_path(self, path)
-        else:
-            qs = self
+            qs = artifacts_from_path(qs, path)
 
         try:
-            record = get(qs, idlike, **expressions)  # type: ignore
+            record = get(qs, idlike, **expressions)
         except ValueError as e:
             # Pass through original error for explicit id lookups
             if "Field 'id' expected a number" in str(e):
@@ -921,15 +1004,28 @@ class QuerySet(BasicQuerySet):
 
     def filter(self, *queries, **expressions) -> QuerySet:
         """Query a set of records."""
+        from lamindb.models import Artifact, Record, Run
+
+        registry = self.model
+
+        if not expressions.pop("_skip_filter_with_features", False) and registry in {
+            Artifact,
+            Run,
+            Record,
+        }:
+            from ._feature_manager import filter_with_features
+
+            return filter_with_features(self, *queries, **expressions)
+
         # Suggest to use __name for related fields such as id when not passed
         for field, value in expressions.items():
             if (
                 isinstance(value, str)
                 and value.strip("-").isalpha()
                 and "__" not in field
-                and hasattr(self.model, field)
+                and hasattr(registry, field)
             ):
-                field_attr = getattr(self.model, field)
+                field_attr = getattr(registry, field)
                 if hasattr(field_attr, "field") and field_attr.field.related_model:
                     raise FieldError(
                         f"Invalid lookup '{value}' for {field}. Did you mean {field}__name?"

lamindb/models/record.py

@@ -108,6 +108,10 @@ class Record(SQLRecord, CanCurate, TracksRun, TracksUpdates):
         Run, through="RecordRun", related_name="records"
     )
     """Linked runs."""
+    linked_users: User = models.ManyToManyField(
+        User, through="RecordUser", related_name="records"
+    )
+    """Linked runs."""
     run: Run | None = ForeignKey(
         Run,
         PROTECT,
@@ -122,7 +126,7 @@ class Record(SQLRecord, CanCurate, TracksRun, TracksUpdates):
     ulabels: ULabel = models.ManyToManyField(
         ULabel,
         through="RecordULabel",
-        related_name="_records",  # in transition period
+        related_name="_records",  # in transition period with underscore prefix
     )
     """Linked runs."""
     linked_projects: Project