lamindb 0.74.1__py3-none-any.whl → 0.74.3__py3-none-any.whl

lamindb/{_annotate.py → _curate.py}

@@ -7,7 +7,14 @@ import lamindb_setup as ln_setup
 import pandas as pd
 from lamin_utils import colors, logger
 from lamindb_setup.core._docs import doc_args
-from lnschema_core import Artifact, Collection, Feature, Registry, Run, ULabel
+from lnschema_core import (
+    Artifact,
+    Collection,
+    Feature,
+    Record,
+    Run,
+    ULabel,
+)
 
 from .core.exceptions import ValidationError
 
@@ -17,7 +24,7 @@ if TYPE_CHECKING:
     from mudata import MuData
 
 
-class AnnotateLookup:
+class CurateLookup:
     """Lookup categories from the reference instance."""
 
     def __init__(
@@ -75,11 +82,11 @@ class AnnotateLookup:
             return colors.warning("No fields are found!")
 
 
-class DataFrameAnnotator:
+class DataFrameCurator:
     """Annotation flow for a DataFrame object.
 
     Args:
-        df: The DataFrame object to annotate.
+        df: The DataFrame object to curate.
         columns: The field attribute for the feature column.
         categoricals: A dictionary mapping column names to registry_field.
         using: The reference instance containing registries to validate against.
@@ -88,7 +95,7 @@ class DataFrameAnnotator:
 
     Examples:
         >>> import bionty as bt
-        >>> annotate = ln.Annotate.from_df(
+        >>> curate = ln.Curate.from_df(
                 df,
                 categoricals={"cell_type_ontology_id": bt.CellType.ontology_id, "donor_id": ln.ULabel.name}
             )
@@ -121,7 +128,7 @@ class DataFrameAnnotator:
         """Return the columns fields to validate against."""
         return self._fields
 
-    def lookup(self, using: str | None = None) -> AnnotateLookup:
+    def lookup(self, using: str | None = None) -> CurateLookup:
         """Lookup categories.
 
         Args:
@@ -129,7 +136,7 @@ class DataFrameAnnotator:
                 if None (default), the lookup is performed on the instance specified in "using" parameter of the validator.
                 if "public", the lookup is performed on the public reference.
         """
-        return AnnotateLookup(
+        return CurateLookup(
             categoricals=self._fields,
             slots={"columns": self._columns_field},
             using=using or self._using,
@@ -321,7 +328,7 @@ class DataFrameAnnotator:
             ).delete()
 
 
-class AnnDataAnnotator(DataFrameAnnotator):
+class AnnDataCurator(DataFrameCurator):
     """Annotation flow for ``AnnData``.
 
     Args:
@@ -334,7 +341,7 @@ class AnnDataAnnotator(DataFrameAnnotator):
 
     Examples:
         >>> import bionty as bt
-        >>> annotate = ln.Annotate.from_anndata(
+        >>> curate = ln.Curate.from_anndata(
                 adata,
                 var_index=bt.Gene.ensembl_gene_id,
                 categoricals={"cell_type_ontology_id": bt.CellType.ontology_id, "donor_id": ln.ULabel.name},
@@ -388,7 +395,7 @@ class AnnDataAnnotator(DataFrameAnnotator):
         """Return the obs fields to validate against."""
         return self._obs_fields
 
-    def lookup(self, using: str | None = None) -> AnnotateLookup:
+    def lookup(self, using: str | None = None) -> CurateLookup:
         """Lookup categories.
 
         Args:
@@ -396,7 +403,7 @@ class AnnDataAnnotator(DataFrameAnnotator):
                 if None (default), the lookup is performed on the instance specified in "using" parameter of the validator.
                 if "public", the lookup is performed on the public reference.
         """
-        return AnnotateLookup(
+        return CurateLookup(
             categoricals=self._obs_fields,
             slots={"columns": self._columns_field, "var_index": self._var_field},
             using=using or self._using,
@@ -480,11 +487,11 @@ class AnnDataAnnotator(DataFrameAnnotator):
         return self._artifact
 
 
-class MuDataAnnotator:
+class MuDataCurator:
     """Annotation flow for a ``MuData`` object.
 
     Args:
-        mdata: The MuData object to annotate.
+        mdata: The MuData object to curate.
         var_index: The registry field for mapping the ``.var`` index for each modality.
             For example:
             ``{"modality_1": bt.Gene.ensembl_gene_id, "modality_2": ln.CellMarker.name}``
@@ -496,7 +503,7 @@ class MuDataAnnotator:
 
     Examples:
         >>> import bionty as bt
-        >>> annotate = ln.Annotate.from_mudata(
+        >>> curate = ln.Curate.from_mudata(
                 mdata,
                 var_index={"rna": bt.Gene.ensembl_gene_id, "adt": ln.CellMarker.name},
                 categoricals={"cell_type_ontology_id": bt.CellType.ontology_id, "donor_id": ln.ULabel.name},
@@ -522,7 +529,7 @@ class MuDataAnnotator:
         self._using = using
         self._verbosity = verbosity
         self._df_annotators = {
-            modality: DataFrameAnnotator(
+            modality: DataFrameCurator(
                 df=mdata[modality].obs if modality != "obs" else mdata.obs,
                 categoricals=self._obs_fields.get(modality, {}),
                 using=using,
@@ -585,7 +592,7 @@ class MuDataAnnotator:
                 obs_fields["obs"][k] = v
         return obs_fields
 
-    def lookup(self, using: str | None = None) -> AnnotateLookup:
+    def lookup(self, using: str | None = None) -> CurateLookup:
         """Lookup categories.
 
         Args:
@@ -593,7 +600,7 @@ class MuDataAnnotator:
                 if None (default), the lookup is performed on the instance specified in "using" parameter of the validator.
                 if "public", the lookup is performed on the public reference.
         """
-        return AnnotateLookup(
+        return CurateLookup(
             categoricals=self._obs_fields,
             slots={
                 **self._obs_fields,
@@ -735,11 +742,11 @@ class MuDataAnnotator:
         return self._artifact
 
 
-class Annotate:
+class Curate:
     """Annotation flow."""
 
     @classmethod
-    @doc_args(DataFrameAnnotator.__doc__)
+    @doc_args(DataFrameCurator.__doc__)
     def from_df(
         cls,
         df: pd.DataFrame,
@@ -748,9 +755,9 @@ class Annotate:
         using: str | None = None,
         verbosity: str = "hint",
         organism: str | None = None,
-    ) -> DataFrameAnnotator:
-        """{}."""
-        return DataFrameAnnotator(
+    ) -> DataFrameCurator:
+        """{}"""  # noqa: D415
+        return DataFrameCurator(
             df=df,
             categoricals=categoricals,
             columns=columns,
@@ -760,7 +767,7 @@ class Annotate:
         )
 
     @classmethod
-    @doc_args(AnnDataAnnotator.__doc__)
+    @doc_args(AnnDataCurator.__doc__)
     def from_anndata(
         cls,
         data: ad.AnnData | UPathStr,
@@ -769,9 +776,9 @@ class Annotate:
         using: str = "default",
         verbosity: str = "hint",
         organism: str | None = None,
-    ) -> AnnDataAnnotator:
-        """{}."""
-        return AnnDataAnnotator(
+    ) -> AnnDataCurator:
+        """{}"""  # noqa: D415
+        return AnnDataCurator(
             data=data,
             var_index=var_index,
             categoricals=categoricals,
@@ -781,7 +788,7 @@ class Annotate:
         )
 
     @classmethod
-    @doc_args(MuDataAnnotator.__doc__)
+    @doc_args(MuDataCurator.__doc__)
     def from_mudata(
         cls,
         mdata: MuData,
@@ -790,9 +797,9 @@ class Annotate:
         using: str = "default",
         verbosity: str = "hint",
         organism: str | None = None,
-    ) -> MuDataAnnotator:
-        """{}."""
-        return MuDataAnnotator(
+    ) -> MuDataCurator:
+        """{}"""  # noqa: D415
+        return MuDataCurator(
             mdata=mdata,
             var_index=var_index,
             categoricals=categoricals,
@@ -802,7 +809,7 @@ class Annotate:
         )
 
 
-def get_registry_instance(registry: Registry, using: str | None = None) -> Registry:
+def get_registry_instance(registry: Record, using: str | None = None) -> Record:
     """Get a registry instance using a specific instance."""
     if using is not None and using != "default":
         return registry.using(using)
@@ -810,7 +817,7 @@ def get_registry_instance(registry: Registry, using: str | None = None) -> Regis
 
 
 def standardize_and_inspect(
-    values: Iterable[str], field: FieldAttr, registry: Registry, **kwargs
+    values: Iterable[str], field: FieldAttr, registry: Record, **kwargs
 ):
     """Standardize and inspect values using a registry."""
     if hasattr(registry, "standardize") and hasattr(
@@ -821,7 +828,7 @@ def standardize_and_inspect(
     return registry.inspect(values, field=field, mute=True, **kwargs)
 
 
-def check_registry_organism(registry: Registry, organism: str | None = None) -> dict:
+def check_registry_organism(registry: Record, organism: str | None = None) -> dict:
     """Check if a registry needs an organism and return the organism name."""
     if hasattr(registry, "organism_id"):
         import bionty as bt
@@ -962,7 +969,7 @@ def save_artifact(
 
     artifact = None
     if data_is_anndata(data):
-        assert adata is not None
+        assert adata is not None  # noqa: S101
         artifact = Artifact.from_anndata(data, description=description, **kwargs)
         artifact.n_observations = adata.shape[0]
         data = adata
@@ -1040,7 +1047,7 @@ def update_registry(
     organism: str | None = None,
     dtype: str | None = None,
     **kwargs,
-) -> None:
+) -> list[Record]:
     """Save features or labels records in the default instance from the using instance.
 
     Args:
@@ -1068,8 +1075,11 @@ def update_registry(
             values=values, field=field, registry=registry, **filter_kwargs
         )
         if not inspect_result_current.non_validated:
+            all_labels = registry.from_values(
+                inspect_result_current.validated, field=field, **filter_kwargs
+            )
             settings.verbosity = verbosity
-            return
+            return all_labels
 
         labels_saved: dict = {"from public": [], "without reference": []}
 
@@ -1103,15 +1113,25 @@ def update_registry(
             else:
                 if "organism" in filter_kwargs:
                     filter_kwargs["organism"] = _save_organism(name=organism)
+                init_kwargs = {}
                 for value in labels_saved["without reference"]:
-                    filter_kwargs[field.field.name] = value
+                    init_kwargs[field.field.name] = value
                     if registry == Feature:
-                        filter_kwargs["dtype"] = "cat" if dtype is None else dtype
-                    non_validated_records.append(registry(**filter_kwargs, **kwargs))
+                        init_kwargs["dtype"] = "cat" if dtype is None else dtype
+                    non_validated_records.append(
+                        registry(**init_kwargs, **filter_kwargs, **kwargs)
+                    )
             ln_save(non_validated_records)
 
         if registry == ULabel and field.field.name == "name":
             save_ulabels_with_parent(values, field=field, key=key)
+
+        # get all records
+        all_labels = registry.from_values(
+            inspect_result_current.validated + inspect_result_current.non_validated,
+            field=field,
+            **filter_kwargs,
+        )
     finally:
         settings.verbosity = verbosity
 
@@ -1123,6 +1143,8 @@ def update_registry(
         validated_only=validated_only,
     )
 
+    return all_labels
+
 
 def log_saved_labels(
     labels_saved: dict,
@@ -1168,7 +1190,7 @@ def log_saved_labels(
 def save_ulabels_with_parent(values: list[str], field: FieldAttr, key: str) -> None:
     """Save a parent label for the given labels."""
     registry = field.field.model
-    assert registry == ULabel
+    assert registry == ULabel  # noqa: S101
     all_records = registry.from_values(values, field=field)
     is_feature = registry.filter(name=f"is_{key}").one_or_none()
     if is_feature is None:

lamindb/_feature.py

@@ -46,20 +46,18 @@ def __init__(self, *args, **kwargs):
     dtype: type | str = kwargs.pop("dtype") if "dtype" in kwargs else None
     # cast type
     if dtype is None:
-        raise ValueError("Please pass a type!")
+        raise ValueError("Please pass dtype!")
     elif dtype is not None:
         if not isinstance(dtype, str):
             if not isinstance(dtype, list) and dtype.__name__ in FEATURE_TYPES:
                 dtype_str = FEATURE_TYPES[dtype.__name__]
             else:
                 if not isinstance(dtype, list):
-                    raise ValueError("dtype has to be a list of Registry types")
+                    raise ValueError("dtype has to be a list of Record types")
                 registries_str = ""
                 for cls in dtype:
                     if not hasattr(cls, "__get_name_with_schema__"):
-                        raise ValueError(
-                            "each element of the list has to be a Registry"
-                        )
+                        raise ValueError("each element of the list has to be a Record")
                     registries_str += cls.__get_name_with_schema__() + "|"
                 dtype_str = f'cat[{registries_str.rstrip("|")}]'
         else:
@@ -102,7 +100,7 @@ def categoricals_from_df(df: pd.DataFrame) -> dict:
 @classmethod  # type:ignore
 @doc_args(Feature.from_df.__doc__)
 def from_df(cls, df: pd.DataFrame, field: FieldAttr | None = None) -> RecordsList:
-    """{}."""
+    """{}"""  # noqa: D415
     field = Feature.name if field is None else field
     categoricals = categoricals_from_df(df)
 
@@ -112,7 +110,7 @@ def from_df(cls, df: pd.DataFrame, field: FieldAttr | None = None) -> RecordsLis
         if name in categoricals:
             dtypes[name] = "cat"
             # below is a harder feature to write, now, because it requires to
-            # query the link tables between the label Registry and file or collection
+            # query the link tables between the label Record and file or collection
             # the original implementation fell short
             # categorical = categoricals[name]
             # if hasattr(
@@ -139,7 +137,7 @@ def from_df(cls, df: pd.DataFrame, field: FieldAttr | None = None) -> RecordsLis
     finally:
         settings.verbosity = verbosity
 
-    assert len(features) == len(df.columns)
+    assert len(features) == len(df.columns)  # noqa: S101
 
     # if len(categoricals_with_unmapped_categories) > 0:
     #     n_max = 20
@@ -182,7 +180,7 @@ def from_df(cls, df: pd.DataFrame, field: FieldAttr | None = None) -> RecordsLis
 
 @doc_args(Feature.save.__doc__)
 def save(self, *args, **kwargs) -> Feature:
-    """{}."""
+    """{}"""  # noqa: D415
     super(Feature, self).save(*args, **kwargs)
     return self
 

lamindb/_feature_set.py

@@ -7,13 +7,13 @@ 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, Registry, ids
+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 ._registry import init_self_from_db
+from ._record import init_self_from_db
 from .core.exceptions import ValidationError
 from .core.schema import (
     dict_related_model_to_related_name,
@@ -29,7 +29,7 @@ NUMBER_TYPE = "number"
 DICT_KEYS_TYPE = type({}.keys())  # type: ignore
 
 
-def validate_features(features: list[Registry]) -> Registry:
+def validate_features(features: list[Record]) -> Record:
     """Validate and return feature type."""
     try:
         if len(features) == 0:
@@ -40,7 +40,7 @@ def validate_features(features: list[Registry]) -> Registry:
         ) from None
     if not hasattr(features, "__getitem__"):
         raise TypeError("features has to be list-like")
-    if not isinstance(features[0], Registry):
+    if not isinstance(features[0], Record):
         raise TypeError(
             "features has to store feature records! use .from_values() otherwise"
         )
@@ -60,11 +60,11 @@ def __init__(self, *args, **kwargs):
     # now we proceed with the user-facing constructor
     if len(args) > 1:
         raise ValueError("Only one non-keyword arg allowed: features")
-    features: Iterable[Registry] = kwargs.pop("features") if len(args) == 0 else args[0]
+    features: Iterable[Record] = kwargs.pop("features") if len(args) == 0 else args[0]
     dtype: str | None = kwargs.pop("dtype") if "dtype" in kwargs else None
     name: str | None = kwargs.pop("name") if "name" in kwargs else None
     if len(kwargs) > 0:
-        raise ValueError("Only features, type, name are valid keyword arguments")
+        raise ValueError("Only features, dtype, name are valid keyword arguments")
     # now code
     features_registry = validate_features(features)
     if dtype is None:
@@ -91,12 +91,13 @@ def __init__(self, *args, **kwargs):
 
 
 @doc_args(FeatureSet.save.__doc__)
-def save(self, *args, **kwargs) -> None:
-    """{}."""
+def save(self, *args, **kwargs) -> FeatureSet:
+    """{}"""  # noqa: D415
     super(FeatureSet, self).save(*args, **kwargs)
     if hasattr(self, "_features"):
         related_name, records = self._features
         getattr(self, related_name).set(records)
+    return self
 
 
 def get_type_str(dtype: str | None) -> str | None:
@@ -116,15 +117,13 @@ def from_values(
     type: str | None = None,
     name: str | None = None,
     mute: bool = False,
-    organism: Registry | str | None = None,
-    public_source: Registry | None = None,
+    organism: Record | str | None = None,
+    public_source: Record | None = None,
     raise_validation_error: bool = True,
 ) -> FeatureSet:
-    """{}."""
+    """{}"""  # noqa: D415
     if not isinstance(field, FieldAttr):
-        raise TypeError(
-            "Argument `field` must be a Registry field, e.g., `Feature.name`"
-        )
+        raise TypeError("Argument `field` must be a Record field, e.g., `Feature.name`")
     if len(values) == 0:
         raise ValueError("Provide a list of at least one value")
     if isinstance(values, DICT_KEYS_TYPE):
@@ -168,10 +167,10 @@ def from_df(
     field: FieldAttr = Feature.name,
     name: str | None = None,
     mute: bool = False,
-    organism: Registry | str | None = None,
-    public_source: Registry | None = None,
+    organism: Record | str | None = None,
+    public_source: Record | None = None,
 ) -> FeatureSet | None:
-    """{}."""
+    """{}"""  # noqa: D415
     registry = field.field.model
     validated = registry.validate(df.columns, field=field, mute=mute, organism=organism)
     if validated.sum() == 0:
@@ -203,7 +202,7 @@ def from_df(
 @property  # type: ignore
 @doc_args(FeatureSet.members.__doc__)
 def members(self) -> QuerySet:
-    """{}."""
+    """{}"""  # noqa: D415
     if self._state.adding:
         # this should return a queryset and not a list...
         # need to fix this

lamindb/_filter.py

@@ -1,18 +1,18 @@
 from __future__ import annotations
 
-from lnschema_core import Artifact, Collection, Feature, Registry
+from lnschema_core import Artifact, Collection, Feature, Record
 from lnschema_core.types import VisibilityChoice
 
 from lamindb import settings
 from lamindb._query_set import QuerySet
 
 
-def filter(Registry: type[Registry], **expressions) -> QuerySet:
-    """See :meth:`~lamindb.core.Registry.filter`."""
+def filter(Record: type[Record], **expressions) -> QuerySet:
+    """See :meth:`~lamindb.core.Record.filter`."""
     _using_key = None
     if "_using_key" in expressions:
         _using_key = expressions.pop("_using_key")
-    if Registry in {Artifact, Collection}:
+    if Record in {Artifact, Collection}:
         # visibility is set to 0 unless expressions contains id or uid equality
         if not (
             "id" in expressions
@@ -29,7 +29,7 @@ def filter(Registry: type[Registry], **expressions) -> QuerySet:
             # sense for a non-NULLABLE column
             elif visibility in expressions and expressions[visibility] is None:
                 expressions.pop(visibility)
-    qs = QuerySet(model=Registry, using=_using_key)
+    qs = QuerySet(model=Record, using=_using_key)
     if len(expressions) > 0:
         return qs.filter(**expressions)
     else:

lamindb/_finish.py

@@ -41,7 +41,10 @@ def finish() -> None:
     if run_context.run is None:
         raise TrackNotCalled("Please run `ln.track()` before `ln.finish()`")
     if run_context.path is None:
-        assert run_context.transform.type not in {"script", "notebook"}
+        if run_context.transform.type in {"script", "notebook"}:
+            raise ValueError(
+                f"Transform type is not allowed to be 'script' or 'notebook' but is {run_context.transform.type}."
+            )
         run_context.run.finished_at = datetime.now(timezone.utc)
         run_context.run.save()
         # nothing else to do
@@ -107,9 +110,14 @@ def save_run_context_core(
         # convert the notebook file to html
         # log_level is set to 40 to silence the nbconvert logging
         subprocess.run(
-            "jupyter nbconvert --to html"
-            f" '{filepath.as_posix()}' --Application.log_level=40",
-            shell=True,
+            [
+                "jupyter",
+                "nbconvert",
+                "--to",
+                "html",
+                filepath.as_posix(),
+                "--Application.log_level=40",
+            ],
             check=True,
         )
         # move the temporary file into the cache dir in case it's accidentally
@@ -129,8 +137,12 @@ def save_run_context_core(
         source_code_path = ln_setup.settings.storage.cache_dir / filepath.name
         shutil.copy2(filepath, source_code_path)  # copy
         subprocess.run(
-            f"nbstripout '{source_code_path}' --extra-keys='metadata.version metadata.kernelspec metadata.language_info metadata.pygments_lexer metadata.name metadata.file_extension'",
-            shell=True,
+            [
+                "nbstripout",
+                source_code_path,
+                "--extra-keys",
+                "metadata.version metadata.kernelspec metadata.language_info metadata.pygments_lexer metadata.name metadata.file_extension",
+            ],
             check=True,
         )
     # find initial versions of source codes and html reports

lamindb/_from_values.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING, Any, Iterable
 import pandas as pd
 from django.core.exceptions import FieldDoesNotExist
 from lamin_utils import colors, logger
-from lnschema_core.models import Feature, Registry, ULabel
+from lnschema_core.models import Feature, Record, ULabel
 
 from .core._settings import settings
 
@@ -20,14 +20,14 @@ def get_or_create_records(
     *,
     create: bool = False,
     from_public: bool = False,
-    organism: Registry | str | None = None,
-    public_source: Registry | None = None,
+    organism: Record | str | None = None,
+    public_source: Record | None = None,
     mute: bool = False,
-) -> list[Registry]:
+) -> list[Record]:
     """Get or create records from iterables."""
-    Registry = field.field.model
+    Record = field.field.model
     if create:
-        return [Registry(**{field.field.name: value}) for value in iterable]
+        return [Record(**{field.field.name: value}) for value in iterable]
     creation_search_names = settings.creation.search_names
     feature: Feature = None
     organism = _get_organism_record(field, organism)
@@ -68,14 +68,14 @@ def get_or_create_records(
                     logger.success(msg)
                 s = "" if len(unmapped_values) == 1 else "s"
                 print_values = colors.yellow(_print_values(unmapped_values))
-                name = Registry.__name__
+                name = Record.__name__
                 n_nonval = colors.yellow(f"{len(unmapped_values)} non-validated")
                 if not mute:
                     logger.warning(
                         f"{colors.red('did not create')} {name} record{s} for "
                         f"{n_nonval} {colors.italic(f'{field.field.name}{s}')}: {print_values}"
                     )
-        if Registry.__module__.startswith("lnschema_bionty.") or Registry == ULabel:
+        if Record.__module__.startswith("lnschema_bionty.") or Record == ULabel:
             if isinstance(iterable, pd.Series):
                 feature = iterable.name
             feature_name = None
@@ -301,7 +301,7 @@ def _print_values(names: Iterable, n: int = 20, quotes: bool = True) -> str:
     return print_values
 
 
-def _filter_bionty_df_columns(model: Registry, public_ontology: Any) -> pd.DataFrame:
+def _filter_bionty_df_columns(model: Record, public_ontology: Any) -> pd.DataFrame:
     bionty_df = pd.DataFrame()
     if public_ontology is not None:
         model_field_names = {i.name for i in model._meta.fields}
@@ -359,7 +359,7 @@ def _bulk_create_dicts_from_df(
     return df.reset_index().to_dict(orient="records"), multi_msg
 
 
-def _has_organism_field(orm: Registry) -> bool:
+def _has_organism_field(orm: Record) -> bool:
     try:
         orm._meta.get_field("organism")
         return True
@@ -368,8 +368,8 @@ def _has_organism_field(orm: Registry) -> bool:
 
 
 def _get_organism_record(
-    field: StrField, organism: str | Registry, force: bool = False
-) -> Registry:
+    field: StrField, organism: str | Record, force: bool = False
+) -> Record:
     model = field.field.model
     check = True if force else field.field.name != "ensembl_gene_id"
 

lamindb/_is_versioned.py

@@ -11,7 +11,7 @@ from .core.versioning import get_new_path_from_uid, get_uid_from_old_version
 
 
 # docstring handled through attach_func_to_class_method
-def add_to_version_family(
+def _add_to_version_family(
     self, is_new_version_of: IsVersioned, version: str | None = None
 ):
     old_uid = self.uid
@@ -30,7 +30,7 @@ def add_to_version_family(
 
 
 METHOD_NAMES = [
-    "add_to_version_family",
+    "_add_to_version_family",
 ]
 
 if ln_setup._TESTING:  # type: ignore