lamindb 0.76.14__py3-none-any.whl → 0.76.16__py3-none-any.whl

lamindb/__init__.py

@@ -43,7 +43,7 @@ Modules and settings.
 """
 
 # denote a release candidate for 0.1.0 with 0.1rc1, 0.1a1, 0.1b1, etc.
-__version__ = "0.76.14"
+__version__ = "0.76.16"
 
 import os as _os
 

lamindb/_artifact.py

@@ -28,39 +28,41 @@ from lnschema_core.types import (
     VisibilityChoice,
 )
 
-from lamindb._utils import attach_func_to_class_method
-from lamindb.core._data import _track_run_input, describe, view_lineage
-from lamindb.core._settings import settings
-from lamindb.core.exceptions import IntegrityError, InvalidArgument
-from lamindb.core.loaders import load_to_memory
-from lamindb.core.storage import (
+from ._utils import attach_func_to_class_method
+from .core._data import (
+    _track_run_input,
+    add_transform_to_kwargs,
+    describe,
+    get_run,
+    save_feature_set_links,
+    save_feature_sets,
+    view_lineage,
+)
+from .core._settings import settings
+from .core.exceptions import IntegrityError, InvalidArgument
+from .core.loaders import load_to_memory
+from .core.storage import (
     LocalPathClasses,
     UPath,
     delete_storage,
     infer_suffix,
     write_to_disk,
 )
-from lamindb.core.storage.paths import (
+from .core.storage._pyarrow_dataset import PYARROW_SUFFIXES
+from .core.storage.objects import _mudata_is_installed
+from .core.storage.paths import (
+    AUTO_KEY_PREFIX,
     auto_storage_key_from_artifact,
     auto_storage_key_from_artifact_uid,
     check_path_is_child_of_root,
     filepath_cache_key_from_artifact,
     filepath_from_artifact,
 )
-from lamindb.core.versioning import (
+from .core.versioning import (
     create_uid,
     message_update_key_in_version_family,
 )
 
-from .core._data import (
-    add_transform_to_kwargs,
-    get_run,
-    save_feature_set_links,
-    save_feature_sets,
-)
-from .core.storage.objects import _mudata_is_installed
-from .core.storage.paths import AUTO_KEY_PREFIX
-
 try:
     from .core.storage._zarr import zarr_is_adata
 except ImportError:
@@ -72,6 +74,7 @@ except ImportError:
 if TYPE_CHECKING:
     from lamindb_setup.core.types import UPathStr
     from mudata import MuData
+    from pyarrow.dataset import Dataset as PyArrowDataset
     from tiledbsoma import Collection as SOMACollection
     from tiledbsoma import Experiment as SOMAExperiment
 
@@ -108,7 +111,12 @@ def process_pathlike(
             # for the storage root: the bucket
             if not isinstance(filepath, LocalPathClasses):
                 # for a cloud path, new_root is always the bucket name
-                new_root = list(filepath.parents)[-1]
+                if filepath.protocol == "hf":
+                    hf_path = filepath.fs.resolve_path(filepath.as_posix())
+                    hf_path.path_in_repo = ""
+                    new_root = "hf://" + hf_path.unresolve()
+                else:
+                    new_root = list(filepath.parents)[-1]
                 # do not register remote storage locations on hub if the current instance
                 # is not managed on the hub
                 storage_settings, _ = init_storage(
@@ -210,9 +218,9 @@ def get_stat_or_artifact(
         if stat is not None:
             # convert UPathStatResult to fsspec info dict
             stat = stat.as_info()
-            if "ETag" in stat:  # is file
+            if (store_type := stat["type"]) == "file":
                 size, hash, hash_type = get_stat_file_cloud(stat)
-            elif stat["type"] == "directory":
+            elif store_type == "directory":
                 size, hash, hash_type, n_objects = get_stat_dir_cloud(path)
         if hash is None:
             logger.warning(f"did not add hash for {path}")
@@ -237,7 +245,7 @@ def get_stat_or_artifact(
             .order_by("-created_at")
             .all()
         )
-        artifact_with_same_hash_exists = len(result.filter(hash=hash).all()) > 0
+        artifact_with_same_hash_exists = result.filter(hash=hash).count() > 0
         if not artifact_with_same_hash_exists and len(result) > 0:
             logger.important(
                 f"creating new artifact version for key='{key}' (storage: '{settings.storage.root_as_str}')"
@@ -772,19 +780,14 @@ def from_dir(
     else:
         folder_key_path = Path(key)
 
-    # always sanitize by stripping a trailing slash
-    folder_key = folder_key_path.as_posix().rstrip("/")
-
-    # TODO: (non-local) UPath doesn't list the first level artifacts and dirs with "*"
-    pattern = "" if not isinstance(folderpath, LocalPathClasses) else "*"
-
+    folder_key = folder_key_path.as_posix()
     # silence fine-grained logging
     verbosity = settings.verbosity
     verbosity_int = settings._verbosity_int
     if verbosity_int >= 1:
         settings.verbosity = "warning"
     artifacts_dict = {}
-    for filepath in folderpath.rglob(pattern):
+    for filepath in folderpath.rglob("*"):
         if filepath.is_file():
             relative_path = get_relative_path_to_directory(filepath, folderpath)
             artifact_key = folder_key + "/" + relative_path.as_posix()
@@ -802,7 +805,8 @@ def from_dir(
         if artifact.hash is not None
     ]
     uids = artifacts_dict.keys()
-    if len(set(hashes)) == len(hashes):
+    n_unique_hashes = len(set(hashes))
+    if n_unique_hashes == len(hashes):
         artifacts = list(artifacts_dict.values())
     else:
         # consider exact duplicates (same id, same hash)
@@ -811,7 +815,7 @@ def from_dir(
         #     logger.warning("dropping duplicate records in list of artifact records")
         #     artifacts = list(set(uids))
         # consider false duplicates (different id, same hash)
-        if not len(set(uids)) == len(set(hashes)):
+        if not len(set(uids)) == n_unique_hashes:
             seen_hashes = set()
             non_unique_artifacts = {
                 hash: artifact
@@ -905,14 +909,19 @@ def replace(
 # docstring handled through attach_func_to_class_method
 def open(
     self, mode: str = "r", is_run_input: bool | None = None
-) -> AnnDataAccessor | BackedAccessor | SOMACollection | SOMAExperiment:
+) -> (
+    AnnDataAccessor | BackedAccessor | SOMACollection | SOMAExperiment | PyArrowDataset
+):
     # ignore empty suffix for now
-    suffixes = (".h5", ".hdf5", ".h5ad", ".zarr", ".tiledbsoma", "")
+    suffixes = ("", ".h5", ".hdf5", ".h5ad", ".zarr", ".tiledbsoma") + PYARROW_SUFFIXES
     if self.suffix not in suffixes:
         raise ValueError(
-            "Artifact should have a zarr, h5 or tiledbsoma object as the underlying data, please"
-            " use one of the following suffixes for the object name:"
-            f" {', '.join(suffixes[:-1])}."
+            "Artifact should have a zarr, h5, tiledbsoma object"
+            " or a compatible `pyarrow.dataset.dataset` directory"
+            " as the underlying data, please use one of the following suffixes"
+            f" for the object name: {', '.join(suffixes[1:])}."
+            f" Or no suffix for a folder with {', '.join(PYARROW_SUFFIXES)} files"
+            " (no mixing allowed)."
         )
     if self.suffix != ".tiledbsoma" and self.key != "soma" and mode != "r":
         raise ValueError("Only a tiledbsoma store can be openened with `mode!='r'`.")

lamindb/_can_validate.py

@@ -10,10 +10,10 @@ from lamin_utils import colors, logger
 from lamindb_setup.core._docs import doc_args
 from lnschema_core import CanValidate, Record
 
-from lamindb._utils import attach_func_to_class_method
-
 from ._from_values import _has_organism_field, _print_values, get_or_create_records
 from ._record import _queryset, get_name_field
+from ._utils import attach_func_to_class_method
+from .core.exceptions import ValidationError
 
 if TYPE_CHECKING:
     from django.db.models import QuerySet
@@ -108,14 +108,14 @@ def _check_organism_db(organism: Record, using_key: str | None):
 
 def _concat_lists(values: ListLike) -> list[str]:
     """Concatenate a list of lists of strings into a single list."""
-    if len(values) > 0 and isinstance(values, (list, pd.Series)):
-        try:
-            if isinstance(values[0], list):
-                if isinstance(values, pd.Series):
-                    values = values.tolist()
-                values = sum([v for v in values if isinstance(v, list)], [])
-        except KeyError:
-            pass
+    if isinstance(values, (list, pd.Series)) and len(values) > 0:
+        first_item = values[0] if isinstance(values, list) else values.iloc[0]
+        if isinstance(first_item, list):
+            if isinstance(values, pd.Series):
+                values = values.tolist()
+            values = [
+                v for sublist in values if isinstance(sublist, list) for v in sublist
+            ]
     return values
 
 
@@ -250,7 +250,7 @@ def _validate(
                 f"Your {cls.__name__} registry is empty, consider populating it first!"
             )
             if hasattr(cls, "source_id"):
-                msg += "\n   → use `.import_from_source()` to import records from a source, e.g. a public ontology"
+                msg += "\n   → use `.import_source()` to import records from a source, e.g. a public ontology"
             logger.warning(msg)
         return np.array([False] * len(values))
 
@@ -388,7 +388,11 @@ def _standardize(
 
     try:
         registry._meta.get_field(synonyms_field)
-        fields = {i for i in [field, return_field, synonyms_field] if i is not None}
+        fields = {
+            field_name
+            for field_name in [field, return_field, synonyms_field]
+            if field_name is not None
+        }
         df = _filter_query_based_on_organism(
             queryset=queryset,
             field=field,
@@ -445,14 +449,19 @@ def _standardize(
         if len(std_names_bt_mapper) > 0 and not mute:
             s = "" if len(std_names_bt_mapper) == 1 else "s"
             field_print = "synonym" if field == return_field else field
-            warn_msg = (
-                f"found {len(std_names_bt_mapper)} {field_print}{s} in Bionty:"
-                f" {list(std_names_bt_mapper.keys())}"
+
+            reduced_mapped_keys_str = f"{list(std_names_bt_mapper.keys())[:10] + ['...'] if len(std_names_bt_mapper) > 10 else list(std_names_bt_mapper.keys())}"
+            truncated_note = (
+                " (output truncated)" if len(std_names_bt_mapper) > 10 else ""
             )
-            warn_msg += (
-                f"\n   please add corresponding {registry._meta.model.__name__} records via"
-                f" `.from_values({list(set(std_names_bt_mapper.values()))})`"
+
+            warn_msg = (
+                f"found {len(std_names_bt_mapper)} {field_print}{s} in Bionty{truncated_note}:"
+                f" {reduced_mapped_keys_str}\n"
+                f"  please add corresponding {registry._meta.model.__name__} records via{truncated_note}:"
+                f" `.from_values({reduced_mapped_keys_str})`"
             )
+
             logger.warning(warn_msg)
 
         mapper.update(std_names_bt_mapper)
@@ -496,9 +505,9 @@ def _add_or_remove_synonyms(
                 " with the following records:\n"
             )
             display(records_df)
-            raise ValueError(
-                "cannot assigned a synonym that is already associated with a record to a different record.\n"
-                "Consider removing the synonym from existing records or using a different synonym."
+            raise ValidationError(
+                f"you are trying to assign a synonym to record: {record}\n"
+                "    → consider removing the synonym from existing records or using a different synonym."
             )
 
     # passed synonyms
@@ -516,7 +525,7 @@ def _add_or_remove_synonyms(
         return
     # because we use | as the separator
     if any("|" in i for i in syn_new_set):
-        raise ValueError("a synonym can't contain '|'!")
+        raise ValidationError("a synonym can't contain '|'!")
 
     # existing synonyms
     syns_exist = record.synonyms

lamindb/_collection.py

@@ -20,20 +20,21 @@ from lnschema_core.models import (
 )
 from lnschema_core.types import VisibilityChoice
 
-from lamindb._utils import attach_func_to_class_method
-from lamindb.core._data import _track_run_input, describe, view_lineage
-from lamindb.core._mapped_collection import MappedCollection
-from lamindb.core.versioning import process_revises
-
 from . import Artifact, Run
 from ._record import init_self_from_db, update_attributes
+from ._utils import attach_func_to_class_method
 from .core._data import (
+    _track_run_input,
     add_transform_to_kwargs,
+    describe,
     get_run,
     save_feature_set_links,
     save_feature_sets,
+    view_lineage,
 )
+from .core._mapped_collection import MappedCollection
 from .core._settings import settings
+from .core.versioning import process_revises
 
 if TYPE_CHECKING:
     from collections.abc import Iterable

lamindb/_curate.py

@@ -20,6 +20,7 @@ from .core.exceptions import ValidationError
 
 if TYPE_CHECKING:
     from collections.abc import Iterable
+    from typing import Any
 
     from lamindb_setup.core.types import UPathStr
     from lnschema_core.types import FieldAttr
@@ -184,7 +185,7 @@ class DataFrameCurator(BaseCurator):
     def non_validated(self) -> list:
         """Return the non-validated features and labels."""
         if self._non_validated is None:
-            raise ValueError("Please run validate() first!")
+            raise ValidationError("Please run validate() first!")
         return self._non_validated
 
     @property
@@ -222,11 +223,11 @@ class DataFrameCurator(BaseCurator):
             valid_keys = set(self._df.columns) | {"columns"} | extra
             nonval_keys = [key for key in d.keys() if key not in valid_keys]
             if len(nonval_keys) > 0:
-                raise ValueError(
+                raise ValidationError(
                     f"the following keys passed to {name} are not allowed: {nonval_keys}"
                 )
 
-    def _save_columns(self, validated_only: bool = True, **kwargs) -> None:
+    def _save_columns(self, validated_only: bool = True) -> None:
         """Save column name records."""
         # Always save features specified as the fields keys
         update_registry(
@@ -238,7 +239,7 @@ class DataFrameCurator(BaseCurator):
             validated_only=False,
             source=self._sources.get("columns"),
             exclude=self._exclude.get("columns"),
-            **kwargs,
+            **self._kwargs,  # type: ignore
         )
 
         # Save the rest of the columns based on validated_only
@@ -255,7 +256,7 @@ class DataFrameCurator(BaseCurator):
                 source=self._sources.get("columns"),
                 exclude=self._exclude.get("columns"),
                 warning=False,  # Do not warn about missing columns, just an info message
-                **kwargs,
+                **self._kwargs,  # type: ignore
             )
 
     def add_new_from(self, key: str, organism: str | None = None, **kwargs):
@@ -288,9 +289,11 @@ class DataFrameCurator(BaseCurator):
             self._save_columns(validated_only=validated_only, **kwargs)
         else:
             if categorical not in self.fields:
-                raise ValueError(f"Feature {categorical} is not part of the fields!")
+                raise ValidationError(
+                    f"Feature {categorical} is not part of the fields!"
+                )
             update_registry(
-                values=self._df[categorical].unique().tolist(),
+                values=_flatten_unique(self._df[categorical]),
                 field=self.fields[categorical],
                 key=categorical,
                 using_key=self._using_key,
@@ -303,7 +306,6 @@ class DataFrameCurator(BaseCurator):
     def _update_registry_all(self, validated_only: bool = True, **kwargs):
         """Save labels for all features."""
         for name in self.fields.keys():
-            logger.info(f"saving validated records of '{name}'")
             self._update_registry(name, validated_only=validated_only, **kwargs)
 
     def validate(self, organism: str | None = None) -> bool:
@@ -434,12 +436,15 @@ class AnnDataCurator(DataFrameCurator):
     ) -> None:
         from lamindb_setup.core import upath
 
+        if isinstance(var_index, str):
+            raise TypeError("var_index parameter has to be a bionty field")
+
         from ._artifact import data_is_anndata
 
         if sources is None:
             sources = {}
         if not data_is_anndata(data):
-            raise ValueError(
+            raise TypeError(
                 "data has to be an AnnData object or a path to AnnData-like"
             )
         if isinstance(data, ad.AnnData):
@@ -449,6 +454,11 @@ class AnnDataCurator(DataFrameCurator):
 
             self._adata = backed_access(upath.create_path(data))
 
+        if "symbol" in str(var_index):
+            logger.warning(
+                "Curating gene symbols is discouraged. See FAQ for more details."
+            )
+
         self._data = data
         self._var_field = var_index
         super().__init__(
@@ -508,13 +518,11 @@ class AnnDataCurator(DataFrameCurator):
             exclude=self._exclude.get("var_index"),
         )
 
-    def _update_registry_all(self):
+    def _update_registry_all(self, validated_only: bool = True, **kwargs):
         """Save labels for all features."""
-        logger.info("saving validated records of 'var_index'")
-        self._save_from_var_index(validated_only=True, **self._kwargs)
+        self._save_from_var_index(validated_only=validated_only, **self._kwargs)
         for name in self._obs_fields.keys():
-            logger.info(f"saving validated terms of '{name}'")
-            self._update_registry(name, validated_only=True, **self._kwargs)
+            self._update_registry(name, validated_only=validated_only, **self._kwargs)
 
     def add_new_from_var_index(self, organism: str | None = None, **kwargs):
         """Update variable records.
@@ -704,7 +712,7 @@ class MuDataCurator:
         """Verify the modality exists."""
         for modality in modalities:
             if modality not in self._mdata.mod.keys():
-                raise ValueError(f"modality '{modality}' does not exist!")
+                raise ValidationError(f"modality '{modality}' does not exist!")
 
     def _save_from_var_index_modality(
         self, modality: str, validated_only: bool = True, **kwargs
@@ -729,7 +737,7 @@ class MuDataCurator:
         obs_fields: dict[str, dict[str, FieldAttr]] = {}
         for k, v in categoricals.items():
             if k not in self._mdata.obs.columns:
-                raise ValueError(f"column '{k}' does not exist in mdata.obs!")
+                raise ValidationError(f"column '{k}' does not exist in mdata.obs!")
             if any(k.startswith(prefix) for prefix in prefixes):
                 modality, col = k.split(":")[0], k.split(":")[1]
                 if modality not in obs_fields.keys():
@@ -1120,7 +1128,7 @@ def check_registry_organism(registry: Record, organism: str | None = None) -> di
         import bionty as bt
 
         if organism is None and bt.settings.organism is None:
-            raise ValueError(
+            raise ValidationError(
                 f"{registry.__name__} registry requires an organism!\n"
                 "      → please pass an organism name via organism="
             )
@@ -1148,8 +1156,8 @@ def validate_categories(
         using_key: A reference LaminDB instance.
         organism: The organism name.
         source: The source record.
-        exclude: Exclude specific values.
-        standardize: Standardize the values.
+        exclude: Exclude specific values from validation.
+        standardize: Whether to standardize the values.
         validated_hint_print: The hint to print for validated values.
     """
     from lamindb._from_values import _print_values
@@ -1210,12 +1218,15 @@ def validate_categories(
 
     validated_hint_print = validated_hint_print or f".add_validated_from('{key}')"
     n_validated = len(values_validated)
+
     if n_validated > 0:
         _log_mapping_info()
+        terms_str = f"{', '.join([f'{chr(39)}{v}{chr(39)}' for v in values_validated[:10]])}{', ...' if len(values_validated) > 10 else ''}"
+        val_numerous = "" if n_validated == 1 else "s"
         logger.warning(
-            f"found {colors.yellow(n_validated)} validated terms: "
-            f"{colors.yellow(values_validated)}\n      → save terms via "
-            f"{colors.yellow(validated_hint_print)}"
+            f"found {colors.yellow(n_validated)} validated term{val_numerous}: "
+            f"{colors.yellow(terms_str)}\n"
+            f"→ save term{val_numerous} via {colors.yellow(validated_hint_print)}"
         )
 
     non_validated_hint_print = validated_hint_print.replace("_validated_", "_new_")
@@ -1224,19 +1235,21 @@ def validate_categories(
     if n_non_validated == 0:
         if n_validated == 0:
             logger.indent = ""
-            logger.success(f"{key} is validated against {colors.italic(model_field)}")
+            logger.success(f"'{key}' is validated against {colors.italic(model_field)}")
             return True, []
         else:
             # validated values still need to be saved to the current instance
             return False, []
     else:
-        are = "are" if n_non_validated > 1 else "is"
+        non_val_numerous = ("", "is") if n_non_validated == 1 else ("s", "are")
         print_values = _print_values(non_validated)
         warning_message = (
-            f"{colors.red(f'{n_non_validated} terms')} {are} not validated: "
-            f"{colors.red(print_values)}\n      → fix typos, remove non-existent values, or save terms via "
+            f"{colors.red(f'{n_non_validated} term{non_val_numerous[0]}')} {non_val_numerous[1]} not validated: "
+            f"{colors.red(', '.join(print_values.split(', ')[:10]) + ', ...' if len(print_values.split(', ')) > 10 else print_values)}\n"
+            f"→ fix typo{non_val_numerous[0]}, remove non-existent value{non_val_numerous[0]}, or save term{non_val_numerous[0]} via "
             f"{colors.red(non_validated_hint_print)}"
         )
+
         if logger.indent == "":
             _log_mapping_info()
         logger.warning(warning_message)
@@ -1427,6 +1440,19 @@ def save_artifact(
     return artifact
 
 
+def _flatten_unique(series: pd.Series[list[Any] | Any]) -> list[Any]:
+    """Flatten a Pandas series containing lists or single items into a unique list of elements."""
+    result = set()
+
+    for item in series:
+        if isinstance(item, list):
+            result.update(item)
+        else:
+            result.add(item)
+
+    return list(result)
+
+
 def update_registry(
     values: list[str],
     field: FieldAttr,
@@ -1485,9 +1511,14 @@ def update_registry(
 
         public_records = [r for r in existing_and_public_records if r._state.adding]
         # here we check to only save the public records if they are from the specified source
-        # we check the uid because r.source and soruce can be from different instances
+        # we check the uid because r.source and source can be from different instances
         if source:
             public_records = [r for r in public_records if r.source.uid == source.uid]
+
+        if public_records:
+            settings.verbosity = "info"
+            logger.info(f"saving validated records of '{key}'")
+            settings.verbosity = "error"
         ln_save(public_records)
         labels_saved["from public"] = [
             getattr(r, field.field.name) for r in public_records
@@ -1596,24 +1627,25 @@ def log_saved_labels(
             continue
 
         if k == "without reference" and validated_only:
-            msg = colors.yellow(
-                f"{len(labels)} non-validated values are not saved in {model_field}: {labels}!"
-            )
-            lookup_print = (
-                f"lookup().{key}" if key.isidentifier() else f".lookup()['{key}']"
-            )
-
-            hint = f".add_new_from('{key}')"
-            msg += f"\n      → to lookup values, use {lookup_print}"
-            msg += (
-                f"\n      → to save, run {colors.yellow(hint)}"
-                if save_function == "add_new_from"
-                else f"\n      → to save, run {colors.yellow(save_function)}"
-            )
-            if warning:
-                logger.warning(msg)
-            else:
-                logger.info(msg)
+            continue
+            # msg = colors.yellow(
+            #     f"{len(labels)} non-validated values are not saved in {model_field}: {labels}!"
+            # )
+            # lookup_print = (
+            #     f"lookup().{key}" if key.isidentifier() else f".lookup()['{key}']"
+            # )
+
+            # hint = f".add_new_from('{key}')"
+            # msg += f"\n      → to lookup values, use {lookup_print}"
+            # msg += (
+            #     f"\n      → to save, run {colors.yellow(hint)}"
+            #     if save_function == "add_new_from"
+            #     else f"\n      → to save, run {colors.yellow(save_function)}"
+            # )
+            # if warning:
+            #     logger.warning(msg)
+            # else:
+            #     logger.info(msg)
         else:
             k = "" if k == "without reference" else f"{colors.green(k)} "
             # the term "transferred" stresses that this is always in the context of transferring
@@ -1631,8 +1663,8 @@ def save_ulabels_with_parent(values: list[str], field: FieldAttr, key: str) -> N
     all_records = registry.from_values(list(values), field=field)
     is_feature = registry.filter(name=f"is_{key}").one_or_none()
     if is_feature is None:
-        is_feature = registry(name=f"is_{key}")
-        is_feature.save()
+        is_feature = registry(name=f"is_{key}").save()
+        logger.important(f"Created a parent ULabel: {is_feature}")
     is_feature.children.add(*all_records)
 
 
@@ -1689,7 +1721,7 @@ def _save_organism(name: str):  # pragma: no cover
     if organism is None:
         organism = bt.Organism.from_source(name=name)
         if organism is None:
-            raise ValueError(
+            raise ValidationError(
                 f"Organism '{name}' not found\n"
                 f"      → please save it: bt.Organism(name='{name}').save()"
             )

lamindb/_feature.py

@@ -8,10 +8,9 @@ from lamindb_setup.core._docs import doc_args
 from lnschema_core.models import Artifact, Feature
 from pandas.api.types import CategoricalDtype, is_string_dtype
 
-from lamindb._utils import attach_func_to_class_method
-from lamindb.core._settings import settings
-
 from ._query_set import RecordsList
+from ._utils import attach_func_to_class_method
+from .core._settings import settings
 from .core.schema import dict_schema_name_to_model_name
 
 if TYPE_CHECKING:

lamindb/_feature_set.py

@@ -10,10 +10,9 @@ 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._utils import attach_func_to_class_method
-
 from ._feature import convert_numpy_dtype_to_lamin_feature_type
 from ._record import init_self_from_db
+from ._utils import attach_func_to_class_method
 from .core.exceptions import ValidationError
 from .core.schema import (
     dict_related_model_to_related_name,