lamindb 0.64.2__py3-none-any.whl → 0.65.1__py3-none-any.whl

lamindb/__init__.py

@@ -6,7 +6,7 @@ LaminDB helps you manage data batches with two basic registries:
    :toctree: .
 
    Artifact
-   Dataset
+   Collection
 
 Four registries track provenance of data batches:
 
@@ -54,7 +54,7 @@ Modules & settings:
 
 """
 
-__version__ = "0.64.2"  # denote a release candidate for 0.1.0 with 0.1rc1
+__version__ = "0.65.1"  # denote a release candidate for 0.1.0 with 0.1rc1
 
 import os as _os
 
@@ -92,7 +92,7 @@ if _INSTANCE_SETUP:
     del __getattr__  # delete so that imports work out
     from lnschema_core import (
         Artifact,
-        Dataset,
+        Collection,
         Feature,
         FeatureSet,
         Run,
@@ -104,7 +104,7 @@ if _INSTANCE_SETUP:
 
     File = Artifact  # backward compat
     from . import _artifact  # noqa
-    from . import _dataset
+    from . import _collection
     from . import _feature
     from . import _feature_set
     from . import _parents

lamindb/_artifact.py

@@ -41,7 +41,7 @@ from lamindb.dev.storage.file import (
     auto_storage_key_from_artifact_uid,
     filepath_from_artifact,
 )
-from lamindb.dev.versioning import get_ids_from_old_version, init_uid
+from lamindb.dev.versioning import get_uid_from_old_version, init_uid
 
 from . import _TESTING
 from ._feature import convert_numpy_dtype_to_lamin_feature_type
@@ -513,9 +513,6 @@ def __init__(artifact: Artifact, *args, **kwargs):
     is_new_version_of: Optional[Artifact] = (
         kwargs.pop("is_new_version_of") if "is_new_version_of" in kwargs else None
     )
-    initial_version_id: Optional[int] = (
-        kwargs.pop("initial_version_id") if "initial_version_id" in kwargs else None
-    )
     version: Optional[str] = kwargs.pop("version") if "version" in kwargs else None
     visibility: Optional[int] = (
         kwargs.pop("visibility")
@@ -539,18 +536,11 @@ def __init__(artifact: Artifact, *args, **kwargs):
     else:
         if not isinstance(is_new_version_of, Artifact):
             raise TypeError("is_new_version_of has to be of type ln.Artifact")
-        provisional_uid, initial_version_id, version = get_ids_from_old_version(
+        provisional_uid, version = get_uid_from_old_version(
             is_new_version_of, version, n_full_id=20
         )
         if description is None:
             description = is_new_version_of.description
-
-    if version is not None:
-        if initial_version_id is None:
-            logger.info(
-                "initializing versioning for this file! create future versions of it"
-                " using ln.Artifact(..., is_new_version_of=old_file)"
-            )
     kwargs_or_artifact, privates = get_artifact_kwargs_from_data(
         data=data,
         key=key,
@@ -588,7 +578,6 @@ def __init__(artifact: Artifact, *args, **kwargs):
         kwargs["accessor"] = "MuData"
 
     kwargs["uid"] = provisional_uid
-    kwargs["initial_version_id"] = initial_version_id
     kwargs["version"] = version
     kwargs["description"] = description
     kwargs["visibility"] = visibility

lamindb/{_dataset.py → _collection.py}

@@ -5,13 +5,13 @@ import anndata as ad
 import pandas as pd
 from lamin_utils import logger
 from lamindb_setup.dev._docs import doc_args
-from lnschema_core.models import Dataset, Feature, FeatureSet
+from lnschema_core.models import Collection, Feature, FeatureSet
 from lnschema_core.types import AnnDataLike, DataLike, FieldAttr, VisibilityChoice
 
 from lamindb._utils import attach_func_to_class_method
 from lamindb.dev._data import _track_run_input
-from lamindb.dev._mapped_dataset import MappedDataset
-from lamindb.dev.versioning import get_ids_from_old_version, init_uid
+from lamindb.dev._mapped_collection import MappedCollection
+from lamindb.dev.versioning import get_uid_from_old_version, init_uid
 
 from . import _TESTING, Artifact, Run
 from ._artifact import parse_feature_sets_from_anndata
@@ -29,12 +29,12 @@ if TYPE_CHECKING:
 
 
 def __init__(
-    dataset: Dataset,
+    collection: Collection,
     *args,
     **kwargs,
 ):
-    if len(args) == len(dataset._meta.concrete_fields):
-        super(Dataset, dataset).__init__(*args, **kwargs)
+    if len(args) == len(collection._meta.concrete_fields):
+        super(Collection, collection).__init__(*args, **kwargs)
         return None
     # now we proceed with the user-facing constructor
     if len(args) > 1:
@@ -54,12 +54,9 @@ def __init__(
         kwargs.pop("reference_type") if "reference_type" in kwargs else None
     )
     run: Optional[Run] = kwargs.pop("run") if "run" in kwargs else None
-    is_new_version_of: Optional[Dataset] = (
+    is_new_version_of: Optional[Collection] = (
         kwargs.pop("is_new_version_of") if "is_new_version_of" in kwargs else None
     )
-    initial_version_id: Optional[int] = (
-        kwargs.pop("initial_version_id") if "initial_version_id" in kwargs else None
-    )
     version: Optional[str] = kwargs.pop("version") if "version" in kwargs else None
     visibility: Optional[int] = (
         kwargs.pop("visibility")
@@ -77,20 +74,13 @@ def __init__(
     if is_new_version_of is None:
         provisional_uid = init_uid(version=version, n_full_id=20)
     else:
-        if not isinstance(is_new_version_of, Dataset):
-            raise TypeError("is_new_version_of has to be of type ln.Dataset")
-        provisional_uid, initial_version_id, version = get_ids_from_old_version(
+        if not isinstance(is_new_version_of, Collection):
+            raise TypeError("is_new_version_of has to be of type ln.Collection")
+        provisional_uid, version = get_uid_from_old_version(
             is_new_version_of, version, n_full_id=20
         )
         if name is None:
             name = is_new_version_of.name
-    if version is not None:
-        if initial_version_id is None:
-            logger.info(
-                "initializing versioning for this dataset! create future versions of it"
-                " using ln.Dataset(..., is_new_version_of=old_dataset)"
-            )
-
     run = get_run(run)
     data_init_complete = False
     artifact = None
@@ -107,7 +97,7 @@ def __init__(
         if isinstance(data, Artifact):
             artifact = data
             if artifact._state.adding:
-                raise ValueError("Save artifact before creating dataset!")
+                raise ValueError("Save artifact before creating collection!")
             if not feature_sets:
                 feature_sets = artifact.features._feature_set_by_slot
             else:
@@ -132,7 +122,7 @@ def __init__(
         hash = artifact.hash  # type: ignore
         provisional_uid = artifact.uid  # type: ignore
         if artifact.description is None or artifact.description == "tmp":
-            artifact.description = f"See dataset {provisional_uid}"  # type: ignore
+            artifact.description = f"See collection {provisional_uid}"  # type: ignore
         data_init_complete = True
     if not data_init_complete:
         if hasattr(data, "__getitem__"):
@@ -144,23 +134,25 @@ def __init__(
             raise ValueError(
                 "Only DataFrame, AnnData, Artifact or list of artifacts is allowed."
             )
-    # we ignore datasets in trash containing the same hash
+    # we ignore collections in trash containing the same hash
     if hash is not None:
-        existing_dataset = Dataset.filter(hash=hash).one_or_none()
+        existing_collection = Collection.filter(hash=hash).one_or_none()
     else:
-        existing_dataset = None
-    if existing_dataset is not None:
-        logger.warning(f"returning existing dataset with same hash: {existing_dataset}")
-        init_self_from_db(dataset, existing_dataset)
-        for slot, feature_set in dataset.features._feature_set_by_slot.items():
+        existing_collection = None
+    if existing_collection is not None:
+        logger.warning(
+            f"returning existing collection with same hash: {existing_collection}"
+        )
+        init_self_from_db(collection, existing_collection)
+        for slot, feature_set in collection.features._feature_set_by_slot.items():
             if slot in feature_sets:
                 if not feature_sets[slot] == feature_set:
-                    dataset.feature_sets.remove(feature_set)
+                    collection.feature_sets.remove(feature_set)
                     logger.warning(f"removing feature set: {feature_set}")
     else:
         kwargs = {}
         add_transform_to_kwargs(kwargs, run)
-        super(Dataset, dataset).__init__(
+        super(Collection, collection).__init__(
             uid=provisional_uid,
             name=name,
             description=description,
@@ -170,12 +162,11 @@ def __init__(
             hash=hash,
             run=run,
             version=version,
-            initial_version_id=initial_version_id,
             visibility=visibility,
             **kwargs,
         )
-    dataset._artifacts = artifacts
-    dataset._feature_sets = feature_sets
+    collection._artifacts = artifacts
+    collection._feature_sets = feature_sets
     # register provenance
     if is_new_version_of is not None:
         _track_run_input(is_new_version_of, run=run)
@@ -186,7 +177,7 @@ def __init__(
 
 
 @classmethod  # type: ignore
-@doc_args(Dataset.from_df.__doc__)
+@doc_args(Collection.from_df.__doc__)
 def from_df(
     cls,
     df: "pd.DataFrame",
@@ -199,14 +190,14 @@ def from_df(
     version: Optional[str] = None,
     is_new_version_of: Optional["Artifact"] = None,
     **kwargs,
-) -> "Dataset":
+) -> "Collection":
     """{}."""
     feature_set = FeatureSet.from_df(df, field=field, **kwargs)
     if feature_set is not None:
         feature_sets = {"columns": feature_set}
     else:
         feature_sets = {}
-    dataset = Dataset(
+    collection = Collection(
         data=df,
         name=name,
         run=run,
@@ -217,11 +208,11 @@ def from_df(
         version=version,
         is_new_version_of=is_new_version_of,
     )
-    return dataset
+    return collection
 
 
 @classmethod  # type: ignore
-@doc_args(Dataset.from_anndata.__doc__)
+@doc_args(Collection.from_anndata.__doc__)
 def from_anndata(
     cls,
     adata: "AnnDataLike",
@@ -234,7 +225,7 @@ def from_anndata(
     version: Optional[str] = None,
     is_new_version_of: Optional["Artifact"] = None,
     **kwargs,
-) -> "Dataset":
+) -> "Collection":
     """{}."""
     if isinstance(adata, Artifact):
         assert not adata._state.adding
@@ -243,7 +234,7 @@ def from_anndata(
     else:
         adata_parse = adata
     feature_sets = parse_feature_sets_from_anndata(adata_parse, field, **kwargs)
-    dataset = Dataset(
+    collection = Collection(
         data=adata,
         run=run,
         name=name,
@@ -254,7 +245,7 @@ def from_anndata(
         version=version,
         is_new_version_of=is_new_version_of,
     )
-    return dataset
+    return collection
 
 
 # internal function, not exposed to user
@@ -323,10 +314,12 @@ def mapped(
     label_keys: Optional[Union[str, List[str]]] = None,
     join_vars: Optional[Literal["auto", "inner"]] = "auto",
     encode_labels: bool = True,
+    cache_categories: bool = True,
     parallel: bool = False,
+    dtype: Optional[str] = None,
     stream: bool = False,
     is_run_input: Optional[bool] = None,
-) -> "MappedDataset":
+) -> "MappedCollection":
     _track_run_input(self, is_run_input)
     path_list = []
     for artifact in self.artifacts.all():
@@ -337,7 +330,15 @@ def mapped(
             path_list.append(artifact.stage())
         else:
             path_list.append(artifact.path)
-    return MappedDataset(path_list, label_keys, join_vars, encode_labels, parallel)
+    return MappedCollection(
+        path_list,
+        label_keys,
+        join_vars,
+        encode_labels,
+        cache_categories,
+        parallel,
+        dtype,
+    )
 
 
 # docstring handled through attach_func_to_class_method
@@ -346,7 +347,9 @@ def backed(
 ) -> Union["AnnDataAccessor", "BackedAccessor"]:
     _track_run_input(self, is_run_input)
     if self.artifact is None:
-        raise RuntimeError("Can only call backed() for datasets with a single artifact")
+        raise RuntimeError(
+            "Can only call backed() for collections with a single artifact"
+        )
     return self.artifact.backed()
 
 
@@ -366,9 +369,9 @@ def load(
         suffixes = [artifact.suffix for artifact in all_artifacts]
         if len(set(suffixes)) != 1:
             raise RuntimeError(
-                "Can only load datasets where all artifacts have the same suffix"
+                "Can only load collections where all artifacts have the same suffix"
             )
-        # because we're tracking data flow on the dataset-level, here, we don't
+        # because we're tracking data flow on the collection-level, here, we don't
         # want to track it on the artifact-level
         objects = [artifact.load(is_run_input=False) for artifact in all_artifacts]
         artifact_uids = [artifact.uid for artifact in all_artifacts]
@@ -391,17 +394,17 @@ def delete(
     if self.visibility > VisibilityChoice.trash.value and permanent is not True:
         self.visibility = VisibilityChoice.trash.value
         self.save()
-        logger.warning("moved dataset to trash.")
+        logger.warning("moved collection to trash.")
         if self.artifact is not None:
             self.artifact.visibility = VisibilityChoice.trash.value
             self.artifact.save()
-            logger.warning("moved dataset.artifact to trash.")
+            logger.warning("moved collection.artifact to trash.")
         return
 
     # permanent delete
     if permanent is None:
         response = input(
-            "Dataset record is already in trash! Are you sure to delete it from your"
+            "Collection record is already in trash! Are you sure to delete it from your"
             " database? (y/n) You can't undo this action."
         )
         delete_record = response == "y"
@@ -409,7 +412,7 @@ def delete(
         delete_record = permanent
 
     if delete_record:
-        super(Dataset, self).delete()
+        super(Collection, self).delete()
     if self.artifact is not None:
         self.artifact.delete(permanent=permanent, storage=storage)
 
@@ -420,7 +423,7 @@ def save(self, *args, **kwargs) -> None:
         self.artifact.save()
     # we don't need to save feature sets again
     save_feature_sets(self)
-    super(Dataset, self).save()
+    super(Collection, self).save()
     if hasattr(self, "_artifacts"):
         if self._artifacts is not None and len(self._artifacts) > 0:
             self.artifacts.set(self._artifacts)
@@ -452,13 +455,13 @@ if _TESTING:
     from inspect import signature
 
     SIGS = {
-        name: signature(getattr(Dataset, name))
+        name: signature(getattr(Collection, name))
         for name in METHOD_NAMES
         if name != "__init__"
     }
 
 for name in METHOD_NAMES:
-    attach_func_to_class_method(name, Dataset, globals())
+    attach_func_to_class_method(name, Collection, globals())
 
 # this seems a Django-generated function
-delattr(Dataset, "get_visibility_display")
+delattr(Collection, "get_visibility_display")

lamindb/_feature.py

@@ -96,7 +96,7 @@ def from_df(cls, df: "pd.DataFrame") -> List["Feature"]:
         if name in categoricals:
             types[name] = "category"
             # below is a harder feature to write, now, because it requires to
-            # query the link tables between the label Registry and file or dataset
+            # query the link tables between the label Registry and file or collection
             # the original implementation fell short
             # categorical = categoricals[name]
             # if hasattr(

lamindb/_filter.py

@@ -1,6 +1,6 @@
 from typing import Type
 
-from lnschema_core import Artifact, Dataset, Registry
+from lnschema_core import Artifact, Collection, Registry
 from lnschema_core.types import VisibilityChoice
 
 from lamindb._query_set import QuerySet
@@ -8,7 +8,7 @@ from lamindb._query_set import QuerySet
 
 def filter(Registry: Type[Registry], **expressions) -> QuerySet:
     """See :meth:`~lamindb.dev.Registry.filter`."""
-    if Registry in {Artifact, Dataset}:
+    if Registry in {Artifact, Collection}:
         # visibility is set to 0 unless expressions contains id or uid equality
         if not ("id" in expressions or "uid" in expressions):
             visibility = "visibility"

lamindb/_parents.py

@@ -2,7 +2,7 @@ import builtins
 from typing import List, Optional, Set, Union
 
 from lamin_utils import logger
-from lnschema_core import Artifact, Dataset, Registry, Run, Transform
+from lnschema_core import Artifact, Collection, Registry, Run, Transform
 from lnschema_core.models import HasParents, format_field_value
 
 from lamindb._utils import attach_func_to_class_method
@@ -61,14 +61,14 @@ def view_parents(
     )
 
 
-def view_lineage(data: Union[Artifact, Dataset], with_children: bool = True) -> None:
+def view_lineage(data: Union[Artifact, Collection], with_children: bool = True) -> None:
     """Graph of data flow.
 
     Notes:
         For more info, see use cases: :doc:`docs:data-flow`.
 
     Examples:
-        >>> dataset.view_lineage()
+        >>> collection.view_lineage()
         >>> artifact.view_lineage()
     """
     import graphviz
@@ -81,7 +81,7 @@ def view_lineage(data: Union[Artifact, Dataset], with_children: bool = True) ->
     data_label = _record_label(data)
 
     def add_node(
-        record: Union[Run, Artifact, Dataset],
+        record: Union[Run, Artifact, Collection],
         node_id: str,
         node_label: str,
         u: graphviz.Digraph,
@@ -267,7 +267,7 @@ def _record_label(record: Registry, field: Optional[str] = None):
             rf'<📄 {name}<BR/><FONT COLOR="GREY" POINT-SIZE="10"'
             rf' FACE="Monospace">uid={record.uid}<BR/>suffix={record.suffix}</FONT>>'
         )
-    elif isinstance(record, Dataset):
+    elif isinstance(record, Collection):
         name = record.name.replace("&", "&amp;")
         return (
             rf'<🍱 {name}<BR/><FONT COLOR="GREY" POINT-SIZE="10"'
@@ -305,8 +305,8 @@ def _add_emoji(record: Registry, label: str):
     return f"{emoji} {label}"
 
 
-def _get_all_parent_runs(data: Union[Artifact, Dataset]) -> List:
-    """Get all input file/dataset runs recursively."""
+def _get_all_parent_runs(data: Union[Artifact, Collection]) -> List:
+    """Get all input file/collection runs recursively."""
     name = data._meta.model_name
     run_inputs_outputs = []
 
@@ -317,30 +317,36 @@ def _get_all_parent_runs(data: Union[Artifact, Dataset]) -> List:
             inputs_run = (
                 r.__getattribute__(f"input_{name}s").all().filter(visibility=1).list()
             )
-            if name == "file":
-                inputs_run += r.input_datasets.all().filter(visibility=1).list()
+            if name == "artifact":
+                inputs_run += r.input_collections.all().filter(visibility=1).list()
             run_inputs_outputs += [(inputs_run, r)]
             outputs_run = (
                 r.__getattribute__(f"output_{name}s").all().filter(visibility=1).list()
             )
-            if name == "file":
-                outputs_run += r.output_datasets.all().filter(visibility=1).list()
+            if name == "artifact":
+                outputs_run += r.output_collections.all().filter(visibility=1).list()
             run_inputs_outputs += [(r, outputs_run)]
             inputs += inputs_run
         runs = [f.run for f in inputs if f.run is not None]
     return run_inputs_outputs
 
 
-def _get_all_child_runs(data: Union[Artifact, Dataset]) -> List:
-    """Get all output file/dataset runs recursively."""
+def _get_all_child_runs(data: Union[Artifact, Collection]) -> List:
+    """Get all output file/collection runs recursively."""
     name = data._meta.model_name
     all_runs: Set[Run] = set()
     run_inputs_outputs = []
 
-    runs = {f.run for f in data.run.__getattribute__(f"output_{name}s").all()}
-    if name == "file":
+    if data.run is not None:
+        runs = {f.run for f in data.run.__getattribute__(f"output_{name}s").all()}
+    else:
+        runs = set()
+    if name == "artifact" and data.run is not None:
         runs.update(
-            {f.run for f in data.run.output_datasets.all().filter(visibility=1).all()}
+            {
+                f.run
+                for f in data.run.output_collections.all().filter(visibility=1).all()
+            }
         )
     while runs.difference(all_runs):
         all_runs.update(runs)
@@ -349,24 +355,24 @@ def _get_all_child_runs(data: Union[Artifact, Dataset]) -> List:
             inputs_run = (
                 r.__getattribute__(f"input_{name}s").all().filter(visibility=1).list()
             )
-            if name == "file":
-                inputs_run += r.input_datasets.all().filter(visibility=1).list()
+            if name == "artifact":
+                inputs_run += r.input_collections.all().filter(visibility=1).list()
             run_inputs_outputs += [(inputs_run, r)]
             outputs_run = (
                 r.__getattribute__(f"output_{name}s").all().filter(visibility=1).list()
             )
-            if name == "file":
-                outputs_run += r.output_datasets.all().filter(visibility=1).list()
+            if name == "artifact":
+                outputs_run += r.output_collections.all().filter(visibility=1).list()
             run_inputs_outputs += [(r, outputs_run)]
             child_runs.update(
                 Run.filter(
                     **{f"input_{name}s__id__in": [i.id for i in outputs_run]}
                 ).list()
             )
-            if name == "file":
+            if name == "artifact":
                 child_runs.update(
                     Run.filter(
-                        input_datasets__id__in=[i.id for i in outputs_run]
+                        input_collections__id__in=[i.id for i in outputs_run]
                     ).list()
                 )
         runs = child_runs

lamindb/_query_manager.py

@@ -31,7 +31,7 @@ class QueryManager(models.Manager):
     def _track_run_input_manager(self):
         if hasattr(self, "source_field_name") and hasattr(self, "target_field_name"):
             if (
-                self.source_field_name == "dataset"
+                self.source_field_name == "collection"
                 and self.target_field_name == "artifact"
             ):
                 from lamindb.dev._data import WARNING_RUN_TRANSFORM, _track_run_input
@@ -98,7 +98,7 @@ class QueryManager(models.Manager):
             target_field_name = self.target_field_name
 
             if (
-                source_field_name in {"artifact", "dataset"}
+                source_field_name in {"artifact", "collection"}
                 and target_field_name == "feature_set"
             ):
                 return get_feature_set_by_slot(host=self.instance).get(item)

lamindb/_registry.py

@@ -350,6 +350,9 @@ def using(
     instance: str,
 ) -> "QuerySet":
     """{}."""
+    from lamindb_setup._load_instance import update_db_using_local
+    from lamindb_setup.dev._settings_store import instance_settings_file
+
     owner, name = get_owner_name_from_identifier(instance)
     load_result = load_instance(owner=owner, name=name)
     if isinstance(load_result, str):
@@ -357,12 +360,14 @@ def using(
             f"Fail to load instance {instance}, please check your permission!"
         )
     instance_result, storage_result = load_result
+    settings_file = instance_settings_file(name, owner)
+    db_updated = update_db_using_local(instance_result, settings_file)
     isettings = InstanceSettings(
         owner=owner,
         name=name,
         storage_root=storage_result["root"],
         storage_region=storage_result["region"],
-        db=instance_result["db"],
+        db=db_updated,
         schema=instance_result["schema_str"],
         id=UUID(instance_result["id"]),
     )
@@ -377,8 +382,10 @@ REGISTRY_UNIQUE_FIELD = {
 }
 
 
-def update_fk_to_default_db(records: Union[Registry, List[Registry]], fk: str):
-    record = records[0] if isinstance(records, List) else records
+def update_fk_to_default_db(
+    records: Union[Registry, List[Registry], QuerySet], fk: str
+):
+    record = records[0] if isinstance(records, (List, QuerySet)) else records
     if hasattr(record, f"{fk}_id") and getattr(record, f"{fk}_id") is not None:
         fk_record = getattr(record, fk)
         field = REGISTRY_UNIQUE_FIELD.get(fk, "uid")
@@ -390,7 +397,7 @@ def update_fk_to_default_db(records: Union[Registry, List[Registry]], fk: str):
 
             fk_record_default = copy(fk_record)
             transfer_to_default_db(fk_record_default, save=True)
-        if isinstance(records, List):
+        if isinstance(records, (List, QuerySet)):
             for r in records:
                 setattr(r, f"{fk}", None)
                 setattr(r, f"{fk}_id", fk_record_default.id)
@@ -399,7 +406,7 @@ def update_fk_to_default_db(records: Union[Registry, List[Registry]], fk: str):
             setattr(records, f"{fk}_id", fk_record_default.id)
 
 
-def transfer_fk_to_default_db_bulk(records: List):
+def transfer_fk_to_default_db_bulk(records: Union[List, QuerySet]):
     for fk in [
         "organism",
         "bionty_source",
@@ -407,7 +414,7 @@ def transfer_fk_to_default_db_bulk(records: List):
         "latest_report",  # Transform
         "source_code",  # Transform
         "report",  # Run
-        "file",  # Dataset
+        "file",  # Collection
     ]:
         update_fk_to_default_db(records, fk)
 
@@ -462,7 +469,11 @@ def save(self, *args, **kwargs) -> None:
     if result is not None:
         init_self_from_db(self, result)
     else:
-        super(Registry, self).save(*args, **kwargs)
+        # here, we can't use the parents argument
+        save_kwargs = kwargs.copy()
+        if "parents" in save_kwargs:
+            save_kwargs.pop("parents")
+        super(Registry, self).save(*args, **save_kwargs)
     if db is not None and db != "default":
         if hasattr(self, "labels"):
             from copy import copy
@@ -470,10 +481,13 @@ def save(self, *args, **kwargs) -> None:
             self_on_db = copy(self)
             self_on_db._state.db = db
             self_on_db.pk = pk_on_db
+            add_from_kwargs = {
+                "parents": kwargs.get("parents") if "parents" in kwargs else True
+            }
             logger.info("transfer features")
-            self.features._add_from(self_on_db)
+            self.features._add_from(self_on_db, **add_from_kwargs)
             logger.info("transfer labels")
-            self.labels.add_from(self_on_db)
+            self.labels.add_from(self_on_db, **add_from_kwargs)
 
 
 METHOD_NAMES = [