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

lamindb/_record.py

@@ -1,15 +1,23 @@
 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,
@@ -31,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)
@@ -75,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`
@@ -97,7 +114,7 @@ def validate_fields(record: Record, kwargs):
         Run,
         ULabel,
         Feature,
-        FeatureSet,
+        Schema,
         Param,
     }:
         uid_max_length = record.__class__._meta.get_field(
@@ -152,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:
@@ -183,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:
@@ -198,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):
@@ -284,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")
@@ -316,6 +343,7 @@ def _search(
             string = string[:n_80_pct]
 
     string = string.strip()
+    string_escape = re.escape(string)
 
     exact_lookup = Exact if case_sensitive else IExact
     regex_lookup = Regex if case_sensitive else IRegex
@@ -334,28 +362,28 @@ def _search(
         exact_rank = Cast(exact_expr, output_field=IntegerField()) * 200
         ranks.append(exact_rank)
         # exact synonym
-        synonym_expr = regex_lookup(field_expr, rf"(?:^|.*\|){string}(?:\|.*|$)")
+        synonym_expr = regex_lookup(field_expr, rf"(?:^|.*\|){string_escape}(?:\|.*|$)")
         synonym_rank = Cast(synonym_expr, output_field=IntegerField()) * 200
         ranks.append(synonym_rank)
         # match as sub-phrase
         sub_expr = regex_lookup(
-            field_expr, rf"(?:^|.*[ \|\.,;:]){string}(?:[ \|\.,;:].*|$)"
+            field_expr, rf"(?:^|.*[ \|\.,;:]){string_escape}(?:[ \|\.,;:].*|$)"
         )
         sub_rank = Cast(sub_expr, output_field=IntegerField()) * 10
         ranks.append(sub_rank)
         # startswith and avoid matching string with " " on the right
         # mostly for truncated
         startswith_expr = regex_lookup(
-            field_expr, rf"(?:^|.*\|){string}[^ ]*(?:\|.*|$)"
+            field_expr, rf"(?:^|.*\|){string_escape}[^ ]*(?:\|.*|$)"
         )
         startswith_rank = Cast(startswith_expr, output_field=IntegerField()) * 8
         ranks.append(startswith_rank)
         # match as sub-phrase from the left, mostly for truncated
-        right_expr = regex_lookup(field_expr, rf"(?:^|.*[ \|]){string}.*")
+        right_expr = regex_lookup(field_expr, rf"(?:^|.*[ \|]){string_escape}.*")
         right_rank = Cast(right_expr, output_field=IntegerField()) * 2
         ranks.append(right_rank)
         # match as sub-phrase from the right
-        left_expr = regex_lookup(field_expr, rf".*{string}(?:$|[ \|\.,;:].*)")
+        left_expr = regex_lookup(field_expr, rf".*{string_escape}(?:$|[ \|\.,;:].*)")
         left_rank = Cast(left_expr, output_field=IntegerField()) * 2
         ranks.append(left_rank)
         # simple contains filter
@@ -524,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)
@@ -539,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)
 
@@ -548,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
 }
 
 
@@ -583,7 +612,6 @@ def update_fk_to_default_db(
 FKBULK = [
     "organism",
     "source",
-    "_source_code_artifact",  # Transform
     "report",  # Run
 ]
 
@@ -596,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
 
@@ -617,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
 
 
@@ -719,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:
@@ -739,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)
@@ -757,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__
 
@@ -783,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"
@@ -803,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"
@@ -822,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
@@ -841,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 = [
@@ -869,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())

lamindb/_run.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from lnschema_core.models import ParamManager, Run, Transform
+from lamindb.models import ParamManager, Run, Transform
 
 
 def __init__(run: Run, *args, **kwargs):
@@ -18,7 +18,7 @@ def __init__(run: Run, *args, **kwargs):
     reference_type: str | None = (
         kwargs.pop("reference_type") if "reference_type" in kwargs else None
     )
-    parent: Run | None = kwargs.pop("parent", None)
+    initiated_by_run: Run | None = kwargs.pop("initiated_by_run", None)
     if transform is None:
         raise TypeError("Pass transform parameter")
     if transform._state.adding:
@@ -27,7 +27,7 @@ def __init__(run: Run, *args, **kwargs):
     super(Run, run).__init__(
         transform=transform,
         reference=reference,
-        parent=parent,
+        initiated_by_run=initiated_by_run,
         reference_type=reference_type,
     )
 

lamindb/_save.py

@@ -5,15 +5,14 @@ import shutil
 import traceback
 from collections import defaultdict
 from datetime import datetime
-from functools import partial
-from typing import TYPE_CHECKING, overload
+from typing import TYPE_CHECKING
 
-import lamindb_setup
-from django.db import IntegrityError, transaction
+from django.db import transaction
 from django.utils.functional import partition
 from lamin_utils import logger
 from lamindb_setup.core.upath import LocalPathClasses
-from lnschema_core.models import Artifact, Record
+
+from lamindb.models import Artifact, Record
 
 from .core._settings import settings
 from .core.storage.paths import (
@@ -64,7 +63,7 @@ def save(records: Iterable[Record], ignore_conflicts: bool | None = False) -> No
         Update a single existing record:
 
         >>> transform = ln.Transform.get("0Cb86EZj")
-        >>> transform.name = "New name"
+        >>> transform.description = "New description"
         >>> transform.save()
 
     """
@@ -184,10 +183,17 @@ def copy_or_move_to_cache(
         return None
     # non-local storage_path further
     if local_path != cache_path:
-        cache_path.parent.mkdir(parents=True, exist_ok=True)
-        if cache_dir in local_path.parents:
+        if cache_path.exists():
+            logger.warning(
+                f"The cache path {cache_path.as_posix()} already exists, replacing it."
+            )
             if cache_path.is_dir():
                 shutil.rmtree(cache_path)
+            else:
+                cache_path.unlink()
+        else:
+            cache_path.parent.mkdir(parents=True, exist_ok=True)
+        if cache_dir in local_path.parents:
             local_path.replace(cache_path)
         else:
             if is_dir:

lamindb/{_feature_set.py → _schema.py}

@@ -7,14 +7,16 @@ import numpy as np
 from lamin_utils import logger
 from lamindb_setup.core._docs import doc_args
 from lamindb_setup.core.hashing import hash_set
-from lnschema_core import Feature, FeatureSet, Record, ids
-from lnschema_core.types import FieldAttr, ListLike
+
+from lamindb.base import ids
+from lamindb.base.types import FieldAttr, ListLike
+from lamindb.models import Feature, Record, Schema
 
 from ._feature import convert_pandas_dtype_to_lamin_dtype
 from ._record import init_self_from_db
 from ._utils import attach_func_to_class_method
 from .core.exceptions import ValidationError
-from .core.schema import (
+from .core.relations import (
     dict_related_model_to_related_name,
     get_related_name,
 )
@@ -47,7 +49,7 @@ def validate_features(features: list[Record]) -> Record:
         )
     feature_types = {feature.__class__ for feature in features}
     if len(feature_types) > 1:
-        raise TypeError("feature_set can only contain a single type")
+        raise TypeError("schema can only contain a single type")
     for feature in features:
         if feature._state.adding:
             raise ValueError("Can only construct feature sets from validated features")
@@ -56,7 +58,7 @@ def validate_features(features: list[Record]) -> Record:
 
 def __init__(self, *args, **kwargs):
     if len(args) == len(self._meta.concrete_fields):
-        super(FeatureSet, self).__init__(*args, **kwargs)
+        super(Schema, self).__init__(*args, **kwargs)
         return None
     # now we proceed with the user-facing constructor
     if len(args) > 1:
@@ -72,29 +74,29 @@ def __init__(self, *args, **kwargs):
         dtype = None if features_registry == Feature else NUMBER_TYPE
     n_features = len(features)
     features_hash = hash_set({feature.uid for feature in features})
-    feature_set = FeatureSet.filter(hash=features_hash).one_or_none()
-    if feature_set is not None:
-        logger.debug(f"loaded: {feature_set}")
-        init_self_from_db(self, feature_set)
+    schema = Schema.filter(hash=features_hash).one_or_none()
+    if schema is not None:
+        logger.debug(f"loaded: {schema}")
+        init_self_from_db(self, schema)
         return None
     else:
         hash = features_hash
     self._features = (get_related_name(features_registry), features)
 
-    super(FeatureSet, self).__init__(
+    super(Schema, self).__init__(
         uid=ids.base62_20(),
         name=name,
         dtype=get_type_str(dtype),
         n=n_features,
-        registry=features_registry.__get_name_with_schema__(),
+        registry=features_registry.__get_name_with_module__(),
         hash=hash,
     )
 
 
-@doc_args(FeatureSet.save.__doc__)
-def save(self, *args, **kwargs) -> FeatureSet:
+@doc_args(Schema.save.__doc__)
+def save(self, *args, **kwargs) -> Schema:
     """{}"""  # noqa: D415
-    super(FeatureSet, self).save(*args, **kwargs)
+    super(Schema, self).save(*args, **kwargs)
     if hasattr(self, "_features"):
         related_name, records = self._features
         getattr(self, related_name).set(records)
@@ -110,7 +112,7 @@ def get_type_str(dtype: str | None) -> str | None:
 
 
 @classmethod  # type:ignore
-@doc_args(FeatureSet.from_values.__doc__)
+@doc_args(Schema.from_values.__doc__)
 def from_values(
     cls,
     values: ListLike,
@@ -121,7 +123,7 @@ def from_values(
     organism: Record | str | None = None,
     source: Record | None = None,
     raise_validation_error: bool = True,
-) -> FeatureSet:
+) -> Schema:
     """{}"""  # noqa: D415
     if not isinstance(field, FieldAttr):
         raise TypeError("Argument `field` must be a Record field, e.g., `Feature.name`")
@@ -152,16 +154,16 @@ def from_values(
         organism=organism,
         source=source,
     )
-    feature_set = FeatureSet(
+    schema = Schema(
         features=validated_features,
         name=name,
         dtype=get_type_str(type),
     )
-    return feature_set
+    return schema
 
 
 @classmethod  # type:ignore
-@doc_args(FeatureSet.from_df.__doc__)
+@doc_args(Schema.from_df.__doc__)
 def from_df(
     cls,
     df: pd.DataFrame,
@@ -170,7 +172,7 @@ def from_df(
     mute: bool = False,
     organism: Record | str | None = None,
     source: Record | None = None,
-) -> FeatureSet | None:
+) -> Schema | None:
     """{}"""  # noqa: D415
     registry = field.field.model
     validated = registry.validate(df.columns, field=field, mute=mute, organism=organism)
@@ -182,7 +184,7 @@ def from_df(
         validated_features = Feature.from_values(
             df.columns, field=field, organism=organism
         )
-        feature_set = FeatureSet(validated_features, name=name, dtype=None)
+        schema = Schema(validated_features, name=name, dtype=None)
     else:
         dtypes = [col.dtype for (_, col) in df.loc[:, validated].items()]
         if len(set(dtypes)) != 1:
@@ -194,16 +196,16 @@ def from_df(
             organism=organism,
             source=source,
         )
-        feature_set = FeatureSet(
+        schema = Schema(
             features=validated_features,
             name=name,
             dtype=get_type_str(dtype),
         )
-    return feature_set
+    return schema
 
 
 @property  # type: ignore
-@doc_args(FeatureSet.members.__doc__)
+@doc_args(Schema.members.__doc__)
 def members(self) -> QuerySet:
     """{}"""  # noqa: D415
     if self._state.adding:
@@ -216,11 +218,11 @@ def members(self) -> QuerySet:
     return self.__getattribute__(related_name).all()
 
 
-def _get_related_name(self: FeatureSet) -> str:
-    feature_sets_related_models = dict_related_model_to_related_name(
+def _get_related_name(self: Schema) -> str:
+    _schemas_m2m_related_models = dict_related_model_to_related_name(
         self, instance=self._state.db
     )
-    related_name = feature_sets_related_models.get(self.registry)
+    related_name = _schemas_m2m_related_models.get(self.itype)
     return related_name
 
 
@@ -235,13 +237,14 @@ if ln_setup._TESTING:
     from inspect import signature
 
     SIGS = {
-        name: signature(getattr(FeatureSet, name))
+        name: signature(getattr(Schema, name))
         for name in METHOD_NAMES
         if name != "__init__"
     }
 
 for name in METHOD_NAMES:
-    attach_func_to_class_method(name, FeatureSet, globals())
+    attach_func_to_class_method(name, Schema, globals())
 
-FeatureSet.members = members
-FeatureSet._get_related_name = _get_related_name
+Schema.members = members
+Schema._get_related_name = _get_related_name
+Schema.feature_sets = Schema._artifacts_m2m  # backward compat

lamindb/_storage.py

@@ -1,6 +1,7 @@
 from lamindb_setup.core._docs import doc_args
 from lamindb_setup.core.upath import UPath, create_path
-from lnschema_core import Storage
+
+from lamindb.models import Storage
 
 
 @property  # type: ignore