lamindb 1.10.2__py3-none-any.whl → 1.11.0__py3-none-any.whl

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
@@ -13,9 +13,10 @@ from django.db import models
 from django.db.models import F, ForeignKey, ManyToManyField, Q, Subquery
 from django.db.models.fields.related import ForeignObjectRel
 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
@@ -27,10 +28,6 @@ if TYPE_CHECKING:
 T = TypeVar("T")
 
 
-class MultipleResultsFound(Exception):
-    pass
-
-
 pd.set_option("display.max_columns", 200)
 
 
@@ -62,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]
 
@@ -87,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",
@@ -144,7 +154,6 @@ def process_expressions(queryset: QuerySet, expressions: dict) -> dict:
         queryset,
         expressions,
     )
-
     if issubclass(queryset.model, SQLRecord):
         # branch_id is set to 1 unless expressions contains id or uid
         if not (
@@ -173,32 +182,46 @@ def process_expressions(queryset: QuerySet, expressions: dict) -> dict:
 
 
 def get(
-    registry_or_queryset: Union[type[SQLRecord], QuerySet],
+    registry_or_queryset: Registry | BasicQuerySet,
     idlike: int | str | None = None,
     **expressions,
 ) -> SQLRecord:
-    if isinstance(registry_or_queryset, QuerySet):
+    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 = QuerySet(model=registry_or_queryset)
+        qs = BasicQuerySet(model=registry_or_queryset)
         registry = registry_or_queryset
+
     if isinstance(idlike, int):
-        return super(QuerySet, qs).get(id=idlike)  # type: ignore
+        return qs.get(id=idlike)
     elif isinstance(idlike, str):
-        qs = qs.filter(uid__startswith=idlike)
-
         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}')?"
-
-        if issubclass(registry, IsVersioned):
-            if len(idlike) <= registry._len_stem_uid:
-                return one_helper(qs.latest_version(), DOESNOTEXIST_MSG)
+        # this is the case in which the user passes an under-specified uid
+        if issubclass(registry, IsVersioned) and len(idlike) <= registry._len_stem_uid:
+            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:
-                return one_helper(qs, DOESNOTEXIST_MSG)
+                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 = qs.filter(uid__startswith=idlike)
             return one_helper(qs, DOESNOTEXIST_MSG)
     else:
         assert idlike is None  # noqa: S101
@@ -210,24 +233,19 @@ def get(
         if issubclass(registry, IsVersioned) and is_latest_was_not_in_expressions:
             expressions["is_latest"] = True
         try:
-            return registry.objects.using(qs.db).get(**expressions)
-        except registry.DoesNotExist:
+            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 = (
-                    registry.objects.using(qs.db)
-                    .filter(**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 registry.DoesNotExist
+            raise registry.DoesNotExist from e
 
 
 class SQLRecordList(UserList, Generic[T]):
-    """Is ordered, can't be queried, but has `.df()`."""
+    """Is ordered, can't be queried, but has `.to_dataframe()`."""
 
     def __init__(self, records: Iterable[T]):
         if isinstance(records, list):
@@ -235,16 +253,24 @@ class SQLRecordList(UserList, Generic[T]):
         else:
             super().__init__(records)  # Let UserList handle the conversion
 
-    def df(self) -> pd.DataFrame:
+    def to_dataframe(self) -> pd.DataFrame:
         keys = get_keys_from_df(self.data, self.data[0].__class__)
         values = [record.__dict__ for record in self.data]
         return pd.DataFrame(values, columns=keys)
 
-    def list(
+    @deprecated(new_name="to_dataframe")
+    def df(self) -> pd.DataFrame:
+        return self.to_dataframe()
+
+    def to_list(
         self, field: str
-    ) -> list[str]:  # meaningful to be parallel with list() in QuerySet
+    ) -> list[str]:  # meaningful to be parallel with to_list() in QuerySet
         return [getattr(record, field) for record in self.data]
 
+    @deprecated(new_name="to_list")
+    def list(self, field: str) -> list[str]:
+        return self.to_list(field)
+
     def one(self) -> T:
         """Exactly one result. Throws error if there are more or none."""
         return one_helper(self)
@@ -348,7 +374,7 @@ def get_feature_annotate_kwargs(
             | Q(dtype__startswith="cat[ULabel")
             | Q(dtype__startswith="cat[Record")
         )
-        feature_names = feature_qs.list("name")
+        feature_names = feature_qs.to_list("name")
         logger.important(
             f"queried for all categorical features with dtype ULabel or Record and non-categorical features: ({len(feature_names)}) {feature_names}"
         )
@@ -387,6 +413,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"
         )
@@ -642,6 +671,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.
 
@@ -657,22 +707,26 @@ 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)
-
-    @doc_args(SQLRecord.df.__doc__)
-    def df(
+        # 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(
         self,
         include: str | list[str] | None = None,
         features: bool | list[str] | str | None = None,
@@ -706,7 +760,7 @@ class BasicQuerySet(models.QuerySet):
             id_subquery = self.values("id")
             time = logger.debug("finished get id values", time=time)
             # for annotate, we want the queryset without filters so that joins don't affect the annotations
-            query_set_without_filters = self.model.objects.filter(
+            query_set_without_filters = self.model.objects.using(self._db).filter(
                 id__in=Subquery(id_subquery)
             )
             time = logger.debug("finished get query_set_without_filters", time=time)
@@ -739,26 +793,63 @@ class BasicQuerySet(models.QuerySet):
         time = logger.debug("finished", time=time)
         return df_reshaped
 
-    def delete(self, *args, **kwargs):
-        """Delete all records in the query set."""
-        from lamindb.models import Artifact, Collection, Run, Transform
+    @deprecated(new_name="to_dataframe")
+    def df(
+        self,
+        include: str | list[str] | None = None,
+        features: bool | list[str] | str | None = None,
+    ) -> pd.DataFrame:
+        return self.to_dataframe(include, features)
+
+    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:
 
-        # both Transform & Run might reference artifacts
+            For any `QuerySet` object `qs`, call:
+
+            >>> qs.delete()
+        """
+        from lamindb.models import Artifact, Collection, Run, Storage, Transform
+
+        # 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:
-                logger.important(f"deleting {record}")
-                record.delete(*args, **kwargs)
+                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:
+                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 list(self, field: str | None = None) -> list[SQLRecord] | list[str]:
+    def to_list(self, field: str | None = None) -> list[SQLRecord] | list[str]:
         """Populate an (unordered) list with the results.
 
         Note that the order in this list is only meaningful if you ordered the underlying query set with `.order_by()`.
 
         Examples:
-            >>> queryset.list()  # list of records
-            >>> queryset.list("name")  # list of values
+            >>> queryset.to_list()  # list of records
+            >>> queryset.to_list("name")  # list of values
         """
         if field is None:
             return list(self)
@@ -766,6 +857,10 @@ class BasicQuerySet(models.QuerySet):
             # list casting is necessary because values_list does not return a list
             return list(self.values_list(field, flat=True))
 
+    @deprecated(new_name="to_list")
+    def list(self, field: str | None = None) -> list[SQLRecord] | list[str]:
+        return self.to_list(field)
+
     def first(self) -> SQLRecord | None:
         """If non-empty, the first result in the query set, otherwise ``None``.
 
@@ -787,12 +882,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."""
@@ -869,8 +959,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(qs, path)
+
         try:
-            record = get(self, idlike, **expressions)
+            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):
@@ -886,8 +986,8 @@ class QuerySet(BasicQuerySet):
             raise  # pragma: no cover
 
         if is_run_input is not False:  # might be None or True or Run
-            from lamindb.models.artifact import Artifact, _track_run_input
-            from lamindb.models.collection import Collection
+            from .artifact import Artifact, _track_run_input
+            from .collection import Collection
 
             if isinstance(record, (Artifact, Collection)):
                 _track_run_input(record, is_run_input)
@@ -896,15 +996,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

@@ -20,7 +20,7 @@ from .can_curate import CanCurate
 from .feature import Feature
 from .has_parents import _query_relatives
 from .query_set import reorder_subset_columns_in_df
-from .run import Run, TracksRun, TracksUpdates
+from .run import Run, TracksRun, TracksUpdates, User
 from .sqlrecord import BaseSQLRecord, IsLink, SQLRecord, _get_record_kwargs
 from .transform import Transform
 from .ulabel import ULabel
@@ -54,6 +54,7 @@ class Record(SQLRecord, CanCurate, TracksRun, TracksUpdates):
 
     class Meta(SQLRecord.Meta, TracksRun.Meta, TracksUpdates.Meta):
         abstract = False
+        app_label = "lamindb"
 
     _name_field: str = "name"
 
@@ -107,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,
@@ -121,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
@@ -207,11 +212,13 @@ class Record(SQLRecord, CanCurate, TracksRun, TracksUpdates):
     def to_pandas(self) -> pd.DataFrame:
         """Export all children of a record type recursively to a pandas DataFrame."""
         assert self.is_type, "Only types can be exported as dataframes"  # noqa: S101
-        df = self.query_children().df(features="queryset")
+        df = self.query_children().to_dataframe(features="queryset")
         df.columns.values[0] = "__lamindb_record_uid__"
         df.columns.values[1] = "__lamindb_record_name__"
         if self.schema is not None:
-            desired_order = self.schema.members.list("name")  # only members is ordered!
+            desired_order = self.schema.members.to_list(
+                "name"
+            )  # only members is ordered!
         else:
             # sort alphabetically for now
             desired_order = df.columns[2:].tolist()
@@ -235,7 +242,7 @@ class Record(SQLRecord, CanCurate, TracksRun, TracksUpdates):
         )
         run = Run(transform, initiated_by_run=context.run).save()
         run.input_records.add(self)
-        return Artifact.from_df(
+        return Artifact.from_dataframe(
             self.to_pandas(),
             key=key,
             description=f"Export of sheet {self.uid}{description}",
@@ -252,6 +259,7 @@ class RecordJson(BaseSQLRecord, IsLink):
     value: Any = JSONField(default=None, db_default=None)
 
     class Meta:
+        app_label = "lamindb"
         unique_together = ("record", "feature")  # a list is modeled as a list in json
 
 
@@ -266,6 +274,7 @@ class RecordRecord(SQLRecord, IsLink):
     )  # component
 
     class Meta:
+        app_label = "lamindb"
         unique_together = ("record", "feature", "value")
 
 
@@ -277,6 +286,19 @@ class RecordULabel(BaseSQLRecord, IsLink):
 
     class Meta:
         # allows linking exactly one record to one ulabel per feature, because we likely don't want to have Many
+        app_label = "lamindb"
+        unique_together = ("record", "feature", "value")
+
+
+class RecordUser(BaseSQLRecord, IsLink):
+    id: int = models.BigAutoField(primary_key=True)
+    record: Record = ForeignKey(Record, CASCADE, related_name="values_user")
+    feature: Feature = ForeignKey(Feature, PROTECT, related_name="links_recorduser")
+    value: User = ForeignKey(User, PROTECT, related_name="links_record")
+
+    class Meta:
+        # allows linking exactly one record to one user per feature, because we likely don't want to have Many
+        app_label = "lamindb"
         unique_together = ("record", "feature", "value")
 
 
@@ -288,6 +310,7 @@ class RecordRun(BaseSQLRecord, IsLink):
 
     class Meta:
         # allows linking several records to a single run for the same feature because we'll likely need this
+        app_label = "lamindb"
         unique_together = ("record", "feature", "value")
 
 
@@ -299,6 +322,7 @@ class RecordArtifact(BaseSQLRecord, IsLink):
 
     class Meta:
         # allows linking several records to a single artifact for the same feature because we'll likely need this
+        app_label = "lamindb"
         unique_together = ("record", "feature", "value")
 
 
@@ -315,4 +339,5 @@ class ArtifactRecord(BaseSQLRecord, IsLink):
 
     class Meta:
         # allows linking several records to a single artifact for the same feature because we'll likely need this
+        app_label = "lamindb"
         unique_together = ("artifact", "record", "feature")

lamindb/models/run.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, overload
 
-import numpy as np
 from django.db import models
 from django.db.models import (
     CASCADE,
@@ -18,7 +17,6 @@ from lamindb.base.fields import (
     ForeignKey,
 )
 from lamindb.base.users import current_user_id
-from lamindb.errors import InvalidArgument
 
 from ..base.ids import base62_16
 from .can_curate import CanCurate
@@ -142,6 +140,9 @@ class User(BaseSQLRecord, CanCurate):
         >>> user
     """
 
+    class Meta:
+        app_label = "lamindb"
+
     _name_field: str = "handle"
 
     id: int = models.AutoField(primary_key=True)
@@ -223,6 +224,9 @@ class Run(SQLRecord):
         >>> ln.context.run
     """
 
+    class Meta:
+        app_label = "lamindb"
+
     _name_field: str = "started_at"
 
     id: int = models.BigAutoField(primary_key=True)
@@ -368,11 +372,6 @@ class Run(SQLRecord):
             reference_type=reference_type,
         )
 
-    def delete(self) -> None:
-        """Delete."""
-        delete_run_artifacts(self)
-        super().delete()
-
     @property
     @deprecated("features")
     def params(self) -> FeatureManager:
@@ -427,31 +426,8 @@ class Run(SQLRecord):
 
                 ln.Run.filter(hyperparam_x=100)
         """
-        from ._feature_manager import filter_base
-        from .feature import Feature
-        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 Run.__get_available_fields__():
-                return QuerySet(model=cls).filter(*queries, **expressions)
-            elif all(
-                params_validated := Feature.validate(
-                    keys_normalized, field="name", mute=True
-                )
-            ):
-                return filter_base(Run, **expressions)
-            else:
-                params = ", ".join(sorted(np.array(keys_normalized)[~params_validated]))
-                message = f"feature names: {params}"
-                fields = ", ".join(sorted(cls.__get_available_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)
+        # from Registry metaclass
+        return type(cls).filter(cls, *queries, **expressions)
 
 
 def delete_run_artifacts(run: Run) -> None:
@@ -470,7 +446,7 @@ def delete_run_artifacts(run: Run) -> None:
         if environment._environment_of.count() == 0:
             environment.delete(permanent=True)
     if report is not None:
-        # only delete if there are no other runs attached to this environment
+        # only delete if there are no other runs attached to this report
         if report._report_of.count() == 0:
             report.delete(permanent=True)
 
@@ -492,4 +468,5 @@ class RunFeatureValue(BaseSQLRecord, IsLink):
     """Creator of record."""
 
     class Meta:
+        app_label = "lamindb"
         unique_together = ("run", "featurevalue")