lamindb 0.76.0__py3-none-any.whl → 0.76.2__py3-none-any.whl

lamindb/_feature.py

@@ -109,18 +109,6 @@ def from_df(cls, df: pd.DataFrame, field: FieldAttr | None = None) -> RecordsLis
     for name, col in df.items():
         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 Record and file or collection
-            # the original implementation fell short
-            # categorical = categoricals[name]
-            # if hasattr(
-            #     categorical, "cat"
-            # ):  # because .categories > pd2.0, .cat.categories < pd2.0
-            #     categorical = categorical.cat
-            # categories = categorical.categories
-            # categoricals_with_unmapped_categories[name] = ULabel.filter(
-            #     feature=name
-            # ).inspect(categories, "name", logging=False)["not_mapped"]
         else:
             dtypes[name] = convert_numpy_dtype_to_lamin_feature_type(col.dtype)
 
@@ -138,46 +126,9 @@ def from_df(cls, df: pd.DataFrame, field: FieldAttr | None = None) -> RecordsLis
         settings.verbosity = verbosity
 
     assert len(features) == len(df.columns)  # noqa: S101
-
-    # if len(categoricals_with_unmapped_categories) > 0:
-    #     n_max = 20
-    #     categoricals_with_unmapped_categories_formatted = "\n      ".join(
-    #         [
-    #             (
-    #                 f"{key} ({len(value)}): {', '.join(value)}"
-    #                 if len(value) <= 5
-    #                 else f"{key} ({len(value)}): {', '.join(value[:5])} ..."
-    #             )
-    #             for key, value in take(
-    #                 n_max, categoricals_with_unmapped_categories.items()
-    #             )
-    #         ]
-    #     )
-    #     if len(categoricals_with_unmapped_categories) > n_max:
-    #         categoricals_with_unmapped_categories_formatted += "\n      ..."
-    #     categoricals_with_unmapped_categories_formatted
-    #     logger.info(
-    #         f"{len(categoricals_with_unmapped_categories)} features have"
-    #         f" {colors.yellow('unmapped categories')}:\n     "
-    #         f" {categoricals_with_unmapped_categories_formatted}"
-    #     )
     return RecordsList(features)
 
 
-# def from_df(
-#     self,
-#     df: "pd.DataFrame",
-#     field: Optional[FieldAttr] = Feature.name,
-#     **kwargs,
-# ) -> Dict:
-#     feature_set = FeatureSet.from_df(df, field=field, **kwargs)
-#     if feature_set is not None:
-#         feature_sets = {"columns": feature_set}
-#     else:
-#         feature_sets = {}
-#     return feature_sets
-
-
 @doc_args(Feature.save.__doc__)
 def save(self, *args, **kwargs) -> Feature:
     """{}"""  # noqa: D415

lamindb/_filter.py

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

lamindb/_finish.py

@@ -9,9 +9,6 @@ from typing import TYPE_CHECKING
 import lamindb_setup as ln_setup
 from lamin_utils import logger
 from lamindb_setup.core.hashing import hash_file
-from lnschema_core.types import TransformType
-
-from .core._run_context import is_run_from_ipython, run_context
 
 if TYPE_CHECKING:
     from pathlib import Path
@@ -21,51 +18,7 @@ if TYPE_CHECKING:
     from ._query_set import QuerySet
 
 
-class TrackNotCalled(SystemExit):
-    pass
-
-
-class NotebookNotSaved(SystemExit):
-    pass
-
-
-def get_seconds_since_modified(filepath) -> float:
-    return datetime.now().timestamp() - filepath.stat().st_mtime
-
-
-def finish() -> None:
-    """Mark a tracked run as finished.
-
-    Saves source code and, for notebooks, a run report to your default storage location.
-    """
-    if run_context.run is None:
-        raise TrackNotCalled("Please run `ln.track()` before `ln.finish()`")
-    if run_context.path is None:
-        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
-        return None
-    if is_run_from_ipython:  # notebooks
-        if (
-            get_seconds_since_modified(run_context.path) > 3
-            and os.getenv("LAMIN_TESTING") is None
-        ):
-            raise NotebookNotSaved(
-                "Please save the notebook in your editor right before running `ln.finish()`"
-            )
-    save_run_context_core(
-        run=run_context.run,
-        transform=run_context.transform,
-        filepath=run_context.path,
-        finished_at=True,
-    )
-
-
-def save_run_context_core(
+def save_context_core(
     *,
     run: Run,
     transform: Transform,
@@ -76,6 +29,8 @@ def save_run_context_core(
 ) -> str | None:
     import lamindb as ln
 
+    from .core._context import context, is_run_from_ipython
+
     ln.settings.verbosity = "success"
 
     # for scripts, things are easy
@@ -182,7 +137,9 @@ def save_run_context_core(
                     f"replaced transform._source_code_artifact: {transform._source_code_artifact}"
                 )
             else:
-                logger.warning("Please re-run `ln.track()` to make a new version")
+                logger.warning(
+                    "Please re-run `ln.context.track()` to make a new version"
+                )
                 return "rerun-the-notebook"
         else:
             logger.important("source code is already saved")
@@ -191,7 +148,7 @@ def save_run_context_core(
             _source_code_artifact_path,
             description=f"Source of transform {transform.uid}",
             version=transform.version,
-            is_new_version_of=prev_source,
+            revises=prev_source,
             visibility=0,  # hidden file
             run=False,
         )
@@ -254,7 +211,7 @@ def save_run_context_core(
             report_file = ln.Artifact(
                 report_path,
                 description=f"Report of run {run.uid}",
-                is_new_version_of=prev_report,
+                revises=prev_report,
                 visibility=0,  # hidden file
                 run=False,
             )
@@ -282,7 +239,7 @@ def save_run_context_core(
             logger.important(
                 f"if you want to update your {thing} without re-running it, use `lamin save {name}`"
             )
-    # because run & transform changed, update the global run_context
-    run_context.run = run
-    run_context.transform = transform
+    # because run & transform changed, update the global context
+    context._run = run
+    context._transform = transform
     return None

lamindb/_from_values.py

@@ -25,9 +25,9 @@ def get_or_create_records(
     mute: bool = False,
 ) -> list[Record]:
     """Get or create records from iterables."""
-    Record = field.field.model
+    registry = field.field.model
     if create:
-        return [Record(**{field.field.name: value}) for value in iterable]
+        return [registry(**{field.field.name: value}) for value in iterable]
     creation_search_names = settings.creation.search_names
     feature: Feature = None
     organism = _get_organism_record(field, organism)
@@ -57,21 +57,23 @@ def get_or_create_records(
                     and records[0].source_id
                 ):
                     source_record = records[0].source
-            if not source_record and hasattr(Record, "public"):
+            if not source_record and hasattr(registry, "public"):
                 from bionty._bionty import get_source_record
 
-                source_record = get_source_record(Record.public(organism=organism))
+                source_record = get_source_record(
+                    registry.public(organism=organism), registry
+                )
             if source_record:
                 from bionty.core._add_ontology import check_source_in_db
 
                 check_source_in_db(
-                    registry=Record,
+                    registry=registry,
                     source=source_record,
                     update=True,
                 )
 
                 from_source = not source_record.in_db
-            elif hasattr(Record, "source_id"):
+            elif hasattr(registry, "source_id"):
                 from_source = True
             else:
                 from_source = False
@@ -97,14 +99,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 = Record.__name__
+                name = registry.__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 Record.__module__.startswith("bionty.") or Record == ULabel:
+        if registry.__get_schema_name__() == "bionty" or registry == ULabel:
             if isinstance(iterable, pd.Series):
                 feature = iterable.name
             feature_name = None
@@ -230,7 +232,7 @@ def create_records_from_source(
         # for custom records that are not created from public sources
         return records, iterable_idx
     # add source record to the kwargs
-    source_record = get_source_record(public_ontology)
+    source_record = get_source_record(public_ontology, model)
     kwargs.update({"source": source_record})
 
     # filter the columns in bionty df based on fields
@@ -373,6 +375,8 @@ def _get_organism_record(
     if _has_organism_field(registry) and check:
         from bionty._bionty import create_or_get_organism_record
 
-        organism_record = create_or_get_organism_record(organism=organism, orm=registry)
+        organism_record = create_or_get_organism_record(
+            organism=organism, registry=registry
+        )
         if organism_record is not None:
             return organism_record

lamindb/_is_versioned.py

@@ -7,15 +7,13 @@ from lnschema_core.models import IsVersioned
 
 from lamindb._utils import attach_func_to_class_method
 
-from .core.versioning import get_new_path_from_uid, get_uid_from_old_version
+from .core.versioning import create_uid, get_new_path_from_uid
 
 
 # docstring handled through attach_func_to_class_method
-def _add_to_version_family(
-    self, is_new_version_of: IsVersioned, version: str | None = None
-):
+def _add_to_version_family(self, revises: IsVersioned, version: str | None = None):
     old_uid = self.uid
-    new_uid, version = get_uid_from_old_version(is_new_version_of, version)
+    new_uid, revises = create_uid(revises=revises, version=version)
     if self.__class__.__name__ == "Artifact" and self._key_is_virtual:
         old_path = self.path
         new_path = get_new_path_from_uid(

lamindb/_query_manager.py

@@ -28,7 +28,7 @@ class QueryManager(models.Manager):
         >>> ln.save(ln.ULabel.from_values(["ULabel1", "ULabel2", "ULabel3"], field="name"))  # noqa
         >>> labels = ln.ULabel.filter(name__icontains = "label").all()
         >>> ln.ULabel(name="ULabel1").save()
-        >>> label = ln.ULabel.filter(name="ULabel1").one()
+        >>> label = ln.ULabel.get(name="ULabel1")
         >>> label.parents.set(labels)
         >>> manager = label.parents
         >>> manager.df()
@@ -40,11 +40,11 @@ class QueryManager(models.Manager):
                 self.source_field_name == "collection"
                 and self.target_field_name == "artifact"
             ):
+                from lamindb.core._context import context
                 from lamindb.core._data import WARNING_RUN_TRANSFORM, _track_run_input
-                from lamindb.core._run_context import run_context
 
                 if (
-                    run_context.run is None
+                    context.run is None
                     and not settings.creation.artifact_silence_missing_run_warning
                 ):
                     logger.warning(WARNING_RUN_TRANSFORM)
@@ -57,7 +57,7 @@ class QueryManager(models.Manager):
             >>> ln.save(ln.ULabel.from_values(["ULabel1", "ULabel2", "ULabel3"], field="name"))
             >>> labels = ln.ULabel.filter(name__icontains="label").all()
             >>> ln.ULabel(name="ULabel1").save()
-            >>> label = ln.ULabel.filter(name="ULabel1").one()
+            >>> label = ln.ULabel.get(name="ULabel1")
             >>> label.parents.set(labels)
             >>> label.parents.list()
             >>> label.parents.list("name")

lamindb/_query_set.py

@@ -17,14 +17,12 @@ from lnschema_core.models import (
     Transform,
 )
 
+from lamindb.core.exceptions import DoesNotExist
+
 if TYPE_CHECKING:
     from lnschema_core.types import ListLike, StrField
 
 
-class NoResultFound(Exception):
-    pass
-
-
 class MultipleResultsFound(Exception):
     pass
 
@@ -59,13 +57,41 @@ def get_keys_from_df(data: list, registry: Record) -> list[str]:
 
 def one_helper(self):
     if len(self) == 0:
-        raise NoResultFound
+        raise DoesNotExist
     elif len(self) > 1:
         raise MultipleResultsFound(self)
     else:
         return self[0]
 
 
+def get(
+    registry_or_queryset: type[Record] | QuerySet,
+    idlike: int | str | None = None,
+    **expressions,
+) -> Record:
+    if isinstance(registry_or_queryset, QuerySet):
+        qs = registry_or_queryset
+        registry = qs.model
+    else:
+        qs = QuerySet(model=registry_or_queryset)
+        registry = registry_or_queryset
+    if isinstance(idlike, int):
+        return super(QuerySet, qs).get(id=idlike)
+    elif isinstance(idlike, str):
+        qs = qs.filter(uid__startswith=idlike)
+        if issubclass(registry, IsVersioned):
+            if len(idlike) <= registry._len_stem_uid:
+                return qs.latest_version().one()
+            else:
+                return qs.one()
+        else:
+            return qs.one()
+    else:
+        assert idlike is None  # noqa: S101
+        # below behaves exactly like `.one()`
+        return registry.objects.get(**expressions)
+
+
 class RecordsList(UserList):
     """Is ordered, can't be queried, but has `.df()`."""
 
@@ -221,12 +247,12 @@ class QuerySet(models.QuerySet, CanValidate):
             return None
         return self[0]
 
-    def one(self) -> Record:
-        """Exactly one result. Raises error if there are more or none.
+    def get(self, idlike: int | str | None = None, **expressions) -> Record:
+        """Query a single record. Raises error if there are more or none."""
+        return get(self, idlike, **expressions)
 
-        Examples:
-            >>> ln.ULabel.filter(name="benchmark").one()
-        """
+    def one(self) -> Record:
+        """Exactly one result. Raises error if there are more or none."""
         return one_helper(self)
 
     def one_or_none(self) -> Record | None:

lamindb/_record.py

@@ -12,7 +12,7 @@ from lamin_utils._lookup import Lookup
 from lamindb_setup._connect_instance import get_owner_name_from_identifier
 from lamindb_setup.core._docs import doc_args
 from lamindb_setup.core._hub_core import connect_instance
-from lnschema_core.models import IsVersioned, Record
+from lnschema_core.models import Collection, IsVersioned, Record
 
 from lamindb._utils import attach_func_to_class_method
 from lamindb.core._settings import settings
@@ -90,13 +90,22 @@ def __init__(record: Record, *args, **kwargs):
             match = suggest_records_with_similar_names(record, kwargs)
             if match:
                 if "version" in kwargs:
-                    version_comment = " and version"
-                    existing_record = record.__class__.filter(
-                        name=kwargs["name"], version=kwargs["version"]
-                    ).one_or_none()
+                    if kwargs["version"] is not None:
+                        version_comment = " and version"
+                        existing_record = record.__class__.filter(
+                            name=kwargs["name"], version=kwargs["version"]
+                        ).one_or_none()
+                    else:
+                        # for a versioned record, an exact name match is not a
+                        # criterion for retrieving a record in case `version`
+                        # isn't passed - we'd always pull out many records with exactly the
+                        # same name
+                        existing_record = None
                 else:
                     version_comment = ""
-                    existing_record = record.__class__.filter(name=kwargs["name"]).one()
+                    existing_record = record.__class__.filter(
+                        name=kwargs["name"]
+                    ).one_or_none()
                 if existing_record is not None:
                     logger.important(
                         f"returning existing {record.__class__.__name__} record with same"
@@ -123,27 +132,26 @@ def filter(cls, **expressions) -> QuerySet:
 
 @classmethod  # type:ignore
 @doc_args(Record.get.__doc__)
-def get(cls, idlike: int | str) -> Record:
+def get(
+    cls,
+    idlike: int | str | None = None,
+    **expressions,
+) -> Record:
     """{}"""  # noqa: D415
-    from lamindb._filter import filter
+    # 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
 
-    if isinstance(idlike, int):
-        return filter(cls, id=idlike).one()
-    else:
-        qs = filter(cls, uid__startswith=idlike)
-        if issubclass(cls, IsVersioned):
-            if len(idlike) <= cls._len_stem_uid:
-                return qs.latest_version().one()
-            else:
-                return qs.one()
-        else:
-            return qs.one()
+    return QuerySet(model=cls).get(idlike, **expressions)
 
 
 @classmethod  # type:ignore
 @doc_args(Record.df.__doc__)
 def df(
-    cls, include: str | list[str] | None = None, join: str = "inner"
+    cls,
+    include: str | list[str] | None = None,
+    join: str = "inner",
+    limit: int = 100,
 ) -> pd.DataFrame:
     """{}"""  # noqa: D415
     from lamindb._filter import filter
@@ -151,7 +159,7 @@ def df(
     query_set = filter(cls)
     if hasattr(cls, "updated_at"):
         query_set = query_set.order_by("-updated_at")
-    return query_set.df(include=include, join=join)
+    return query_set[:limit].df(include=include, join=join)
 
 
 # from_values doesn't apply for QuerySet or Manager
@@ -382,9 +390,11 @@ def add_db_connection(db: str, using: str):
 @doc_args(Record.using.__doc__)
 def using(
     cls,
-    instance: str,
+    instance: str | None,
 ) -> QuerySet:
     """{}"""  # noqa: D415
+    if instance is None:
+        return QuerySet(model=cls, using=None)
     from lamindb_setup._connect_instance import (
         load_instance_settings,
         update_db_using_local,
@@ -473,8 +483,8 @@ def transfer_to_default_db(
             return record_on_default
         if not mute:
             logger.hint(f"saving from instance {db} to default instance: {record}")
+        from lamindb.core._context import context
         from lamindb.core._data import WARNING_RUN_TRANSFORM
-        from lamindb.core._run_context import run_context
 
         if hasattr(record, "created_by_id"):
             # this line is needed to point created_by to default db
@@ -482,16 +492,16 @@ def transfer_to_default_db(
             record.created_by_id = ln_setup.settings.user.id
         if hasattr(record, "run_id"):
             record.run = None
-            if run_context.run is not None:
-                record.run_id = run_context.run.id
+            if context.run is not None:
+                record.run_id = context.run.id
             else:
                 if not settings.creation.artifact_silence_missing_run_warning:
                     logger.warning(WARNING_RUN_TRANSFORM)
                 record.run_id = None
         if hasattr(record, "transform_id") and record._meta.model_name != "run":
             record.transform = None
-            if run_context.transform is not None:
-                record.transform_id = run_context.transform.id
+            if context.run is not None:
+                record.transform_id = context.run.transform_id
             else:
                 record.transform_id = None
         # transfer other foreign key fields
@@ -530,24 +540,15 @@ def save(self, *args, **kwargs) -> Record:
         init_self_from_db(self, result)
     else:
         # save versioned record
-        if isinstance(self, IsVersioned) and self._is_new_version_of is not None:
-            if self._is_new_version_of.is_latest:
-                is_new_version_of = self._is_new_version_of
-            else:
-                # need one additional request
-                is_new_version_of = self.__class__.objects.get(
-                    is_latest=True, uid__startswith=self.stem_uid
-                )
-                logger.warning(
-                    f"didn't pass the latest version in `is_new_version_of`, retrieved it: {is_new_version_of}"
-                )
-            is_new_version_of.is_latest = False
+        if isinstance(self, IsVersioned) and self._revises is not None:
+            assert self._revises.is_latest  # noqa: S101
+            revises = self._revises
+            revises.is_latest = False
             with transaction.atomic():
-                is_new_version_of._is_new_version_of = (
-                    None  # ensure we don't start a recursion
-                )
-                is_new_version_of.save()
+                revises._revises = None  # ensure we don't start a recursion
+                revises.save()
                 super(Record, self).save(*args, **kwargs)
+            self._revises = None
         # save unversioned record
         else:
             super(Record, self).save(*args, **kwargs)

lamindb/_save.py

@@ -48,8 +48,7 @@ def save(records: Iterable[Record], ignore_conflicts: bool | None = False) -> No
 
     Examples:
 
-        Save a collection of records in one transaction, which is much faster
-        than writing a loop over ``projects.save()``:
+        Save a list of records:
 
         >>> labels = [ln.ULabel(f"Label {i}") for i in range(10)]
         >>> ln.save(projects)
@@ -61,7 +60,7 @@ def save(records: Iterable[Record], ignore_conflicts: bool | None = False) -> No
 
         Update a single existing record:
 
-        >>> transform = ln.filter(ln.Transform, uid="0Cb86EZj").one()
+        >>> transform = ln.Transform.get("0Cb86EZj")
         >>> transform.name = "New name"
         >>> transform.save()
 

lamindb/_transform.py

@@ -2,12 +2,13 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from lamin_utils import logger
 from lamindb_setup.core._docs import doc_args
 from lnschema_core.models import Run, Transform
 
 from ._parents import _view_parents
 from ._run import delete_run_artifacts
-from .core.versioning import process_is_new_version_of
+from .core.versioning import message_update_key_in_version_family, process_revises
 
 if TYPE_CHECKING:
     from lnschema_core.types import TransformType
@@ -19,26 +20,38 @@ def __init__(transform: Transform, *args, **kwargs):
         return None
     name: str | None = kwargs.pop("name") if "name" in kwargs else None
     key: str | None = kwargs.pop("key") if "key" in kwargs else None
-    is_new_version_of: Transform | None = (
-        kwargs.pop("is_new_version_of") if "is_new_version_of" in kwargs else None
-    )
+    revises: Transform | None = kwargs.pop("revises") if "revises" in kwargs else None
     version: str | None = kwargs.pop("version") if "version" in kwargs else None
     type: TransformType | None = kwargs.pop("type") if "type" in kwargs else "pipeline"
     reference: str | None = kwargs.pop("reference") if "reference" in kwargs else None
     reference_type: str | None = (
         kwargs.pop("reference_type") if "reference_type" in kwargs else None
     )
+    if "is_new_version_of" in kwargs:
+        logger.warning("`is_new_version_of` will be removed soon, please use `revises`")
+        revises = kwargs.pop("is_new_version_of")
     # below is internal use that we'll hopefully be able to eliminate
     uid: str | None = kwargs.pop("uid") if "uid" in kwargs else None
     if not len(kwargs) == 0:
         raise ValueError(
-            "Only name, key, version, type, is_new_version_of, reference, "
+            "Only name, key, version, type, revises, reference, "
             f"reference_type can be passed, but you passed: {kwargs}"
         )
-    new_uid, version, name = process_is_new_version_of(
-        is_new_version_of, version, name, Transform
-    )
-    # this is only because the user-facing constructor allows passing an id
+    # Transform allows passing a uid, all others don't
+    if uid is None and key is not None:
+        revises = Transform.filter(key=key).order_by("-created_at").first()
+    if revises is not None and key is not None and revises.key != key:
+        note = message_update_key_in_version_family(
+            suid=revises.stem_uid,
+            existing_key=revises.key,
+            new_key=key,
+            registry="Artifact",
+        )
+        raise ValueError(
+            f"`key` is {key}, but `revises.key` is '{revises.key}'\n\n Either do *not* pass `key`.\n\n{note}"
+        )
+    new_uid, version, name, revises = process_revises(revises, version, name, Transform)
+    # this is only because the user-facing constructor allows passing a uid
     # most others don't
     if uid is None:
         has_consciously_provided_uid = False
@@ -54,7 +67,7 @@ def __init__(transform: Transform, *args, **kwargs):
         reference=reference,
         reference_type=reference_type,
         _has_consciously_provided_uid=has_consciously_provided_uid,
-        is_new_version_of=is_new_version_of,
+        revises=revises,
     )