lamindb 0.76.15__py3-none-any.whl → 0.77.0__py3-none-any.whl

lamindb/_record.py

@@ -1,12 +1,26 @@
 from __future__ import annotations
 
 import builtins
+from functools import reduce
 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 IntegerField, Manager, Q, QuerySet, Value
+from django.db.models import F, IntegerField, Manager, Q, QuerySet, TextField, Value
+from django.db.models.functions import Cast, Coalesce
+from django.db.models.lookups import (
+    Contains,
+    Exact,
+    IContains,
+    IExact,
+    IRegex,
+    IStartsWith,
+    Regex,
+    StartsWith,
+)
 from lamin_utils import colors, logger
 from lamin_utils._lookup import Lookup
 from lamindb_setup._connect_instance import (
@@ -17,11 +31,24 @@ 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 Artifact, Feature, IsVersioned, Record, Run, Transform
+from lnschema_core.models import (
+    Artifact,
+    Collection,
+    Feature,
+    FeatureSet,
+    IsVersioned,
+    Param,
+    Record,
+    Run,
+    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
+from .core.exceptions import RecordNameChangeIntegrityError, ValidationError
 
 if TYPE_CHECKING:
     import pandas as pd
@@ -47,7 +74,11 @@ def update_attributes(record: Record, attributes: dict[str, str]):
             setattr(record, key, value)
 
 
-def validate_required_fields(record: Record, kwargs):
+def validate_fields(record: Record, kwargs):
+    from lnschema_core.validation import validate_literal_fields
+
+    # validate required fields
+    # a "required field" is a Django field that has `null=False, default=None`
     required_fields = {
         k.name for k in record._meta.fields if not k.null and k.default is None
     }
@@ -58,25 +89,49 @@ def validate_required_fields(record: Record, kwargs):
     ]
     if missing_fields:
         raise TypeError(f"{missing_fields} are required.")
+    # ensure the exact length of the internal uid for core entities
+    if "uid" in kwargs and record.__class__ in {
+        Artifact,
+        Collection,
+        Transform,
+        Run,
+        ULabel,
+        Feature,
+        FeatureSet,
+        Param,
+    }:
+        uid_max_length = record.__class__._meta.get_field(
+            "uid"
+        ).max_length  # triggers FieldDoesNotExist
+        if len(kwargs["uid"]) != uid_max_length:  # triggers KeyError
+            raise ValidationError(
+                f'`uid` must be exactly {uid_max_length} characters long, got {len(kwargs["uid"])}.'
+            )
+    # validate literals
+    validate_literal_fields(record, kwargs)
 
 
-def suggest_records_with_similar_names(record: Record, kwargs) -> bool:
+def suggest_records_with_similar_names(record: Record, name_field: str, kwargs) -> bool:
     """Returns True if found exact match, otherwise False.
 
     Logs similar matches if found.
     """
-    if kwargs.get("name") is None:
+    if kwargs.get(name_field) is None or not isinstance(kwargs.get(name_field), str):
         return False
     queryset = _search(
-        record.__class__, kwargs["name"], field="name", truncate_words=True, limit=3
+        record.__class__,
+        kwargs[name_field],
+        field=name_field,
+        truncate_string=True,
+        limit=3,
     )
     if not queryset.exists():  # empty queryset
         return False
     for alternative_record in queryset:
-        if alternative_record.name == kwargs["name"]:
+        if getattr(alternative_record, name_field) == kwargs[name_field]:
             return True
     s, it, nots = ("", "it", "s") if len(queryset) == 1 else ("s", "one of them", "")
-    msg = f"record{s} with similar name{s} exist{nots}! did you mean to load {it}?"
+    msg = f"record{s} with similar {name_field}{s} exist{nots}! did you mean to load {it}?"
     if IPYTHON:
         from IPython.display import display
 
@@ -90,7 +145,7 @@ def suggest_records_with_similar_names(record: Record, kwargs) -> bool:
 
 def __init__(record: Record, *args, **kwargs):
     if not args:
-        validate_required_fields(record, kwargs)
+        validate_fields(record, kwargs)
 
         # do not search for names if an id is passed; this is important
         # e.g. when synching ids from the notebook store to lamindb
@@ -98,13 +153,17 @@ def __init__(record: Record, *args, **kwargs):
         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:
-            match = suggest_records_with_similar_names(record, kwargs)
+            name_field = getattr(record, "_name_field", "name")
+            match = suggest_records_with_similar_names(record, name_field, kwargs)
             if match:
                 if "version" in kwargs:
                     if kwargs["version"] is not None:
                         version_comment = " and version"
                         existing_record = record.__class__.filter(
-                            name=kwargs["name"], version=kwargs["version"]
+                            **{
+                                name_field: kwargs[name_field],
+                                "version": kwargs["version"],
+                            }
                         ).one_or_none()
                     else:
                         # for a versioned record, an exact name match is not a
@@ -115,16 +174,26 @@ def __init__(record: Record, *args, **kwargs):
                 else:
                     version_comment = ""
                     existing_record = record.__class__.filter(
-                        name=kwargs["name"]
+                        **{name_field: kwargs[name_field]}
                     ).one_or_none()
                 if existing_record is not None:
                     logger.important(
                         f"returning existing {record.__class__.__name__} record with same"
-                        f" name{version_comment}: '{kwargs['name']}'"
+                        f" {name_field}{version_comment}: '{kwargs[name_field]}'"
                     )
                     init_self_from_db(record, existing_record)
                     return None
         super(Record, record).__init__(**kwargs)
+        if isinstance(record, ValidateFields):
+            # this will trigger validation against django validators
+            try:
+                if hasattr(record, "clean_fields"):
+                    record.clean_fields()
+                else:
+                    record._Model__clean_fields()
+            except DjangoValidationError as e:
+                message = _format_django_validation_error(record, e)
+                raise FieldValidationError(message) from e
     elif len(args) != len(record._meta.concrete_fields):
         raise ValueError("please provide keyword arguments, not plain arguments")
     else:
@@ -133,13 +202,48 @@ def __init__(record: Record, *args, **kwargs):
         _store_record_old_name(record)
 
 
+def _format_django_validation_error(record: Record, e: DjangoValidationError):
+    """Pretty print Django validation errors."""
+    errors = {}
+    if hasattr(e, "error_dict"):
+        error_dict = e.error_dict
+    else:
+        error_dict = {"__all__": e.error_list}
+
+    for field_name, error_list in error_dict.items():
+        for error in error_list:
+            if hasattr(error, "message"):
+                msg = error.message
+            else:
+                msg = str(error)
+
+            if field_name == "__all__":
+                errors[field_name] = f"{colors.yellow(msg)}"
+            else:
+                current_value = getattr(record, field_name, None)
+                errors[field_name] = (
+                    f"{field_name}: {colors.yellow(current_value)} is not valid\n    → {msg}"
+                )
+
+    if errors:
+        message = "\n  "
+        for _, error in errors.items():
+            message += error + "\n  "
+
+        return message
+
+
 @classmethod  # type:ignore
 @doc_args(Record.filter.__doc__)
 def filter(cls, *queries, **expressions) -> QuerySet:
     """{}"""  # noqa: D415
-    from lamindb._filter import filter
+    from lamindb._query_set import QuerySet
+
+    _using_key = None
+    if "_using_key" in expressions:
+        _using_key = expressions.pop("_using_key")
 
-    return filter(cls, *queries, **expressions)
+    return QuerySet(model=cls, using=_using_key).filter(*queries, **expressions)
 
 
 @classmethod  # type:ignore
@@ -150,8 +254,6 @@ def get(
     **expressions,
 ) -> Record:
     """{}"""  # noqa: D415
-    # this is the only place in which we need the lamindb queryset
-    # in this file; everywhere else it should be Django's
     from lamindb._query_set import QuerySet
 
     return QuerySet(model=cls).get(idlike, **expressions)
@@ -166,9 +268,7 @@ def df(
     limit: int = 100,
 ) -> pd.DataFrame:
     """{}"""  # noqa: D415
-    from lamindb._filter import filter
-
-    query_set = filter(cls)
+    query_set = cls.filter()
     if hasattr(cls, "updated_at"):
         query_set = query_set.order_by("-updated_at")
     return query_set[:limit].df(include=include, join=join)
@@ -182,10 +282,11 @@ def _search(
     limit: int | None = 20,
     case_sensitive: bool = False,
     using_key: str | None = None,
-    truncate_words: bool = False,
+    truncate_string: bool = False,
 ) -> QuerySet:
     input_queryset = _queryset(cls, using_key=using_key)
     registry = input_queryset.model
+    name_field = getattr(registry, "_name_field", "name")
     if field is None:
         fields = [
             field.name
@@ -209,48 +310,77 @@ def _search(
             else:
                 fields.append(field)
 
-    # decompose search string
-    def truncate_word(word) -> str:
-        if len(word) > 5:
-            n_80_pct = int(len(word) * 0.8)
-            return word[:n_80_pct]
-        elif len(word) > 3:
-            return word[:3]
-        else:
-            return word
-
-    decomposed_string = str(string).split()
-    # add the entire string back
-    decomposed_string += [string]
-    for word in decomposed_string:
-        # will not search against words with 3 or fewer characters
-        if len(word) <= 3:
-            decomposed_string.remove(word)
-    if truncate_words:
-        decomposed_string = [truncate_word(word) for word in decomposed_string]
-    # construct the query
-    expression = Q()
-    case_sensitive_i = "" if case_sensitive else "i"
-    for field in fields:
-        for word in decomposed_string:
-            query = {f"{field}__{case_sensitive_i}contains": word}
-            expression |= Q(**query)
-    output_queryset = input_queryset.filter(expression)
-    # ensure exact matches are at the top
-    narrow_expression = Q()
+    if truncate_string:
+        if (len_string := len(string)) > 5:
+            n_80_pct = int(len_string * 0.8)
+            string = string[:n_80_pct]
+
+    string = string.strip()
+
+    exact_lookup = Exact if case_sensitive else IExact
+    regex_lookup = Regex if case_sensitive else IRegex
+    contains_lookup = Contains if case_sensitive else IContains
+
+    ranks = []
+    contains_filters = []
     for field in fields:
-        query = {f"{field}__{case_sensitive_i}contains": string}
-        narrow_expression |= Q(**query)
-    refined_output_queryset = output_queryset.filter(narrow_expression).annotate(
-        ordering=Value(1, output_field=IntegerField())
-    )
-    remaining_output_queryset = output_queryset.exclude(narrow_expression).annotate(
-        ordering=Value(2, output_field=IntegerField())
+        field_expr = Coalesce(
+            Cast(field, output_field=TextField()),
+            Value(""),
+            output_field=TextField(),
+        )
+        # exact rank
+        exact_expr = exact_lookup(field_expr, string)
+        exact_rank = Cast(exact_expr, output_field=IntegerField()) * 200
+        ranks.append(exact_rank)
+        # exact synonym
+        synonym_expr = regex_lookup(field_expr, rf"(?:^|.*\|){string}(?:\|.*|$)")
+        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}(?:[ \|\.,;:].*|$)"
+        )
+        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}[^ ]*(\||$)")
+        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_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_rank = Cast(left_expr, output_field=IntegerField()) * 2
+        ranks.append(left_rank)
+        # simple contains filter
+        contains_expr = contains_lookup(field_expr, string)
+        contains_filter = Q(contains_expr)
+        contains_filters.append(contains_filter)
+        # also rank by contains
+        contains_rank = Cast(contains_expr, output_field=IntegerField())
+        ranks.append(contains_rank)
+        # additional rule for truncated strings
+        # weight matches from the beginning of the string higher
+        # sometimes whole words get truncated and startswith_expr is not enough
+        if truncate_string and field == name_field:
+            startswith_lookup = StartsWith if case_sensitive else IStartsWith
+            name_startswith_expr = startswith_lookup(field_expr, string)
+            name_startswith_rank = (
+                Cast(name_startswith_expr, output_field=IntegerField()) * 2
+            )
+            ranks.append(name_startswith_rank)
+
+    ranked_queryset = (
+        input_queryset.filter(reduce(lambda a, b: a | b, contains_filters))
+        .alias(rank=sum(ranks))
+        .order_by("-rank")
     )
-    combined_queryset = refined_output_queryset.union(
-        remaining_output_queryset
-    ).order_by("ordering")[:limit]
-    return combined_queryset
+
+    return ranked_queryset[:limit]
 
 
 @classmethod  # type: ignore

lamindb/core/__init__.py

@@ -14,13 +14,14 @@ Registries:
    ParamManager
    LabelManager
    IsVersioned
-   CanValidate
+   CanCurate
    HasParents
    TracksRun
    TracksUpdates
    ParamValue
    FeatureValue
    InspectResult
+   ValidateFields
    fields
 
 Curators:
@@ -67,7 +68,7 @@ Modules:
 from lamin_utils import logger
 from lamin_utils._inspect import InspectResult
 from lnschema_core.models import (
-    CanValidate,
+    CanCurate,
     FeatureValue,
     HasParents,
     IsVersioned,
@@ -76,6 +77,7 @@ from lnschema_core.models import (
     Registry,
     TracksRun,
     TracksUpdates,
+    ValidateFields,
 )
 
 from lamindb._curate import (

lamindb/core/_context.py

@@ -82,11 +82,14 @@ def raise_missing_context(transform_type: str, key: str) -> bool:
     transform = Transform.filter(key=key).latest_version().first()
     if transform is None:
         new_uid = f"{base62_12()}0000"
-        message = f'to track this {transform_type}, copy & paste `ln.track("{new_uid}")` and re-run'
+        message = f'to track this {transform_type}, run: ln.track("{new_uid}")'
     else:
         uid = transform.uid
         new_uid = f"{uid[:-4]}{increment_base62(uid[-4:])}"
-        message = f"you already have a transform with key '{key}' ('{transform.uid}')\n  - to make a revision, call `ln.track('{new_uid}')`\n  - to create a new transform, rename your file and run: `ln.track()`"
+        message = (
+            f"you already have a transform with key '{key}': Transform('{transform.uid[:8]}')\n"
+            f'  (1) to make a revision, run: ln.track("{new_uid}")\n  (2) to create a new transform, rename your {transform_type} file and re-run: ln.track()'
+        )
     if transform_type == "notebook":
         print(f"→ {message}")
         response = input("→ Ready to re-run? (y/n)")
@@ -118,6 +121,8 @@ class Context:
     Enables convenient data lineage tracking by managing a transform & run
     upon :meth:`~lamindb.core.Context.track` & :meth:`~lamindb.core.Context.finish`.
 
+    Guide: :doc:`/track`
+
     Examples:
 
         Is typically used via the global :class:`~lamindb.context` object via `ln.track()` and `ln.finish()`:
@@ -137,7 +142,8 @@ class Context:
         self._run: Run | None = None
         self._path: Path | None = None
         """A local path to the script that's running."""
-        self._logging_message: str = ""
+        self._logging_message_track: str = ""
+        self._logging_message_imports: str = ""
 
     @property
     def transform(self) -> Transform | None:
@@ -178,12 +184,11 @@ class Context:
 
     def track(
         self,
-        uid: str | None = None,
+        transform: str | Transform | None = None,
         *,
         params: dict | None = None,
         new_run: bool | None = None,
         path: str | None = None,
-        transform: Transform | None = None,
     ) -> None:
         """Initiate a run with tracked data lineage.
 
@@ -196,24 +201,31 @@ class Context:
         script-like transform exists in a git repository and links it.
 
         Args:
-            uid: A `uid` to create or load a transform.
+            transform: A transform `uid` or record. If `None`, creates a `uid`.
             params: A dictionary of parameters to track for the run.
             new_run: If `False`, loads latest run of transform
                 (default notebook), if `True`, creates new run (default pipeline).
             path: Filepath of notebook or script. Only needed if it can't be
                 automatically detected.
-            transform: Useful to track an abstract pipeline.
 
         Examples:
 
-            To track the run of a notebook or script, call:
+            To create a transform `uid` for tracking a script or notebook, call:
 
-            >>> import lamindb as ln
             >>> ln.track()
 
+            To track the run of a notebook or script, call:
+
+            >>> ln.track("FPnfDtJz8qbE0000")  # replace with your uid
+
         """
-        if uid is not None:
+        self._logging_message_track = ""
+        self._logging_message_imports = ""
+        uid = None
+        if transform is not None and isinstance(transform, str):
+            uid = transform
             self.uid = uid
+            transform = None
         self._path = None
         if transform is None:
             is_tracked = False
@@ -223,17 +235,20 @@ class Context:
             )
             transform = None
             stem_uid = None
+            # you can set ln.context.uid and then call ln.track() without passing anythin
+            # that has been the preferred syntax for a while; we'll likely
+            # deprecate it at some point
             if uid is not None or self.uid is not None:
                 transform = Transform.filter(uid=self.uid).one_or_none()
                 if self.version is not None:
                     # test inconsistent version passed
                     if (
                         transform is not None
-                        and transform.version is not None
-                        and self.version != transform.version
+                        and transform.version is not None  # type: ignore
+                        and self.version != transform.version  # type: ignore
                     ):
                         raise SystemExit(
-                            f"Please pass consistent version: ln.context.version = '{transform.version}'"
+                            f"Please pass consistent version: ln.context.version = '{transform.version}'"  # type: ignore
                         )
                     # test whether version was already used for another member of the family
                     suid, vuid = (
@@ -265,10 +280,12 @@ class Context:
                 transform_ref = None
                 transform_ref_type = None
             else:
-                (name, key, transform_ref, transform_ref_type) = self._track_script(
-                    path=path
+                # the below function is typically used for `.py` scripts
+                # it is also used for `.Rmd` and `.qmd` files, which we classify
+                # as "notebook" because they typically come with an .html run report
+                (name, key, transform_type, transform_ref, transform_ref_type) = (
+                    self._track_source_code(path=path)
                 )
-                transform_type = "script"
             if self.uid is not None or transform_settings_are_set:
                 # overwrite whatever is auto-detected in the notebook or script
                 if self.name is not None:
@@ -302,10 +319,14 @@ class Context:
                 transform_exists = Transform.filter(id=transform.id).first()
             if transform_exists is None:
                 transform.save()
-                self._logging_message += f"created Transform('{transform.uid[:8]}')"
+                self._logging_message_track += (
+                    f"created Transform('{transform.uid[:8]}')"
+                )
                 transform_exists = transform
             else:
-                self._logging_message += f"loaded Transform('{transform.uid[:8]}')"
+                self._logging_message_track += (
+                    f"loaded Transform('{transform.uid[:8]}')"
+                )
             self._transform = transform_exists
 
         if new_run is None:  # for notebooks, default to loading latest runs
@@ -322,7 +343,7 @@ class Context:
             )
             if run is not None:  # loaded latest run
                 run.started_at = datetime.now(timezone.utc)  # update run time
-                self._logging_message += f", started Run('{run.uid[:8]}') at {format_field_value(run.started_at)}"
+                self._logging_message_track += f", started Run('{run.uid[:8]}') at {format_field_value(run.started_at)}"
 
         if run is None:  # create new run
             run = Run(
@@ -330,7 +351,7 @@ class Context:
                 params=params,
             )
             run.started_at = datetime.now(timezone.utc)
-            self._logging_message += f", started new Run('{run.uid[:8]}') at {format_field_value(run.started_at)}"
+            self._logging_message_track += f", started new Run('{run.uid[:8]}') at {format_field_value(run.started_at)}"
         # can only determine at ln.finish() if run was consecutive in
         # interactive session, otherwise, is consecutive
         run.is_consecutive = True if is_run_from_ipython else None
@@ -338,19 +359,20 @@ class Context:
         run.save()
         if params is not None:
             run.params.add_values(params)
-            self._logging_message += "\n→ params: " + " ".join(
+            self._logging_message_track += "\n→ params: " + " ".join(
                 f"{key}='{value}'" for key, value in params.items()
             )
         self._run = run
         track_environment(run)
-        logger.important(self._logging_message)
-        self._logging_message = ""
+        logger.important(self._logging_message_track)
+        if self._logging_message_imports:
+            logger.important(self._logging_message_imports)
 
-    def _track_script(
+    def _track_source_code(
         self,
         *,
         path: UPathStr | None,
-    ) -> tuple[str, str, str, str]:
+    ) -> tuple[str, str, str, str, str]:
         if path is None:
             import inspect
 
@@ -359,6 +381,9 @@ class Context:
             self._path = Path(module.__file__)
         else:
             self._path = Path(path)
+        transform_type = (
+            "notebook" if self._path.suffix in {".Rmd", ".qmd"} else "script"
+        )
         name = self._path.name
         key = name
         reference = None
@@ -366,7 +391,7 @@ class Context:
         if settings.sync_git_repo is not None:
             reference = get_transform_reference_from_git_repo(self._path)
             reference_type = "url"
-        return name, key, reference, reference_type
+        return name, key, transform_type, reference, reference_type
 
     def _track_notebook(
         self,
@@ -406,9 +431,9 @@ class Context:
                 from nbproject.dev._pypackage import infer_pypackages
 
                 nb = nbproject.dev.read_notebook(path_str)
-                logger.important(
+                self._logging_message_imports += (
                     "notebook imports:"
-                    f" {pretty_pypackages(infer_pypackages(nb, pin_versions=True))}"
+                    f" {pretty_pypackages(infer_pypackages(nb, pin_versions=True))}\n"
                 )
             except Exception:
                 logger.debug("inferring imported packages failed")
@@ -471,7 +496,7 @@ class Context:
                 raise_update_context = True
             if raise_update_context:
                 raise UpdateContext(get_key_clashing_message(revises, key))
-            self._logging_message += f"created Transform('{transform.uid[:8]}')"
+            self._logging_message_track += f"created Transform('{transform.uid[:8]}')"
         else:
             uid = transform.uid
             # transform was already saved via `finish()`
@@ -485,7 +510,7 @@ class Context:
             elif transform.name != name:
                 transform.name = name
                 transform.save()
-                self._logging_message += (
+                self._logging_message_track += (
                     "updated transform name, "  # white space on purpose
                 )
             elif (
@@ -509,7 +534,7 @@ class Context:
                     if condition:
                         bump_revision = True
                     else:
-                        self._logging_message += (
+                        self._logging_message_track += (
                             f"loaded Transform('{transform.uid[:8]}')"
                         )
                 if bump_revision:
@@ -523,7 +548,9 @@ class Context:
                         f'ln.track("{uid[:-4]}{increment_base62(uid[-4:])}")'
                     )
             else:
-                self._logging_message += f"loaded Transform('{transform.uid[:8]}')"
+                self._logging_message_track += (
+                    f"loaded Transform('{transform.uid[:8]}')"
+                )
         self._transform = transform
 
     def finish(self, ignore_non_consecutive: None | bool = None) -> None:

lamindb/core/_django.py

@@ -33,7 +33,7 @@ def get_artifact_with_related(
     include_featureset: bool = False,
 ) -> dict:
     """Fetch an artifact with its related data."""
-    from lamindb._can_validate import get_name_field
+    from lamindb._can_curate import get_name_field
 
     from ._label_manager import LABELS_EXCLUDE_SET
 
@@ -163,7 +163,7 @@ def get_featureset_m2m_relations(
     artifact: Artifact, slot_featureset: dict, limit: int = 20
 ):
     """Fetch all many-to-many relationships for given feature sets."""
-    from lamindb._can_validate import get_name_field
+    from lamindb._can_curate import get_name_field
 
     m2m_relations = [
         v