lamindb 1.5.3__py3-none-any.whl → 1.6.0__py3-none-any.whl

lamindb/models/has_parents.py

@@ -7,8 +7,8 @@ from typing import TYPE_CHECKING, Literal
 import lamindb_setup as ln_setup
 from lamin_utils import logger
 
-from .record import format_field_value, get_name_field
 from .run import Run
+from .sqlrecord import format_field_value, get_name_field
 
 if TYPE_CHECKING:
     from graphviz import Digraph
@@ -18,7 +18,7 @@ if TYPE_CHECKING:
     from .artifact import Artifact
     from .collection import Collection
     from .query_set import QuerySet
-    from .record import Record
+    from .sqlrecord import SQLRecord
     from .transform import Transform
 
 LAMIN_GREEN_LIGHTER = "#10b981"
@@ -38,7 +38,7 @@ is_run_from_ipython = getattr(builtins, "__IPYTHON__", False)
 # this is optimized to have fewer recursive calls
 # also len of QuerySet can be costly at times
 def _query_relatives(
-    records: QuerySet | list[Record],
+    records: QuerySet | list[SQLRecord],
     kind: Literal["parents", "children"],
     cls: type[HasParents],
 ) -> QuerySet:
@@ -242,7 +242,7 @@ def view_lineage(
 
 
 def view_parents(
-    record: Record,
+    record: SQLRecord,
     field: str,
     with_parents: bool = True,
     with_children: bool = False,
@@ -332,7 +332,7 @@ def view_parents(
 
 
 def _get_parents(
-    record: Record,
+    record: SQLRecord,
     field: str,
     distance: int,
     children: bool = False,
@@ -368,7 +368,7 @@ def _get_parents(
 
 
 def _df_edges_from_parents(
-    record: Record,
+    record: SQLRecord,
     field: str,
     distance: int,
     children: bool = False,
@@ -418,7 +418,7 @@ def _df_edges_from_parents(
     return df_edges
 
 
-def _record_label(record: Record, field: str | None = None):
+def _record_label(record: SQLRecord, field: str | None = None):
     from .artifact import Artifact
     from .collection import Collection
     from .transform import Transform
@@ -471,7 +471,7 @@ def _record_label(record: Record, field: str | None = None):
         )
 
 
-def _add_emoji(record: Record, label: str):
+def _add_emoji(record: SQLRecord, label: str):
     if record.__class__.__name__ == "Transform":
         emoji = TRANSFORM_EMOJIS.get(record.type, "💫")
     elif record.__class__.__name__ == "Run":
@@ -493,22 +493,22 @@ def _get_all_parent_runs(data: Artifact | Collection) -> list:
             inputs_run = (
                 r.__getattribute__(f"input_{name}s")
                 .all()
-                .filter(_branch_code__in=[0, 1])
+                .filter(branch_id__in=[0, 1])
                 .list()
             )
             if name == "artifact":
                 inputs_run += (
-                    r.input_collections.all().filter(_branch_code__in=[0, 1]).list()
+                    r.input_collections.all().filter(branch_id__in=[0, 1]).list()
                 )
             outputs_run = (
                 r.__getattribute__(f"output_{name}s")
                 .all()
-                .filter(_branch_code__in=[0, 1])
+                .filter(branch_id__in=[0, 1])
                 .list()
             )
             if name == "artifact":
                 outputs_run += (
-                    r.output_collections.all().filter(_branch_code__in=[0, 1]).list()
+                    r.output_collections.all().filter(branch_id__in=[0, 1]).list()
                 )
             # if inputs are outputs artifacts are the same, will result infinite loop
             # so only show as outputs
@@ -542,7 +542,7 @@ def _get_all_child_runs(data: Artifact | Collection) -> list:
             {
                 f.run
                 for f in data.run.output_collections.all()
-                .filter(_branch_code__in=[0, 1])
+                .filter(branch_id__in=[0, 1])
                 .all()
             }
         )
@@ -553,24 +553,24 @@ def _get_all_child_runs(data: Artifact | Collection) -> list:
             inputs_run = (
                 r.__getattribute__(f"input_{name}s")
                 .all()
-                .filter(_branch_code__in=[0, 1])
+                .filter(branch_id__in=[0, 1])
                 .list()
             )
             if name == "artifact":
                 inputs_run += (
-                    r.input_collections.all().filter(_branch_code__in=[0, 1]).list()
+                    r.input_collections.all().filter(branch_id__in=[0, 1]).list()
                 )
             run_inputs_outputs += [(inputs_run, r)]
 
             outputs_run = (
                 r.__getattribute__(f"output_{name}s")
                 .all()
-                .filter(_branch_code__in=[0, 1])
+                .filter(branch_id__in=[0, 1])
                 .list()
             )
             if name == "artifact":
                 outputs_run += (
-                    r.output_collections.all().filter(_branch_code__in=[0, 1]).list()
+                    r.output_collections.all().filter(branch_id__in=[0, 1]).list()
                 )
             run_inputs_outputs += [(r, outputs_run)]
 

lamindb/models/project.py

@@ -24,9 +24,10 @@ from .artifact import Artifact
 from .can_curate import CanCurate
 from .collection import Collection
 from .feature import Feature
-from .record import BasicRecord, LinkORM, Record, ValidateFields
+from .record import Record, Sheet
 from .run import Run, TracksRun, TracksUpdates, User
 from .schema import Schema
+from .sqlrecord import BaseSQLRecord, IsLink, SQLRecord, ValidateFields
 from .transform import Transform
 from .ulabel import ULabel
 
@@ -35,7 +36,7 @@ if TYPE_CHECKING:
     from datetime import datetime
 
 
-class Person(Record, CanCurate, TracksRun, TracksUpdates, ValidateFields):
+class Person(SQLRecord, CanCurate, TracksRun, TracksUpdates, ValidateFields):
     """People such as authors of a study or collaborators in a project.
 
     This registry is distinct from `User` and exists for project management.
@@ -50,7 +51,7 @@ class Person(Record, CanCurate, TracksRun, TracksUpdates, ValidateFields):
         ... ).save()
     """
 
-    class Meta(Record.Meta, TracksRun.Meta, TracksUpdates.Meta):
+    class Meta(SQLRecord.Meta, TracksRun.Meta, TracksUpdates.Meta):
         abstract = False
 
     id: int = models.AutoField(primary_key=True)
@@ -84,7 +85,7 @@ class Person(Record, CanCurate, TracksRun, TracksUpdates, ValidateFields):
         super().__init__(*args, **kwargs)
 
 
-class Reference(Record, CanCurate, TracksRun, TracksUpdates, ValidateFields):
+class Reference(SQLRecord, CanCurate, TracksRun, TracksUpdates, ValidateFields):
     """References such as internal studies, papers, documents, or URLs.
 
     Example:
@@ -100,7 +101,7 @@ class Reference(Record, CanCurate, TracksRun, TracksUpdates, ValidateFields):
         ... ).save()
     """
 
-    class Meta(Record.Meta, TracksRun.Meta, TracksUpdates.Meta):
+    class Meta(SQLRecord.Meta, TracksRun.Meta, TracksUpdates.Meta):
         abstract = False
 
     id: int = models.AutoField(primary_key=True)
@@ -112,14 +113,14 @@ class Reference(Record, CanCurate, TracksRun, TracksUpdates, ValidateFields):
     name: str = CharField(db_index=True)
     """Title or name of the reference document."""
     type: Reference | None = ForeignKey(
-        "self", PROTECT, null=True, related_name="records"
+        "self", PROTECT, null=True, related_name="references"
     )
     """Type of reference (e.g., 'Study', 'Paper', 'Preprint').
 
     Allows to group reference by type, e.g., internal studies vs. all papers etc.
     """
-    records: Reference
-    """Records of this type."""
+    references: Reference
+    """References of this type (can only be non-empty if `is_type` is `True`)."""
     is_type: bool = BooleanField(default=False, db_index=True, null=True)
     """Distinguish types from instances of the type."""
     abbr: str | None = CharField(
@@ -189,7 +190,7 @@ class Reference(Record, CanCurate, TracksRun, TracksUpdates, ValidateFields):
         super().__init__(*args, **kwargs)
 
 
-class Project(Record, CanCurate, TracksRun, TracksUpdates, ValidateFields):
+class Project(SQLRecord, CanCurate, TracksRun, TracksUpdates, ValidateFields):
     """Projects.
 
     Example:
@@ -200,7 +201,7 @@ class Project(Record, CanCurate, TracksRun, TracksUpdates, ValidateFields):
         ... ).save()
     """
 
-    class Meta(Record.Meta, TracksRun.Meta, TracksUpdates.Meta):
+    class Meta(SQLRecord.Meta, TracksRun.Meta, TracksUpdates.Meta):
         abstract = False
 
     id: int = models.AutoField(primary_key=True)
@@ -212,11 +213,11 @@ class Project(Record, CanCurate, TracksRun, TracksUpdates, ValidateFields):
     name: str = CharField(db_index=True)
     """Title or name of the Project."""
     type: Project | None = ForeignKey(
-        "self", PROTECT, null=True, related_name="records"
+        "self", PROTECT, null=True, related_name="projects"
     )
     """Type of project (e.g., 'Program', 'Project', 'GithubIssue', 'Task')."""
-    records: Project
-    """Records of this type."""
+    projects: Project
+    """Projects of this type (can only be non-empty if `is_type` is `True`)."""
     is_type: bool = BooleanField(default=False, db_index=True, null=True)
     """Distinguish types from instances of the type."""
     abbr: str | None = CharField(max_length=32, db_index=True, null=True)
@@ -273,6 +274,14 @@ class Project(Record, CanCurate, TracksRun, TracksUpdates, ValidateFields):
         Schema, through="SchemaProject", related_name="projects"
     )
     """Linked schemas."""
+    records: Record = models.ManyToManyField(
+        Record, through="RecordProject", related_name="projects"
+    )
+    """Linked records."""
+    sheets: Sheet = models.ManyToManyField(
+        Sheet, through="SheetProject", related_name="projects"
+    )
+    """Linked sheets."""
     collections: Collection = models.ManyToManyField(
         Collection, through="CollectionProject", related_name="projects"
     )
@@ -304,7 +313,7 @@ class Project(Record, CanCurate, TracksRun, TracksUpdates, ValidateFields):
         super().__init__(*args, **kwargs)
 
 
-class ArtifactProject(BasicRecord, LinkORM, TracksRun):
+class ArtifactProject(BaseSQLRecord, IsLink, TracksRun):
     id: int = models.BigAutoField(primary_key=True)
     artifact: Artifact = ForeignKey(Artifact, CASCADE, related_name="links_project")
     project: Project = ForeignKey(Project, PROTECT, related_name="links_artifact")
@@ -323,7 +332,7 @@ class ArtifactProject(BasicRecord, LinkORM, TracksRun):
         unique_together = ("artifact", "project", "feature")
 
 
-class RunProject(BasicRecord, LinkORM):
+class RunProject(BaseSQLRecord, IsLink):
     id: int = models.BigAutoField(primary_key=True)
     run: Run = ForeignKey(Run, CASCADE, related_name="links_project")
     project: Project = ForeignKey(Project, PROTECT, related_name="links_run")
@@ -344,7 +353,7 @@ class RunProject(BasicRecord, LinkORM):
         unique_together = ("run", "project")
 
 
-class TransformProject(BasicRecord, LinkORM, TracksRun):
+class TransformProject(BaseSQLRecord, IsLink, TracksRun):
     id: int = models.BigAutoField(primary_key=True)
     transform: Transform = ForeignKey(Transform, CASCADE, related_name="links_project")
     project: Project = ForeignKey(Project, PROTECT, related_name="links_transform")
@@ -353,7 +362,7 @@ class TransformProject(BasicRecord, LinkORM, TracksRun):
         unique_together = ("transform", "project")
 
 
-class CollectionProject(BasicRecord, LinkORM, TracksRun):
+class CollectionProject(BaseSQLRecord, IsLink, TracksRun):
     id: int = models.BigAutoField(primary_key=True)
     collection: Collection = ForeignKey(
         Collection, CASCADE, related_name="links_project"
@@ -364,7 +373,7 @@ class CollectionProject(BasicRecord, LinkORM, TracksRun):
         unique_together = ("collection", "project")
 
 
-class ULabelProject(BasicRecord, LinkORM, TracksRun):
+class ULabelProject(BaseSQLRecord, IsLink, TracksRun):
     id: int = models.BigAutoField(primary_key=True)
     ulabel: ULabel = ForeignKey(ULabel, CASCADE, related_name="links_project")
     project: Project = ForeignKey(Project, PROTECT, related_name="links_ulabel")
@@ -373,7 +382,7 @@ class ULabelProject(BasicRecord, LinkORM, TracksRun):
         unique_together = ("ulabel", "project")
 
 
-class PersonProject(BasicRecord, LinkORM, TracksRun):
+class PersonProject(BaseSQLRecord, IsLink, TracksRun):
     id: int = models.BigAutoField(primary_key=True)
     person: Person = ForeignKey(Person, CASCADE, related_name="links_project")
     project: Project = ForeignKey(Project, PROTECT, related_name="links_person")
@@ -383,7 +392,7 @@ class PersonProject(BasicRecord, LinkORM, TracksRun):
         unique_together = ("person", "project")
 
 
-class FeatureProject(BasicRecord, LinkORM, TracksRun):
+class FeatureProject(BaseSQLRecord, IsLink, TracksRun):
     id: int = models.BigAutoField(primary_key=True)
     feature: Feature = ForeignKey(Feature, CASCADE, related_name="links_project")
     project: Project = ForeignKey(Project, PROTECT, related_name="links_feature")
@@ -392,7 +401,7 @@ class FeatureProject(BasicRecord, LinkORM, TracksRun):
         unique_together = ("feature", "project")
 
 
-class SchemaProject(BasicRecord, LinkORM, TracksRun):
+class SchemaProject(BaseSQLRecord, IsLink, TracksRun):
     id: int = models.BigAutoField(primary_key=True)
     schema: Schema = ForeignKey(Schema, CASCADE, related_name="links_project")
     project: Project = ForeignKey(Project, PROTECT, related_name="links_schema")
@@ -401,7 +410,26 @@ class SchemaProject(BasicRecord, LinkORM, TracksRun):
         unique_together = ("schema", "project")
 
 
-class ArtifactReference(BasicRecord, LinkORM, TracksRun):
+class RecordProject(BaseSQLRecord, IsLink):
+    id: int = models.BigAutoField(primary_key=True)
+    record: Record = ForeignKey(Record, CASCADE, related_name="values_project")
+    feature: Feature = ForeignKey(Feature, CASCADE, related_name="links_recordproject")
+    value: Project = ForeignKey(Project, PROTECT, related_name="links_record")
+
+    class Meta:
+        unique_together = ("record", "feature")
+
+
+class SheetProject(BaseSQLRecord, IsLink, TracksRun):
+    id: int = models.BigAutoField(primary_key=True)
+    sheet: Sheet = ForeignKey(Sheet, CASCADE, related_name="links_project")
+    project: Project = ForeignKey(Project, PROTECT, related_name="links_sheet")
+
+    class Meta:
+        unique_together = ("sheet", "project")
+
+
+class ArtifactReference(BaseSQLRecord, IsLink, TracksRun):
     id: int = models.BigAutoField(primary_key=True)
     artifact: Artifact = ForeignKey(Artifact, CASCADE, related_name="links_reference")
     reference: Reference = ForeignKey(Reference, PROTECT, related_name="links_artifact")
@@ -420,7 +448,7 @@ class ArtifactReference(BasicRecord, LinkORM, TracksRun):
         unique_together = ("artifact", "reference", "feature")
 
 
-class TransformReference(BasicRecord, LinkORM, TracksRun):
+class TransformReference(BaseSQLRecord, IsLink, TracksRun):
     id: int = models.BigAutoField(primary_key=True)
     transform: Transform = ForeignKey(
         Transform, CASCADE, related_name="links_reference"
@@ -433,7 +461,7 @@ class TransformReference(BasicRecord, LinkORM, TracksRun):
         unique_together = ("transform", "reference")
 
 
-class CollectionReference(BasicRecord, LinkORM, TracksRun):
+class CollectionReference(BaseSQLRecord, IsLink, TracksRun):
     id: int = models.BigAutoField(primary_key=True)
     collection: Collection = ForeignKey(
         Collection, CASCADE, related_name="links_reference"

lamindb/models/query_manager.py

@@ -53,8 +53,8 @@ def _search(
         If `return_queryset` is `True`.  `QuerySet`.
 
     See Also:
-        :meth:`~lamindb.models.Record.filter`
-        :meth:`~lamindb.models.Record.lookup`
+        :meth:`~lamindb.models.SQLRecord.filter`
+        :meth:`~lamindb.models.SQLRecord.lookup`
 
     Examples:
         >>> ulabels = ln.ULabel.from_values(["ULabel1", "ULabel2", "ULabel3"], field="name")
@@ -87,7 +87,7 @@ def _search(
                     fields.append(field.field.name)
                 except AttributeError as error:
                     raise TypeError(
-                        "Please pass a Record string field, e.g., `CellType.name`!"
+                        "Please pass a SQLRecord string field, e.g., `CellType.name`!"
                     ) from error
             else:
                 fields.append(field)
@@ -185,7 +185,7 @@ def _lookup(
         dictionary converter.
 
     See Also:
-        :meth:`~lamindb.models.Record.search`
+        :meth:`~lamindb.models.SQLRecord.search`
 
     Examples:
         >>> import bionty as bt
@@ -199,7 +199,7 @@ def _lookup(
         >>> genes.ensg00000002745
         >>> lookup_return_symbols = bt.Gene.lookup(field="ensembl_gene_id", return_field="symbol")
     """
-    from .record import get_name_field
+    from .sqlrecord import get_name_field
 
     queryset = cls.all() if isinstance(cls, (QuerySet, Manager)) else cls.objects.all()
     field = get_name_field(registry=queryset.model, field=field)

lamindb/models/query_set.py

@@ -19,7 +19,7 @@ from ..errors import DoesNotExist
 from ._is_versioned import IsVersioned
 from .can_curate import CanCurate, _inspect, _standardize, _validate
 from .query_manager import _lookup, _search
-from .record import Record
+from .sqlrecord import SQLRecord
 
 if TYPE_CHECKING:
     from lamindb.base.types import ListLike, StrField
@@ -40,7 +40,7 @@ pd.set_option("display.max_columns", 200)
 #     return (series + timedelta).dt.strftime("%Y-%m-%d %H:%M:%S %Z")
 
 
-def get_keys_from_df(data: list, registry: Record) -> list[str]:
+def get_keys_from_df(data: list, registry: SQLRecord) -> list[str]:
     if len(data) > 0:
         if isinstance(data[0], dict):
             keys = list(data[0].keys())
@@ -62,9 +62,9 @@ def get_keys_from_df(data: list, registry: Record) -> list[str]:
     return keys
 
 
-def one_helper(self):
+def one_helper(self, does_not_exist_msg: str | None = None):
     if len(self) == 0:
-        raise DoesNotExist
+        raise DoesNotExist(does_not_exist_msg)
     elif len(self) > 1:
         raise MultipleResultsFound(self)
     else:
@@ -80,11 +80,13 @@ def get_backward_compat_filter_kwargs(queryset, expressions):
 
     if queryset.model in {Collection, Transform}:
         name_mappings = {
-            "visibility": "_branch_code",
+            "visibility": "branch_id",
+            "_branch_code": "branch_id",
         }
     elif queryset.model == Artifact:
         name_mappings = {
-            "visibility": "_branch_code",
+            "visibility": "branch_id",
+            "_branch_code": "branch_id",
             "transform": "run__transform",
         }
     else:
@@ -108,7 +110,7 @@ def get_backward_compat_filter_kwargs(queryset, expressions):
 
 def process_expressions(queryset: QuerySet, expressions: dict) -> dict:
     def _map_databases(value: Any, key: str, target_db: str) -> tuple[str, Any]:
-        if isinstance(value, Record):
+        if isinstance(value, SQLRecord):
             if value._state.db != target_db:
                 logger.warning(
                     f"passing record from database {value._state.db} to query {target_db}, matching on uid '{value.uid}'"
@@ -121,12 +123,14 @@ def process_expressions(queryset: QuerySet, expressions: dict) -> dict:
             and isinstance(value, IterableType)
             and not isinstance(value, str)
         ):
-            if any(isinstance(v, Record) and v._state.db != target_db for v in value):
+            if any(
+                isinstance(v, SQLRecord) and v._state.db != target_db for v in value
+            ):
                 logger.warning(
                     f"passing records from another database to query {target_db}, matching on uids"
                 )
                 return key.replace("__in", "__uid__in"), [
-                    v.uid if isinstance(v, Record) else v for v in value
+                    v.uid if isinstance(v, SQLRecord) else v for v in value
                 ]
             return key, value
 
@@ -137,21 +141,21 @@ def process_expressions(queryset: QuerySet, expressions: dict) -> dict:
         expressions,
     )
 
-    if issubclass(queryset.model, Record):
-        # _branch_code is set to 0 unless expressions contains id or uid
+    if issubclass(queryset.model, SQLRecord):
+        # branch_id is set to 0 unless expressions contains id or uid
         if not (
             "id" in expressions
             or "uid" in expressions
             or "uid__startswith" in expressions
         ):
-            _branch_code = "_branch_code"
-            if not any(e.startswith(_branch_code) for e in expressions):
-                expressions[_branch_code] = 1  # default _branch_code
-            # if _branch_code is None, do not apply a filter
+            branch_id = "branch_id"
+            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_code in expressions and expressions[_branch_code] is None:
-                expressions.pop(_branch_code)
+            elif branch_id in expressions and expressions[branch_id] is None:
+                expressions.pop(branch_id)
     if queryset._db is not None:
         # only check for database mismatch if there is a defined database on the
         # queryset
@@ -166,10 +170,10 @@ def process_expressions(queryset: QuerySet, expressions: dict) -> dict:
 
 
 def get(
-    registry_or_queryset: Union[type[Record], QuerySet],
+    registry_or_queryset: Union[type[SQLRecord], QuerySet],
     idlike: int | str | None = None,
     **expressions,
-) -> Record:
+) -> SQLRecord:
     if isinstance(registry_or_queryset, QuerySet):
         qs = registry_or_queryset
         registry = qs.model
@@ -180,18 +184,24 @@ def get(
         return super(QuerySet, qs).get(id=idlike)  # type: ignore
     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 qs.latest_version().one()
+                return one_helper(qs.latest_version(), DOESNOTEXIST_MSG)
             else:
-                return qs.one()
+                return one_helper(qs, DOESNOTEXIST_MSG)
         else:
-            return qs.one()
+            return one_helper(qs, DOESNOTEXIST_MSG)
     else:
         assert idlike is None  # noqa: S101
         expressions = process_expressions(qs, expressions)
-        # don't want _branch_code here in .get(), only in .filter()
-        expressions.pop("_branch_code", None)
+        # 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:
@@ -213,7 +223,7 @@ def get(
             raise registry.DoesNotExist from registry.DoesNotExist
 
 
-class RecordList(UserList, Generic[T]):
+class SQLRecordList(UserList, Generic[T]):
     """Is ordered, can't be queried, but has `.df()`."""
 
     def __init__(self, records: Iterable[T]):
@@ -236,7 +246,7 @@ class RecordList(UserList, Generic[T]):
         """Exactly one result. Throws error if there are more or none."""
         return one_helper(self)
 
-    def save(self) -> RecordList[T]:
+    def save(self) -> SQLRecordList[T]:
         """Save all records to the database."""
         from lamindb.models.save import save
 
@@ -271,7 +281,7 @@ def get_basic_field_names(
         "created_by_id",
         "updated_at",
         "_aux",
-        "_branch_code",
+        "branch_id",
     ]:
         if field_name in field_names:
             field_names.remove(field_name)
@@ -353,7 +363,7 @@ def get_feature_annotate_kwargs(
 
 # https://claude.ai/share/16280046-6ae5-4f6a-99ac-dec01813dc3c
 def analyze_lookup_cardinality(
-    model_class: Record, lookup_paths: list[str] | None
+    model_class: SQLRecord, lookup_paths: list[str] | None
 ) -> dict[str, str]:
     """Analyze lookup cardinality.
 
@@ -584,7 +594,7 @@ class BasicQuerySet(models.QuerySet):
             new_cls = cls
         return object.__new__(new_cls)
 
-    @doc_args(Record.df.__doc__)
+    @doc_args(SQLRecord.df.__doc__)
     def df(
         self,
         include: str | list[str] | None = None,
@@ -664,7 +674,7 @@ class BasicQuerySet(models.QuerySet):
         else:
             super().delete(*args, **kwargs)
 
-    def list(self, field: str | None = None) -> list[Record] | list[str]:
+    def 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()`.
@@ -679,7 +689,7 @@ class BasicQuerySet(models.QuerySet):
             # list casting is necessary because values_list does not return a list
             return list(self.values_list(field, flat=True))
 
-    def first(self) -> Record | None:
+    def first(self) -> SQLRecord | None:
         """If non-empty, the first result in the query set, otherwise ``None``.
 
         Examples:
@@ -689,11 +699,11 @@ class BasicQuerySet(models.QuerySet):
             return None
         return self[0]
 
-    def one(self) -> Record:
+    def one(self) -> SQLRecord:
         """Exactly one result. Raises error if there are more or none."""
         return one_helper(self)
 
-    def one_or_none(self) -> Record | None:
+    def one_or_none(self) -> SQLRecord | None:
         """At most one result. Returns it if there is one, otherwise returns ``None``.
 
         Examples:
@@ -712,7 +722,7 @@ class BasicQuerySet(models.QuerySet):
         if issubclass(self.model, IsVersioned):
             return self.filter(is_latest=True)
         else:
-            raise ValueError("Record isn't subclass of `lamindb.core.IsVersioned`")
+            raise ValueError("SQLRecord isn't subclass of `lamindb.core.IsVersioned`")
 
     @doc_args(_search.__doc__)
     def search(self, string: str, **kwargs):
@@ -769,16 +779,21 @@ class QuerySet(BasicQuerySet):
         """Suggest available fields if an unknown field was passed."""
         if "Cannot resolve keyword" in str(error):
             field = str(error).split("'")[1]
-            fields = ", ".join(sorted(self.model.__get_available_fields__()))
+            avail_fields = self.model.__get_available_fields__()
+            if "_branch_code" in avail_fields:
+                avail_fields.remove("_branch_code")  # backward compat
+            fields = ", ".join(sorted(avail_fields))
             raise FieldError(
                 f"Unknown field '{field}'. Available fields: {fields}"
             ) from None
         raise error  # pragma: no cover
 
-    def get(self, idlike: int | str | None = None, **expressions) -> Record:
+    def get(self, idlike: int | str | None = None, **expressions) -> SQLRecord:
         """Query a single record. Raises error if there are more or none."""
+        is_run_input = expressions.pop("is_run_input", False)
+
         try:
-            return get(self, idlike, **expressions)
+            record = get(self, idlike, **expressions)
         except ValueError as e:
             # Pass through original error for explicit id lookups
             if "Field 'id' expected a number" in str(e):
@@ -793,6 +808,15 @@ class QuerySet(BasicQuerySet):
             self._handle_unknown_field(e)
             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
+
+            if isinstance(record, (Artifact, Collection)):
+                _track_run_input(record, is_run_input)
+
+        return record
+
     def filter(self, *queries, **expressions) -> QuerySet:
         """Query a set of records."""
         # Suggest to use __name for related fields such as id when not passed