lamindb 1.5.2__py3-none-any.whl → 1.6a2__py3-none-any.whl

lamindb/models/_feature_manager.py

@@ -27,14 +27,14 @@ from lamindb.models.feature import (
     serialize_pandas_dtype,
     suggest_categorical_for_str_iterable,
 )
-from lamindb.models.record import (
+from lamindb.models.save import save
+from lamindb.models.schema import DICT_KEYS_TYPE, Schema
+from lamindb.models.sqlrecord import (
     REGISTRY_UNIQUE_FIELD,
     get_name_field,
     transfer_fk_to_default_db_bulk,
     transfer_to_default_db,
 )
-from lamindb.models.save import save
-from lamindb.models.schema import DICT_KEYS_TYPE, Schema
 
 from ..base import deprecated
 from ._describe import (
@@ -50,8 +50,8 @@ from ._relations import (
     dict_related_model_to_related_name,
 )
 from .feature import Feature, FeatureValue, parse_dtype
-from .record import Record
-from .run import Param, ParamManager, ParamManagerRun, ParamValue, Run
+from .run import FeatureManager, FeatureManagerRun, Run
+from .sqlrecord import SQLRecord
 from .ulabel import ULabel
 
 if TYPE_CHECKING:
@@ -61,11 +61,17 @@ if TYPE_CHECKING:
     from lamindb.models import (
         Artifact,
         Collection,
-        LinkORM,
+        IsLink,
     )
     from lamindb.models.query_set import QuerySet
 
 
+class FeatureManagerArtifact(FeatureManager):
+    """Feature manager."""
+
+    pass
+
+
 def get_accessor_by_registry_(host: Artifact | Collection) -> dict:
     dictionary = {
         field.related_model.__get_name_with_module__(): field.name
@@ -112,7 +118,7 @@ def get_schema_links(host: Artifact | Collection) -> QuerySet:
     return links_schema
 
 
-def get_link_attr(link: LinkORM | type[LinkORM], data: Artifact | Collection) -> str:
+def get_link_attr(link: IsLink | type[IsLink], data: Artifact | Collection) -> str:
     link_model_name = link.__class__.__name__
     if link_model_name in {"Registry", "ModelBase"}:  # we passed the type of the link
         link_model_name = link.__name__  # type: ignore
@@ -133,19 +139,18 @@ def custom_aggregate(field, using: str):
 
 
 def _get_categoricals_postgres(
-    self: Artifact | Collection,
+    self: Artifact | Collection | Run,
     related_data: dict | None = None,
-    print_params: bool = False,
 ) -> dict[tuple[str, str], set[str]]:
     """Get categorical features and their values using PostgreSQL-specific optimizations."""
-    if print_params:
-        return {}
-
     if not related_data:
-        artifact_meta = get_artifact_with_related(
-            self, include_feature_link=True, include_m2m=True
-        )
-        related_data = artifact_meta.get("related_data", {})
+        if self.__class__.__name__ == "Artifact":
+            artifact_meta = get_artifact_with_related(
+                self, include_feature_link=True, include_m2m=True
+            )
+            related_data = artifact_meta.get("related_data", {})
+        else:
+            related_data = {}
 
     # Process m2m data
     m2m_data = related_data.get("m2m", {}) if related_data else {}
@@ -189,12 +194,8 @@ def _get_categoricals_postgres(
 
 def _get_categoricals(
     self: Artifact | Collection,
-    print_params: bool = False,
 ) -> dict[tuple[str, str], set[str]]:
     """Get categorical features and their values using the default approach."""
-    if print_params:
-        return {}
-
     result = defaultdict(set)
     for _, links in _get_labels(self, links=True, instance=self._state.db).items():
         for link in links:
@@ -213,7 +214,6 @@ def _get_categoricals(
 
 def _get_non_categoricals(
     self,
-    print_params: bool = False,
 ) -> dict[tuple[str, str], set[Any]]:
     """Get non-categorical features and their values."""
     from .artifact import Artifact
@@ -222,7 +222,7 @@ def _get_non_categoricals(
     non_categoricals = {}
 
     if self.id is not None and isinstance(self, (Artifact, Run)):
-        attr_name = "param" if print_params else "feature"
+        attr_name = "feature"
         _feature_values = (
             getattr(self, f"_{attr_name}_values")
             .values(f"{attr_name}__name", f"{attr_name}__dtype")
@@ -243,7 +243,11 @@ def _get_non_categoricals(
                 and feature_dtype != "dict"
                 and not feature_dtype.startswith("list")
             ):
-                values = set(values)
+                try:
+                    values = set(values)
+                except TypeError:
+                    # TypeError: unhashable type: 'list' if values is list[list]
+                    pass
 
             # Handle special datetime types
             if feature_dtype == "datetime":
@@ -289,7 +293,6 @@ def describe_features(
     self: Artifact,
     related_data: dict | None = None,
     to_dict: bool = False,
-    print_params: bool = False,
     tree: Tree | None = None,
     with_labels: bool = False,
 ):
@@ -308,7 +311,7 @@ def describe_features(
     # feature sets
     schema_data: dict[str, tuple[str, list[str]]] = {}
     feature_data: dict[str, tuple[str, list[str]]] = {}
-    if not print_params and not to_dict:
+    if not to_dict:
         if self.id is not None and connections[self._state.db].vendor == "postgresql":
             fs_data = _get_schemas_postgres(self, related_data=related_data)
             for fs_id, (slot, data) in fs_data.items():
@@ -358,18 +361,15 @@ def describe_features(
         categoricals = _get_categoricals_postgres(
             self,
             related_data=related_data,
-            print_params=print_params,
         )
     else:
         categoricals = _get_categoricals(
             self,
-            print_params=print_params,
         )
 
     # Get non-categorical features
     non_categoricals = _get_non_categoricals(
         self,
-        print_params=print_params,
     )
 
     # Process all Features containing labels and sort into internal/external
@@ -483,9 +483,7 @@ def describe_features(
             )
         )
     # ext_features_tree = None
-    ext_features_header = Text(
-        "Params" if print_params else "Linked features", style="bold dark_orange"
-    )
+    ext_features_header = Text("Linked features", style="bold dark_orange")
     if ext_features_tree_children:
         ext_features_tree = tree.add(ext_features_header)
         for child in ext_features_tree_children:
@@ -558,31 +556,19 @@ def infer_feature_type_convert_json(
                     return "list[float]", value, message
                 elif first_element_type is str:
                     return ("list[cat ? str]", value, message)
-                elif first_element_type == Record:
+                elif first_element_type == SQLRecord:
                     return (
                         f"list[cat[{first_element_type.__get_name_with_module__()}]]",
                         value,
                         message,
                     )
-    elif isinstance(value, Record):
+    elif isinstance(value, SQLRecord):
         return (f"cat[{value.__class__.__get_name_with_module__()}]", value, message)
     if not mute:
         logger.warning(f"cannot infer feature type of: {value}, returning '?")
     return "?", value, message
 
 
-class FeatureManager:
-    """Feature manager."""
-
-    pass
-
-
-class ParamManagerArtifact(ParamManager):
-    """Param manager."""
-
-    pass
-
-
 def __init__(self, host: Artifact | Collection | Run):
     self._host = host
     self._slots = None
@@ -594,15 +580,13 @@ def __repr__(self) -> str:
 
 
 def describe(self, return_str: bool = False) -> str | None:
-    tree = describe_features(self._host, print_params=(self.__class__ == ParamManager))  # type: ignore
+    tree = describe_features(self._host)  # type: ignore
     return format_rich_tree(tree, fallback="no linked features", return_str=return_str)
 
 
 def get_values(self) -> dict[str, Any]:
     """Get feature values as a dictionary."""
-    return describe_features(
-        self._host, to_dict=True, print_params=(self.__class__ == ParamManager)
-    )  # type: ignore
+    return describe_features(self._host, to_dict=True)  # type: ignore
 
 
 @deprecated("slots[slot].members")
@@ -621,12 +605,8 @@ def __getitem__(self, slot) -> QuerySet:
 def filter_base(cls, _skip_validation: bool = True, **expression) -> QuerySet:
     from .artifact import Artifact
 
-    if cls is FeatureManager:
-        model = Feature
-        value_model = FeatureValue
-    else:
-        model = Param
-        value_model = ParamValue
+    model = Feature
+    value_model = FeatureValue
     keys_normalized = [key.split("__")[0] for key in expression]
     if not _skip_validation:
         validated = model.validate(keys_normalized, field="name", mute=True)
@@ -636,7 +616,7 @@ def filter_base(cls, _skip_validation: bool = True, **expression) -> QuerySet:
             )
     new_expression = {}
     features = model.filter(name__in=keys_normalized).all().distinct()
-    feature_param = "param" if model is Param else "feature"
+    feature_param = "feature"
     for key, value in expression.items():
         split_key = key.split("__")
         normalized_key = split_key[0]
@@ -646,7 +626,7 @@ def filter_base(cls, _skip_validation: bool = True, **expression) -> QuerySet:
         feature = features.get(name=normalized_key)
         if not feature.dtype.startswith("cat"):
             if comparator == "__isnull":
-                if cls == FeatureManager:
+                if cls == FeatureManagerArtifact:
                     from .artifact import ArtifactFeatureValue
 
                     if value:  # True
@@ -673,9 +653,9 @@ def filter_base(cls, _skip_validation: bool = True, **expression) -> QuerySet:
             expression = {feature_param: feature, f"value{comparator}": value}
             feature_values = value_model.filter(**expression)
             new_expression[f"_{feature_param}_values__id__in"] = feature_values
-        elif isinstance(value, (str, Record, bool)):
+        elif isinstance(value, (str, SQLRecord, bool)):
             if comparator == "__isnull":
-                if cls == FeatureManager:
+                if cls == FeatureManagerArtifact:
                     result = parse_dtype(feature.dtype)[0]
                     kwargs = {
                         f"links_{result['registry'].__name__.lower()}__feature": feature
@@ -701,7 +681,7 @@ def filter_base(cls, _skip_validation: bool = True, **expression) -> QuerySet:
                         )
                     elif len(labels) == 1:
                         label = labels[0]
-                elif isinstance(value, Record):
+                elif isinstance(value, SQLRecord):
                     label = value
                 label_registry = (
                     label.__class__ if label is not None else labels[0].__class__
@@ -725,9 +705,9 @@ def filter_base(cls, _skip_validation: bool = True, **expression) -> QuerySet:
             # https://laminlabs.slack.com/archives/C04FPE8V01W/p1688328084810609
     if not (new_expression):
         raise NotImplementedError
-    if cls == FeatureManager or cls == ParamManagerArtifact:
+    if cls == FeatureManagerArtifact:
         return Artifact.objects.filter(**new_expression)
-    elif cls == ParamManagerRun:
+    elif cls == FeatureManagerRun:
         return Run.objects.filter(**new_expression)
 
 
@@ -740,7 +720,7 @@ def filter(cls, **expression) -> QuerySet:
 
 @classmethod  # type: ignore
 @deprecated("the filter() registry classmethod")
-def get(cls, **expression) -> Record:
+def get(cls, **expression) -> SQLRecord:
     """Query a single artifact by feature."""
     return filter_base(cls, _skip_validation=False, **expression).one()
 
@@ -780,10 +760,10 @@ def add_label_feature_links(
         related_names = {"ULabel": "ulabels"}
     for class_name, registry_features_labels in features_labels.items():
         related_name = related_names[class_name]  # e.g., "ulabels"
-        LinkORM = getattr(self._host, related_name).through
-        field_name = f"{get_link_attr(LinkORM, self._host)}_id"  # e.g., ulabel_id
+        IsLink = getattr(self._host, related_name).through
+        field_name = f"{get_link_attr(IsLink, self._host)}_id"  # e.g., ulabel_id
         links = [
-            LinkORM(
+            IsLink(
                 **{
                     "artifact_id": self._host.id,
                     "feature_id": feature.id,
@@ -800,7 +780,7 @@ def add_label_feature_links(
         except Exception:
             save(links, ignore_conflicts=True)
         # now delete links that were previously saved without a feature
-        LinkORM.filter(
+        IsLink.filter(
             **{
                 "artifact_id": self._host.id,
                 "feature_id": None,
@@ -823,7 +803,6 @@ def _add_values(
             dictionary.
     """
     from .._tracked import get_current_tracked_run
-    from .artifact import Artifact
 
     # rename to distinguish from the values inside the dict
     dictionary = values
@@ -833,19 +812,8 @@ def _add_values(
     # deal with other cases later
     assert all(isinstance(key, str) for key in keys)  # noqa: S101
     registry = feature_param_field.field.model
-    is_param = registry == Param
-    value_model = ParamValue if is_param else FeatureValue
-    model_name = "Param" if is_param else "Feature"
-    if is_param:
-        if self._host.__class__ == Artifact:
-            if self._host.kind != "model":
-                raise ValidationError("Can only set params for model-like artifacts.")
-    else:
-        if self._host.__class__ == Artifact:
-            if self._host.kind != "dataset" and self._host.kind is not None:
-                raise ValidationError(
-                    "Can only set features for dataset-like artifacts."
-                )
+    value_model = FeatureValue
+    model_name = "Feature"
     records = registry.from_values(keys, field=feature_param_field, mute=True)
     if len(records) != len(keys):
         not_validated_keys = [key for key in keys if key not in records.list("name")]
@@ -892,7 +860,9 @@ def _add_values(
                 )
         elif feature.dtype.startswith("cat"):
             if inferred_type != "?":
-                if not (inferred_type.startswith("cat") or isinstance(value, Record)):
+                if not (
+                    inferred_type.startswith("cat") or isinstance(value, SQLRecord)
+                ):
                     raise TypeError(
                         f"Value for feature '{feature.name}' with type '{feature.dtype}' must be a string or record."
                     )
@@ -907,10 +877,10 @@ def _add_values(
             feature_value, _ = value_model.get_or_create(**filter_kwargs)
             _feature_values.append(feature_value)
         else:
-            if isinstance(value, Record) or (
-                isinstance(value, Iterable) and isinstance(next(iter(value)), Record)
+            if isinstance(value, SQLRecord) or (
+                isinstance(value, Iterable) and isinstance(next(iter(value)), SQLRecord)
             ):
-                if isinstance(value, Record):
+                if isinstance(value, SQLRecord):
                     label_records = [value]
                 else:
                     label_records = value  # type: ignore
@@ -977,12 +947,8 @@ def _add_values(
             for record in _feature_values
             if getattr(record, model_name.lower()).dtype == "dict"
         ]
-        if is_param:
-            LinkORM = self._host._param_values.through
-            valuefield_id = "paramvalue_id"
-        else:
-            LinkORM = self._host._feature_values.through
-            valuefield_id = "featurevalue_id"
+        IsLink = self._host._feature_values.through
+        valuefield_id = "featurevalue_id"
         host_class_lower = self._host.__class__.__get_name_with_module__().lower()
         if dict_typed_features:
             # delete all previously existing anotations with dictionaries
@@ -996,7 +962,7 @@ def _add_values(
                 pass
         # add new feature links
         links = [
-            LinkORM(
+            IsLink(
                 **{
                     f"{host_class_lower}_id": self._host.id,
                     valuefield_id: feature_value.id,
@@ -1026,18 +992,6 @@ def add_values_features(
     _add_values(self, values, feature_field, str_as_ulabel=str_as_ulabel)
 
 
-def add_values_params(
-    self,
-    values: dict[str, str | int | float | bool],
-) -> None:
-    """Curate artifact with features & values.
-
-    Args:
-        values: A dictionary of keys (features) & values (labels, numbers, booleans).
-    """
-    _add_values(self, values, Param.name, str_as_ulabel=False)
-
-
 def remove_values(
     self,
     feature: str | Feature,
@@ -1059,7 +1013,7 @@ def remove_values(
     if feature.dtype.startswith("cat["):  # type: ignore
         feature_registry = feature.dtype.replace("cat[", "").replace("]", "")  # type: ignore
         if value is not None:
-            assert isinstance(value, Record)  # noqa: S101
+            assert isinstance(value, SQLRecord)  # noqa: S101
             # the below uses our convention for field names in link models
             link_name = (
                 feature_registry.split(".")[1]
@@ -1155,15 +1109,8 @@ def _add_from(self, data: Artifact | Collection, transfer_logs: dict = None):
         registry = members[0].__class__
         # note here the features are transferred based on an unique field
         field = REGISTRY_UNIQUE_FIELD.get(registry.__name__.lower(), "uid")
-        if hasattr(registry, "_ontology_id_field"):
-            field = registry._ontology_id_field
         # this will be e.g. be a list of ontology_ids or uids
         member_uids = list(members.values_list(field, flat=True))
-        # create records from ontology_id
-        if hasattr(registry, "_ontology_id_field") and len(member_uids) > 0:
-            # create from bionty
-            members_records = registry.from_values(member_uids, field=field, mute=True)
-            save([r for r in members_records if r._state.adding])
         validated = registry.validate(member_uids, field=field, mute=True)
         new_members_uids = list(compress(member_uids, ~validated))
         new_members = members.filter(**{f"{field}__in": new_members_uids}).all()
@@ -1182,7 +1129,9 @@ def _add_from(self, data: Artifact | Collection, transfer_logs: dict = None):
                     feature, using_key, transfer_fk=False, transfer_logs=transfer_logs
                 )
             logger.info(f"saving {n_new_members} new {registry.__name__} records")
-            save(new_members)
+            save(
+                new_members, ignore_conflicts=True
+            )  # conflicts arising from existing records are ignored
 
         # create a new feature set from feature values using the same uid
         schema_self = Schema.from_values(member_uids, field=getattr(registry, field))
@@ -1259,7 +1208,7 @@ def parse_staged_feature_sets_from_anndata(
     obs_field: FieldAttr = Feature.name,
     uns_field: FieldAttr | None = None,
     mute: bool = False,
-    organism: str | Record | None = None,
+    organism: str | SQLRecord | None = None,
 ) -> dict:
     data_parse = adata
     if not isinstance(adata, AnnData):  # is a path
@@ -1333,7 +1282,7 @@ def _add_set_from_anndata(
     obs_field: FieldAttr | None = Feature.name,
     uns_field: FieldAttr | None = None,
     mute: bool = False,
-    organism: str | Record | None = None,
+    organism: str | SQLRecord | None = None,
 ):
     """Add features from AnnData."""
     assert self._host.otype == "AnnData"  # noqa: S101
@@ -1359,7 +1308,7 @@ def _add_set_from_mudata(
     var_fields: dict[str, FieldAttr] | None = None,
     obs_fields: dict[str, FieldAttr] | None = None,
     mute: bool = False,
-    organism: str | Record | None = None,
+    organism: str | SQLRecord | None = None,
 ):
     """Add features from MuData."""
     if obs_fields is None:
@@ -1396,7 +1345,7 @@ def _add_set_from_spatialdata(
     var_fields: dict[str, FieldAttr] | None = None,
     obs_fields: dict[str, FieldAttr] | None = None,
     mute: bool = False,
-    organism: str | Record | None = None,
+    organism: str | SQLRecord | None = None,
 ):
     """Add features from SpatialData."""
     obs_fields, var_fields = obs_fields or {}, var_fields or {}
@@ -1433,11 +1382,8 @@ def _add_set_from_spatialdata(
 
 # mypy: ignore-errors
 FeatureManager.__init__ = __init__
-ParamManager.__init__ = __init__
 FeatureManager.__repr__ = __repr__
-ParamManager.__repr__ = __repr__
 FeatureManager.describe = describe
-ParamManager.describe = describe
 FeatureManager.__getitem__ = __getitem__
 FeatureManager.get_values = get_values
 FeatureManager.slots = slots
@@ -1449,9 +1395,6 @@ FeatureManager.filter = filter
 FeatureManager.get = get
 FeatureManager.make_external = make_external
 FeatureManager.remove_values = remove_values
-ParamManager.add_values = add_values_params
-ParamManager.get_values = get_values
-ParamManager.filter = filter
 
 # deprecated
 FeatureManager._add_set_from_df = _add_set_from_df

lamindb/models/_from_values.py

@@ -8,8 +8,8 @@ from lamin_utils import colors, logger
 if TYPE_CHECKING:
     from lamindb.base.types import FieldAttr, ListLike
 
-    from .query_set import RecordList
-    from .record import Record
+    from .query_set import SQLRecordList
+    from .sqlrecord import SQLRecord
 
 
 # The base function for `from_values`
@@ -18,12 +18,12 @@ def _from_values(
     field: FieldAttr,
     *,
     create: bool = False,
-    organism: Record | str | None = None,
-    source: Record | None = None,
+    organism: SQLRecord | str | None = None,
+    source: SQLRecord | None = None,
     mute: bool = False,
-) -> RecordList:
+) -> SQLRecordList:
     """Get or create records from iterables."""
-    from .query_set import RecordList
+    from .query_set import SQLRecordList
 
     registry = field.field.model  # type: ignore
     organism_record = get_organism_record_from_field(field, organism, values=iterable)
@@ -32,7 +32,7 @@ def _from_values(
         create_kwargs = {}
         if organism_record:
             create_kwargs["organism"] = organism_record
-        return RecordList(
+        return SQLRecordList(
             [
                 registry(**{field.field.name: value}, **create_kwargs)
                 for value in iterable
@@ -89,13 +89,13 @@ def _from_values(
                     f"{colors.red('did not create')} {registry.__name__} record{s} for "
                     f"{n_nonval} {colors.italic(f'{field.field.name}{s}')}: {print_values}"  # type: ignore
                 )
-    return RecordList(records)
+    return SQLRecordList(records)
 
 
 def get_existing_records(
     iterable_idx: pd.Index,
     field: FieldAttr,
-    organism: Record | None = None,
+    organism: SQLRecord | None = None,
     mute: bool = False,
 ) -> tuple[list, pd.Index, str]:
     """Get existing records from the database."""
@@ -177,8 +177,8 @@ def get_existing_records(
 def create_records_from_source(
     iterable_idx: pd.Index,
     field: FieldAttr,
-    organism: Record | None = None,
-    source: Record | None = None,
+    organism: SQLRecord | None = None,
+    source: SQLRecord | None = None,
     msg: str = "",
     mute: bool = False,
 ) -> tuple[list, pd.Index]:
@@ -341,10 +341,10 @@ def _bulk_create_dicts_from_df(
 
 def get_organism_record_from_field(  # type: ignore
     field: FieldAttr,
-    organism: str | Record | None = None,
+    organism: str | SQLRecord | None = None,
     values: ListLike = None,
     using_key: str | None = None,
-) -> Record | None:
+) -> SQLRecord | None:
     """Get organism record.
 
     Args:

lamindb/models/_label_manager.py

@@ -11,13 +11,13 @@ from rich.tree import Tree
 
 from lamindb.models import CanCurate, Feature
 from lamindb.models._from_values import _format_values
-from lamindb.models.record import (
+from lamindb.models.save import save
+from lamindb.models.sqlrecord import (
     REGISTRY_UNIQUE_FIELD,
     get_name_field,
     transfer_fk_to_default_db_bulk,
     transfer_to_default_db,
 )
-from lamindb.models.save import save
 
 from ._describe import (
     NAME_WIDTH,
@@ -30,10 +30,12 @@ from ._django import get_artifact_with_related, get_related_model
 from ._relations import dict_related_model_to_related_name
 
 if TYPE_CHECKING:
-    from lamindb.models import Artifact, Collection, Record
+    from lamindb.models import Artifact, Collection, SQLRecord
     from lamindb.models.query_set import QuerySet
 
-EXCLUDE_LABELS = {"feature_sets"}
+# we do not want to show records because this is a breaking change until all instances are migrated
+# TODO: remove records from below once all instances are migrated
+EXCLUDE_LABELS = {"feature_sets", "records"}
 
 
 def _get_labels(
@@ -193,7 +195,7 @@ class LabelManager:
 
     def add(
         self,
-        records: Record | list[Record] | QuerySet,
+        records: SQLRecord | list[SQLRecord] | QuerySet,
         feature: Feature | None = None,
     ) -> None:
         """Add one or several labels and associate them with a feature.
@@ -308,7 +310,7 @@ class LabelManager:
                         *feature_labels, through_defaults={"feature_id": feature_id}
                     )
 
-    def make_external(self, label: Record) -> None:
+    def make_external(self, label: SQLRecord) -> None:
         """Make a label external, aka dissociate label from internal features.
 
         Args:

lamindb/models/_relations.py

@@ -10,10 +10,10 @@ from lamindb_setup._connect_instance import (
 )
 from lamindb_setup.core._settings_store import instance_settings_file
 
-from lamindb.models.record import LinkORM
+from lamindb.models.sqlrecord import IsLink
 
 if TYPE_CHECKING:
-    from lamindb.models.record import Record, Registry
+    from lamindb.models.sqlrecord import Registry, SQLRecord
 
 
 def get_schema_modules(instance: str | None) -> set[str]:
@@ -64,10 +64,10 @@ def dict_module_name_to_model_name(
 
 
 def dict_related_model_to_related_name(
-    registry: type[Record], links: bool = False, instance: str | None = None
+    registry: type[SQLRecord], links: bool = False, instance: str | None = None
 ) -> dict[str, str]:
-    def include(model: Record):
-        return not links != issubclass(model, LinkORM)
+    def include(model: SQLRecord):
+        return not links != issubclass(model, IsLink)
 
     schema_modules = get_schema_modules(instance)
 
@@ -88,7 +88,7 @@ def dict_related_model_to_related_name(
     return d
 
 
-def get_related_name(features_type: type[Record]) -> str:
+def get_related_name(features_type: type[SQLRecord]) -> str:
     from lamindb.models.schema import Schema
 
     candidates = [
@@ -100,7 +100,7 @@ def get_related_name(features_type: type[Record]) -> str:
         raise ValueError(
             f"Can't create feature sets from {features_type.__name__} because it's not"
             " related to it!\nYou need to create a link model between Schema and"
-            " your Record in your custom module.\nTo do so, add a"
+            " your SQLRecord in your custom module.\nTo do so, add a"
             " line:\n_feature_sets = models.ManyToMany(Schema,"
             " related_name='mythings')\n"
         )