lamindb 0.77.3__py3-none-any.whl → 1.0rc1__py3-none-any.whl

lamindb/_parents.py

@@ -5,15 +5,22 @@ from typing import TYPE_CHECKING, Literal
 
 import lamindb_setup as ln_setup
 from lamin_utils import logger
-from lnschema_core import Artifact, Collection, Record, Run, Transform
-from lnschema_core.models import HasParents, format_field_value
+
+from lamindb.models import (
+    Artifact,
+    Collection,
+    HasParents,
+    Record,
+    Run,
+    Transform,
+    format_field_value,
+)
 
 from ._record import get_name_field
 from ._utils import attach_func_to_class_method
 
 if TYPE_CHECKING:
-    from lnschema_core.types import StrField
-
+    from lamindb.base.types import StrField
     from lamindb.core import QuerySet
 
 LAMIN_GREEN_LIGHTER = "#10b981"
@@ -25,7 +32,7 @@ TRANSFORM_EMOJIS = {
     "pipeline": "🧩",
     "script": "📝",
     "function": "🔧",
-    "glue": "🧲",
+    "linker": "🧲",
 }
 is_run_from_ipython = getattr(builtins, "__IPYTHON__", False)
 
@@ -342,8 +349,8 @@ def _record_label(record: Record, field: str | None = None):
             rf' FACE="Monospace">uid={record.uid}<BR/>version={record.version}</FONT>>'
         )
     elif isinstance(record, Run):
-        if record.transform.name:
-            name = f'{record.transform.name.replace("&", "&amp;")}'
+        if record.transform.description:
+            name = f'{record.transform.description.replace("&", "&amp;")}'
         elif record.transform.key:
             name = f'{record.transform.key.replace("&", "&amp;")}'
         else:
@@ -395,22 +402,22 @@ def _get_all_parent_runs(data: Artifact | Collection) -> list:
             inputs_run = (
                 r.__getattribute__(f"input_{name}s")
                 .all()
-                .filter(visibility__in=[0, 1])
+                .filter(_branch_code__in=[0, 1])
                 .list()
             )
             if name == "artifact":
                 inputs_run += (
-                    r.input_collections.all().filter(visibility__in=[0, 1]).list()
+                    r.input_collections.all().filter(_branch_code__in=[0, 1]).list()
                 )
             outputs_run = (
                 r.__getattribute__(f"output_{name}s")
                 .all()
-                .filter(visibility__in=[0, 1])
+                .filter(_branch_code__in=[0, 1])
                 .list()
             )
             if name == "artifact":
                 outputs_run += (
-                    r.output_collections.all().filter(visibility__in=[0, 1]).list()
+                    r.output_collections.all().filter(_branch_code__in=[0, 1]).list()
                 )
             # if inputs are outputs artifacts are the same, will result infinite loop
             # so only show as outputs
@@ -444,7 +451,7 @@ def _get_all_child_runs(data: Artifact | Collection) -> list:
             {
                 f.run
                 for f in data.run.output_collections.all()
-                .filter(visibility__in=[0, 1])
+                .filter(_branch_code__in=[0, 1])
                 .all()
             }
         )
@@ -455,24 +462,24 @@ def _get_all_child_runs(data: Artifact | Collection) -> list:
             inputs_run = (
                 r.__getattribute__(f"input_{name}s")
                 .all()
-                .filter(visibility__in=[0, 1])
+                .filter(_branch_code__in=[0, 1])
                 .list()
             )
             if name == "artifact":
                 inputs_run += (
-                    r.input_collections.all().filter(visibility__in=[0, 1]).list()
+                    r.input_collections.all().filter(_branch_code__in=[0, 1]).list()
                 )
             run_inputs_outputs += [(inputs_run, r)]
 
             outputs_run = (
                 r.__getattribute__(f"output_{name}s")
                 .all()
-                .filter(visibility__in=[0, 1])
+                .filter(_branch_code__in=[0, 1])
                 .list()
             )
             if name == "artifact":
                 outputs_run += (
-                    r.output_collections.all().filter(visibility__in=[0, 1]).list()
+                    r.output_collections.all().filter(_branch_code__in=[0, 1]).list()
                 )
             run_inputs_outputs += [(r, outputs_run)]
 

lamindb/_query_manager.py

@@ -5,13 +5,13 @@ from typing import TYPE_CHECKING, NamedTuple
 from django.db import models
 from lamin_utils import logger
 from lamindb_setup.core._docs import doc_args
-from lnschema_core.models import Record
 
-from .core._feature_manager import get_feature_set_by_slot_
+from lamindb.models import Record
+
 from .core._settings import settings
 
 if TYPE_CHECKING:
-    from lnschema_core.types import StrField
+    from lamindb.base.types import StrField
 
 
 class QueryManager(models.Manager):

lamindb/_query_set.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import re
+import warnings
 from collections import UserList
 from collections.abc import Iterable
 from collections.abc import Iterable as IterableType
@@ -12,17 +13,17 @@ from django.db.models import F, ForeignKey, ManyToManyField
 from django.db.models.fields.related import ForeignObjectRel
 from lamin_utils import logger
 from lamindb_setup.core._docs import doc_args
-from lnschema_core.models import (
+
+from lamindb.models import (
     Artifact,
     CanCurate,
     Collection,
     Feature,
     IsVersioned,
     Record,
-    Registry,
     Run,
+    Schema,
     Transform,
-    VisibilityChoice,
 )
 
 from .core.exceptions import DoesNotExist
@@ -32,7 +33,7 @@ T = TypeVar("T")
 if TYPE_CHECKING:
     from collections.abc import Iterable
 
-    from lnschema_core.types import ListLike, StrField
+    from lamindb.base.types import ListLike, StrField
 
 
 class MultipleResultsFound(Exception):
@@ -79,6 +80,58 @@ def one_helper(self):
         return self[0]
 
 
+def get_backward_compat_filter_kwargs(queryset, expressions):
+    if queryset.model in {Collection, Transform}:
+        name_mappings = {
+            "name": "key",
+            "visibility": "_branch_code",  # for convenience (and backward compat <1.0)
+        }
+    elif queryset.model == Artifact:
+        name_mappings = {
+            "n_objects": "n_files",
+            "visibility": "_branch_code",  # for convenience (and backward compat <1.0)
+            "transform": "run__transform",  # for convenience (and backward compat <1.0)
+            "feature_sets": "_schemas_m2m",
+            "type": "kind",
+            "_accessor": "otype",
+        }
+    elif queryset.model == Schema:
+        name_mappings = {
+            "registry": "itype",
+            "artifacts": "_artifacts_m2m",  # will raise warning when we start to migrate over
+        }
+    else:
+        return expressions
+    was_list = False
+    if isinstance(expressions, list):
+        # make a dummy dictionary
+        was_list = True
+        expressions = {field: True for field in expressions}
+    mapped = {}
+    for field, value in expressions.items():
+        parts = field.split("__")
+        if parts[0] in name_mappings:
+            if parts[0] not in {
+                "transform",
+                "visibility",
+                "feature_sets",
+                "schemas",
+                "artifacts",
+            }:
+                warnings.warn(
+                    f"{name_mappings[parts[0]]} is deprecated, please query for {parts[0]} instead",
+                    DeprecationWarning,
+                    stacklevel=2,
+                )
+            new_field = name_mappings[parts[0]] + (
+                "__" + "__".join(parts[1:]) if len(parts) > 1 else ""
+            )
+            mapped[new_field] = value
+        else:
+            mapped[field] = value
+    return list(mapped.keys()) if was_list else mapped
+
+
 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):
@@ -105,23 +158,26 @@ def process_expressions(queryset: QuerySet, expressions: dict) -> dict:
 
         return key, value
 
-    if queryset.model in {Artifact, Collection}:
-        # visibility is set to 0 unless expressions contains id or uid equality
+    expressions = get_backward_compat_filter_kwargs(
+        queryset,
+        expressions,
+    )
+
+    if issubclass(queryset.model, Record):
+        # _branch_code is set to 0 unless expressions contains id or uid
         if not (
             "id" in expressions
             or "uid" in expressions
             or "uid__startswith" in expressions
         ):
-            visibility = "visibility"
-            if not any(e.startswith(visibility) for e in expressions):
-                expressions[visibility] = (
-                    VisibilityChoice.default.value
-                )  # default visibility
-            # if visibility is None, do not apply a filter
+            _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
             # otherwise, it would mean filtering for NULL values, which doesn't make
             # sense for a non-NULLABLE column
-            elif visibility in expressions and expressions[visibility] is None:
-                expressions.pop(visibility)
+            elif _branch_code in expressions and expressions[_branch_code] is None:
+                expressions.pop(_branch_code)
     if queryset._db is not None:
         # only check for database mismatch if there is a defined database on the
         # queryset
@@ -213,6 +269,8 @@ def get_basic_field_names(
         "created_at",
         "created_by_id",
         "updated_at",
+        "_aux",
+        "_branch_code",
     ]:
         if field_name in field_names:
             field_names.remove(field_name)
@@ -242,17 +300,17 @@ def get_feature_annotate_kwargs(show_features: bool | list[str]) -> dict[str, An
     link_models_on_models = {
         getattr(
             Artifact, obj.related_name
-        ).through.__get_name_with_schema__(): obj.related_model.__get_name_with_schema__()
+        ).through.__get_name_with_module__(): obj.related_model.__get_name_with_module__()
         for obj in Artifact._meta.related_objects
-        if obj.related_model.__get_name_with_schema__() in cat_feature_types
+        if obj.related_model.__get_name_with_module__() in cat_feature_types
     }
     link_models_on_models["ArtifactULabel"] = "ULabel"
     link_attributes_on_models = {
         obj.related_name: link_models_on_models[
-            obj.related_model.__get_name_with_schema__()
+            obj.related_model.__get_name_with_module__()
         ]
         for obj in Artifact._meta.related_objects
-        if obj.related_model.__get_name_with_schema__() in link_models_on_models
+        if obj.related_model.__get_name_with_module__() in link_models_on_models
     }
     # Prepare Django's annotate for features
     annotate_kwargs = {}
@@ -478,7 +536,9 @@ class QuerySet(models.QuerySet):
             include = []
         elif isinstance(include, str):
             include = [include]
+        include = get_backward_compat_filter_kwargs(self, include)
         field_names = get_basic_field_names(self, include, features)
+
         annotate_kwargs = {}
         if features:
             annotate_kwargs.update(get_feature_annotate_kwargs(features))
@@ -490,6 +550,7 @@ class QuerySet(models.QuerySet):
             queryset = self.annotate(**annotate_kwargs)
         else:
             queryset = self
+
         df = pd.DataFrame(queryset.values(*field_names, *list(annotate_kwargs.keys())))
         if len(df) == 0:
             df = pd.DataFrame({}, columns=field_names)
@@ -500,6 +561,12 @@ class QuerySet(models.QuerySet):
         pk_column_name = pk_name if pk_name in df.columns else f"{pk_name}_id"
         if pk_column_name in df_reshaped.columns:
             df_reshaped = df_reshaped.set_index(pk_column_name)
+
+        # Compatibility code
+        df_reshaped.columns = df_reshaped.columns.str.replace(
+            r"_schemas_m2m", "feature_sets", regex=True
+        )
+
         return df_reshaped
 
     def delete(self, *args, **kwargs):

lamindb/_record.py

@@ -3,14 +3,21 @@ from __future__ import annotations
 import builtins
 import re
 from functools import reduce
+from pathlib import PurePosixPath
 from typing import TYPE_CHECKING, NamedTuple
 
 import dj_database_url
 import lamindb_setup as ln_setup
-from django.core.exceptions import FieldDoesNotExist
 from django.core.exceptions import ValidationError as DjangoValidationError
 from django.db import connections, transaction
-from django.db.models import F, IntegerField, Manager, Q, QuerySet, TextField, Value
+from django.db.models import (
+    IntegerField,
+    Manager,
+    Q,
+    QuerySet,
+    TextField,
+    Value,
+)
 from django.db.models.functions import Cast, Coalesce
 from django.db.models.lookups import (
     Contains,
@@ -32,28 +39,37 @@ from lamindb_setup._connect_instance import (
 from lamindb_setup.core._docs import doc_args
 from lamindb_setup.core._hub_core import connect_instance_hub
 from lamindb_setup.core._settings_store import instance_settings_file
-from lnschema_core.models import (
+from lamindb_setup.core.upath import extract_suffix_from_path
+
+from lamindb.base.validation import FieldValidationError
+from lamindb.models import (
     Artifact,
+    BasicRecord,
+    CanCurate,
     Collection,
     Feature,
-    FeatureSet,
     IsVersioned,
     Param,
     Record,
     Run,
+    Schema,
     Transform,
     ULabel,
     ValidateFields,
 )
-from lnschema_core.validation import FieldValidationError
 
 from ._utils import attach_func_to_class_method
 from .core._settings import settings
-from .core.exceptions import RecordNameChangeIntegrityError, ValidationError
+from .core.exceptions import (
+    InvalidArgument,
+    RecordNameChangeIntegrityError,
+    ValidationError,
+)
 
 if TYPE_CHECKING:
     import pandas as pd
-    from lnschema_core.types import ListLike, StrField
+
+    from lamindb.base.types import StrField
 
 
 IPYTHON = getattr(builtins, "__IPYTHON__", False)
@@ -76,7 +92,7 @@ def update_attributes(record: Record, attributes: dict[str, str]):
 
 
 def validate_fields(record: Record, kwargs):
-    from lnschema_core.validation import validate_literal_fields
+    from lamindb.base.validation import validate_literal_fields
 
     # validate required fields
     # a "required field" is a Django field that has `null=False, default=None`
@@ -98,7 +114,7 @@ def validate_fields(record: Record, kwargs):
         Run,
         ULabel,
         Feature,
-        FeatureSet,
+        Schema,
         Param,
     }:
         uid_max_length = record.__class__._meta.get_field(
@@ -153,7 +169,13 @@ def __init__(record: Record, *args, **kwargs):
         has_consciously_provided_uid = False
         if "_has_consciously_provided_uid" in kwargs:
             has_consciously_provided_uid = kwargs.pop("_has_consciously_provided_uid")
-        if settings.creation.search_names and not has_consciously_provided_uid:
+        if (
+            isinstance(
+                record, (CanCurate, Collection, Transform)
+            )  # Collection is only temporary because it'll get a key field
+            and settings.creation.search_names
+            and not has_consciously_provided_uid
+        ):
             name_field = getattr(record, "_name_field", "name")
             match = suggest_records_with_similar_names(record, name_field, kwargs)
             if match:
@@ -184,7 +206,7 @@ def __init__(record: Record, *args, **kwargs):
                     )
                     init_self_from_db(record, existing_record)
                     return None
-        super(Record, record).__init__(**kwargs)
+        super(BasicRecord, record).__init__(**kwargs)
         if isinstance(record, ValidateFields):
             # this will trigger validation against django validators
             try:
@@ -199,8 +221,9 @@ def __init__(record: Record, *args, **kwargs):
         raise ValueError("please provide keyword arguments, not plain arguments")
     else:
         # object is loaded from DB (**kwargs could be omitted below, I believe)
-        super(Record, record).__init__(*args, **kwargs)
+        super(BasicRecord, record).__init__(*args, **kwargs)
         _store_record_old_name(record)
+        _store_record_old_key(record)
 
 
 def _format_django_validation_error(record: Record, e: DjangoValidationError):
@@ -285,6 +308,9 @@ def _search(
     using_key: str | None = None,
     truncate_string: bool = False,
 ) -> QuerySet:
+    if string is None:
+        raise ValueError("Cannot search for None value! Please pass a valid string.")
+
     input_queryset = _queryset(cls, using_key=using_key)
     registry = input_queryset.model
     name_field = getattr(registry, "_name_field", "name")
@@ -526,14 +552,14 @@ def using(
                 f"Failed to load instance {instance}, please check your permissions!"
             )
         iresult, _ = result
-        source_schema = {
-            schema for schema in iresult["schema_str"].split(",") if schema != ""
+        source_module = {
+            modules for modules in iresult["schema_str"].split(",") if modules != ""
         }  # type: ignore
-        target_schema = ln_setup.settings.instance.schema
-        if not source_schema.issubset(target_schema):
-            missing_members = source_schema - target_schema
+        target_module = ln_setup.settings.instance.modules
+        if not source_module.issubset(target_module):
+            missing_members = source_module - target_module
             logger.warning(
-                f"source schema has additional modules: {missing_members}\nconsider mounting these schema modules to transfer all metadata"
+                f"source modules has additional modules: {missing_members}\nconsider mounting these registry modules to transfer all metadata"
             )
         cache_filepath.write_text(f"{iresult['lnid']}\n{iresult['schema_str']}")  # type: ignore
         settings_file = instance_settings_file(name, owner)
@@ -541,7 +567,7 @@ def using(
     else:
         isettings = load_instance_settings(settings_file)
         db = isettings.db
-        cache_filepath.write_text(f"{isettings.uid}\n{','.join(isettings.schema)}")  # type: ignore
+        cache_filepath.write_text(f"{isettings.uid}\n{','.join(isettings.modules)}")  # type: ignore
     add_db_connection(db, instance)
     return QuerySet(model=cls, using=instance)
 
@@ -550,6 +576,7 @@ REGISTRY_UNIQUE_FIELD = {
     "storage": "root",
     "feature": "name",
     "ulabel": "name",
+    "space": "name",  # TODO: this should be updated with the currently used space instead during transfer
 }
 
 
@@ -585,7 +612,6 @@ def update_fk_to_default_db(
 FKBULK = [
     "organism",
     "source",
-    "_source_code_artifact",  # Transform
     "report",  # Run
 ]
 
@@ -598,8 +624,6 @@ def transfer_fk_to_default_db_bulk(
 
 
 def get_transfer_run(record) -> Run:
-    from lamindb_setup import settings as setup_settings
-
     from lamindb.core._context import context
     from lamindb.core._data import WARNING_RUN_TRANSFORM
 
@@ -619,18 +643,20 @@ def get_transfer_run(record) -> Run:
             uid=uid, name=f"Transfer from `{slug}`", key=key, type="function"
         ).save()
         settings.creation.search_names = search_names
-    # use the global run context to get the parent run id
+    # use the global run context to get the initiated_by_run run id
     if context.run is not None:
-        parent = context.run
+        initiated_by_run = context.run
     else:
         if not settings.creation.artifact_silence_missing_run_warning:
             logger.warning(WARNING_RUN_TRANSFORM)
-        parent = None
+        initiated_by_run = None
     # it doesn't seem to make sense to create new runs for every transfer
-    run = Run.filter(transform=transform, parent=parent).one_or_none()
+    run = Run.filter(
+        transform=transform, initiated_by_run=initiated_by_run
+    ).one_or_none()
     if run is None:
-        run = Run(transform=transform, parent=parent).save()
-        run.parent = parent  # so that it's available in memory
+        run = Run(transform=transform, initiated_by_run=initiated_by_run).save()
+        run.initiated_by_run = initiated_by_run  # so that it's available in memory
     return run
 
 
@@ -721,14 +747,19 @@ def save(self, *args, **kwargs) -> Record:
                 revises._revises = None  # ensure we don't start a recursion
                 revises.save()
                 check_name_change(self)
-                super(Record, self).save(*args, **kwargs)
+                check_key_change(self)
+                super(BasicRecord, self).save(*args, **kwargs)
                 _store_record_old_name(self)
+                _store_record_old_key(self)
             self._revises = None
         # save unversioned record
         else:
             check_name_change(self)
-            super(Record, self).save(*args, **kwargs)
+            check_key_change(self)
+            super(BasicRecord, self).save(*args, **kwargs)
+            # update _old_name and _old_key after saving
             _store_record_old_name(self)
+            _store_record_old_key(self)
     # perform transfer of many-to-many fields
     # only supported for Artifact and Collection records
     if db is not None and db != "default" and using_key is None:
@@ -741,7 +772,7 @@ def save(self, *args, **kwargs) -> Record:
         if hasattr(self, "labels"):
             from copy import copy
 
-            from lnschema_core.models import FeatureManager
+            from lamindb.models import FeatureManager
 
             # here we go back to original record on the source database
             self_on_db = copy(self)
@@ -759,19 +790,33 @@ def save(self, *args, **kwargs) -> Record:
 def _store_record_old_name(record: Record):
     # writes the name to the _name attribute, so we can detect renaming upon save
     if hasattr(record, "_name_field"):
-        record._name = getattr(record, record._name_field)
+        record._old_name = getattr(record, record._name_field)
+
+
+def _store_record_old_key(record: Record):
+    # writes the key to the _old_key attribute, so we can detect key changes upon save
+    if isinstance(record, (Artifact, Transform)):
+        record._old_key = record.key
 
 
 def check_name_change(record: Record):
     """Warns if a record's name has changed."""
     if (
         not record.pk
-        or not hasattr(record, "_name")
+        or not hasattr(record, "_old_name")
         or not hasattr(record, "_name_field")
     ):
         return
 
-    old_name = record._name
+    # checked in check_key_change or not checked at all
+    if isinstance(record, (Artifact, Collection, Transform)):
+        return
+
+    # renaming feature sets is not checked
+    if isinstance(record, Schema):
+        return
+
+    old_name = record._old_name
     new_name = getattr(record, record._name_field)
     registry = record.__class__.__name__
 
@@ -785,13 +830,13 @@ def check_name_change(record: Record):
                 .exclude(feature_id=None)  # must have a feature
                 .exclude(
                     feature_ref_is_name=None
-                )  # must be linked via Curator and therefore part of a featureset
+                )  # must be linked via Curator and therefore part of a schema
                 .distinct()
             )
             artifact_ids = linked_records.list("artifact__uid")
             n = len(artifact_ids)
-            s = "s" if n > 1 else ""
             if n > 0:
+                s = "s" if n > 1 else ""
                 logger.error(
                     f"You are trying to {colors.red('rename label')} from '{old_name}' to '{new_name}'!\n"
                     f"   → The following {n} artifact{s} {colors.red('will no longer be validated')}: {artifact_ids}\n\n"
@@ -805,13 +850,13 @@ def check_name_change(record: Record):
 
         # when a feature is renamed
         elif isinstance(record, Feature):
-            # only internal features are associated with featuresets
-            linked_artifacts = Artifact.filter(feature_sets__features=record).list(
+            # only internal features are associated with schemas
+            linked_artifacts = Artifact.filter(_schemas_m2m__features=record).list(
                 "uid"
             )
             n = len(linked_artifacts)
-            s = "s" if n > 1 else ""
             if n > 0:
+                s = "s" if n > 1 else ""
                 logger.error(
                     f"You are trying to {colors.red('rename feature')} from '{old_name}' to '{new_name}'!\n"
                     f"   → The following {n} artifact{s} {colors.red('will no longer be validated')}: {linked_artifacts}\n\n"
@@ -824,6 +869,33 @@ def check_name_change(record: Record):
                 raise RecordNameChangeIntegrityError
 
 
+def check_key_change(record: Artifact | Transform):
+    """Errors if a record's key has falsely changed."""
+    if not isinstance(record, Artifact) or not hasattr(record, "_old_key"):
+        return
+
+    old_key = record._old_key or ""
+    new_key = record.key or ""
+
+    if old_key != new_key:
+        if not record._key_is_virtual:
+            raise InvalidArgument(
+                f"Changing a non-virtual key of an artifact is not allowed! Tried to change key from '{old_key}' to '{new_key}'."
+            )
+        old_key_suffix = (
+            record.suffix
+            if record.suffix
+            else extract_suffix_from_path(PurePosixPath(old_key), arg_name="key")
+        )
+        new_key_suffix = extract_suffix_from_path(
+            PurePosixPath(new_key), arg_name="key"
+        )
+        if old_key_suffix != new_key_suffix:
+            raise InvalidArgument(
+                f"The suffix '{new_key_suffix}' of the provided key is incorrect, it should be '{old_key_suffix}'."
+            )
+
+
 def delete(self) -> None:
     """Delete the record."""
     # note that the logic below does not fire if a record is moved to the trash
@@ -843,10 +915,10 @@ def delete(self) -> None:
             new_latest.is_latest = True
             with transaction.atomic():
                 new_latest.save()
-                super(Record, self).delete()
+                super(BasicRecord, self).delete()
             logger.warning(f"new latest version is {new_latest}")
             return None
-    super(Record, self).delete()
+    super(BasicRecord, self).delete()
 
 
 METHOD_NAMES = [
@@ -871,4 +943,5 @@ if ln_setup._TESTING:  # type: ignore
     }
 
 for name in METHOD_NAMES:
+    attach_func_to_class_method(name, BasicRecord, globals())
     attach_func_to_class_method(name, Record, globals())