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

lamindb/dev/{_mapped_dataset.py → _mapped_collection.py}

@@ -40,12 +40,12 @@ class _Connect:
             self.conn.close()
 
 
-class MappedDataset:
-    """Map-style dataset for use in data loaders.
+class MappedCollection:
+    """Map-style collection for use in data loaders.
 
     This currently only works for collections of `AnnData` objects.
 
-    For an example, see :meth:`~lamindb.Dataset.mapped`.
+    For an example, see :meth:`~lamindb.Collection.mapped`.
 
     .. note::
 
@@ -57,10 +57,14 @@ class MappedDataset:
         self,
         path_list: List[Union[str, PathLike]],
         label_keys: Optional[Union[str, List[str]]] = None,
-        join_vars: Optional[Literal["auto", "inner"]] = "auto",
+        join_vars: Optional[Literal["auto", "inner", "outer"]] = "auto",
         encode_labels: bool = True,
+        cache_categories: bool = True,
         parallel: bool = False,
+        dtype: Optional[str] = None,
     ):
+        assert join_vars in {None, "auto", "inner", "outer"}
+
         self.storages = []  # type: ignore
         self.conns = []  # type: ignore
         self.parallel = parallel
@@ -86,8 +90,15 @@ class MappedDataset:
 
         self.encode_labels = encode_labels
         self.label_keys = [label_keys] if isinstance(label_keys, str) else label_keys
-        if self.label_keys is not None and self.encode_labels:
-            self._make_encoders(self.label_keys)
+        if self.label_keys is not None:
+            if cache_categories:
+                self._cache_categories(self.label_keys)
+            else:
+                self._cache_cats: dict = {}
+            if self.encode_labels:
+                self._make_encoders(self.label_keys)
+
+        self._dtype = dtype
 
         self._closed = False
 
@@ -104,6 +115,18 @@ class MappedDataset:
             self.conns.append(conn)
             self.storages.append(storage)
 
+    def _cache_categories(self, label_keys: list):
+        self._cache_cats = {}
+        decode = np.frompyfunc(lambda x: x.decode("utf-8"), 1, 1)
+        for label in label_keys:
+            self._cache_cats[label] = []
+            for storage in self.storages:
+                with _Connect(storage) as store:
+                    cats = self.get_categories(store, label)
+                    if cats is not None:
+                        cats = decode(cats) if isinstance(cats[0], bytes) else cats[...]
+                    self._cache_cats[label].append(cats)
+
     def _make_encoders(self, label_keys: list):
         self.encoders = []
         for label in label_keys:
@@ -115,20 +138,31 @@ class MappedDataset:
         for storage in self.storages:
             with _Connect(storage) as store:
                 var_list.append(_safer_read_index(store["var"]))
+
+        self.var_joint = None
         if self.join_vars == "auto":
             vars_eq = all(var_list[0].equals(vrs) for vrs in var_list[1:])
             if vars_eq:
                 self.join_vars = None
                 return
             else:
-                self.join_vars = "inner"
+                self.var_joint = reduce(pd.Index.intersection, var_list)
+                if len(self.var_joint) > 0:
+                    self.join_vars = "inner"
+                else:
+                    self.join_vars = "outer"
+
         if self.join_vars == "inner":
-            self.var_joint = reduce(pd.Index.intersection, var_list)
-            if len(self.var_joint) == 0:
-                raise ValueError(
-                    "The provided AnnData objects don't have shared varibales."
-                )
+            if self.var_joint is None:
+                self.var_joint = reduce(pd.Index.intersection, var_list)
+                if len(self.var_joint) == 0:
+                    raise ValueError(
+                        "The provided AnnData objects don't have shared varibales."
+                    )
             self.var_indices = [vrs.get_indexer(self.var_joint) for vrs in var_list]
+        elif self.join_vars == "outer":
+            self.var_joint = reduce(pd.Index.union, var_list)
+            self.var_indices = [self.var_joint.get_indexer(vrs) for vrs in var_list]
 
     def __len__(self):
         return self.n_obs
@@ -137,15 +171,21 @@ class MappedDataset:
         obs_idx = self.indices[idx]
         storage_idx = self.storage_idx[idx]
         if self.var_indices is not None:
-            var_idxs = self.var_indices[storage_idx]
+            var_idxs_join = self.var_indices[storage_idx]
         else:
-            var_idxs = None
+            var_idxs_join = None
 
         with _Connect(self.storages[storage_idx]) as store:
-            out = [self.get_data_idx(store, obs_idx, var_idxs)]
+            out = [self.get_data_idx(store, obs_idx, var_idxs_join)]
             if self.label_keys is not None:
                 for i, label in enumerate(self.label_keys):
-                    label_idx = self.get_label_idx(store, obs_idx, label)
+                    if label in self._cache_cats:
+                        cats = self._cache_cats[label][storage_idx]
+                        if cats is None:
+                            cats = []
+                    else:
+                        cats = None
+                    label_idx = self.get_label_idx(store, obs_idx, label, cats)
                     if self.encode_labels:
                         label_idx = self.encoders[i][label_idx]
                     out.append(label_idx)
@@ -155,26 +195,50 @@ class MappedDataset:
         self,
         storage: StorageType,  # type: ignore
         idx: int,
-        var_idxs: Optional[list] = None,
+        var_idxs_join: Optional[list] = None,
         layer_key: Optional[str] = None,
     ):
         """Get the index for the data."""
         layer = storage["X"] if layer_key is None else storage["layers"][layer_key]  # type: ignore
         if isinstance(layer, ArrayTypes):  # type: ignore
-            # todo: better way to select variables
-            return layer[idx] if var_idxs is None else layer[idx][var_idxs]
+            layer_idx = layer[idx]
+            if self.join_vars is None:
+                result = layer_idx
+                if self._dtype is not None:
+                    result = result.astype(self._dtype, copy=False)
+            elif self.join_vars == "outer":
+                dtype = layer_idx.dtype if self._dtype is None else self._dtype
+                result = np.zeros(len(self.var_joint), dtype=dtype)
+                result[var_idxs_join] = layer_idx
+            else:  # inner join
+                result = layer_idx[var_idxs_join]
+                if self._dtype is not None:
+                    result = result.astype(self._dtype, copy=False)
+            return result
         else:  # assume csr_matrix here
             data = layer["data"]
             indices = layer["indices"]
             indptr = layer["indptr"]
             s = slice(*(indptr[idx : idx + 2]))
-            # this requires more memory than csr_matrix when var_idxs is not None
-            # but it is faster
-            layer_idx = np.zeros(layer.attrs["shape"][1])
-            layer_idx[indices[s]] = data[s]
-            return layer_idx if var_idxs is None else layer_idx[var_idxs]
+            data_s = data[s]
+            dtype = data_s.dtype if self._dtype is None else self._dtype
+            if self.join_vars == "outer":
+                layer_idx = np.zeros(len(self.var_joint), dtype=dtype)
+                layer_idx[var_idxs_join[indices[s]]] = data_s
+            else:
+                layer_idx = np.zeros(layer.attrs["shape"][1], dtype=dtype)
+                layer_idx[indices[s]] = data_s
+                if self.join_vars == "inner":
+                    layer_idx = layer_idx[var_idxs_join]
+            return layer_idx
 
-    def get_label_idx(self, storage: StorageType, idx: int, label_key: str):  # type: ignore
+    def get_label_idx(
+        self,
+        storage: StorageType,
+        idx: int,
+        label_key: str,
+        categories: Optional[list] = None,
+    ):
         """Get the index for the label by key."""
         obs = storage["obs"]  # type: ignore
         # how backwards compatible do we want to be here actually?
@@ -186,9 +250,11 @@ class MappedDataset:
                 label = labels[idx]
             else:
                 label = labels["codes"][idx]
-
-        cats = self.get_categories(storage, label_key)
-        if cats is not None:
+        if categories is not None:
+            cats = categories
+        else:
+            cats = self.get_categories(storage, label_key)
+        if cats is not None and len(cats) > 0:
             label = cats[label]
         if isinstance(label, bytes):
             label = label.decode("utf-8")
@@ -215,11 +281,14 @@ class MappedDataset:
         """Get merged labels."""
         labels_merge = []
         decode = np.frompyfunc(lambda x: x.decode("utf-8"), 1, 1)
-        for storage in self.storages:
+        for i, storage in enumerate(self.storages):
             with _Connect(storage) as store:
                 codes = self.get_codes(store, label_key)
                 labels = decode(codes) if isinstance(codes[0], bytes) else codes
-                cats = self.get_categories(store, label_key)
+                if label_key in self._cache_cats:
+                    cats = self._cache_cats[label_key][i]
+                else:
+                    cats = self.get_categories(store, label_key)
                 if cats is not None:
                     cats = decode(cats) if isinstance(cats[0], bytes) else cats
                     labels = cats[labels]
@@ -230,9 +299,12 @@ class MappedDataset:
         """Get merged categories."""
         cats_merge = set()
         decode = np.frompyfunc(lambda x: x.decode("utf-8"), 1, 1)
-        for storage in self.storages:
+        for i, storage in enumerate(self.storages):
             with _Connect(storage) as store:
-                cats = self.get_categories(store, label_key)
+                if label_key in self._cache_cats:
+                    cats = self._cache_cats[label_key][i]
+                else:
+                    cats = self.get_categories(store, label_key)
                 if cats is not None:
                     cats = decode(cats) if isinstance(cats[0], bytes) else cats
                     cats_merge.update(cats)

lamindb/dev/_run_context.py

@@ -13,7 +13,7 @@ from lnschema_core import Run, Transform, ids
 from lnschema_core.types import TransformType
 from lnschema_core.users import current_user_id
 
-from lamindb.dev.versioning import get_ids_from_old_version
+from lamindb.dev.versioning import get_uid_from_old_version
 
 from .hashing import to_b64_str
 
@@ -33,7 +33,9 @@ msg_manual_init = (
 )
 
 
-class UpdateNbWithNonInteractiveEditorError(Exception):
+# we don't want a real error here, as this is so frequent
+# in VSCode
+class UpdateNbWithNonInteractiveEditor(SystemExit):
     pass
 
 
@@ -82,21 +84,21 @@ def update_notebook_metadata(
     from nbproject._header import _filepath
 
     notebook = nb_dev.read_notebook(_filepath)
-    uid_prefix = notebook.metadata["nbproject"]["id"]
+    stem_uid = notebook.metadata["nbproject"]["id"]
     version = notebook.metadata["nbproject"]["version"]
 
-    updated, new_uid_prefix, new_version = update_transform_source_metadata(
+    updated, new_stem_uid, new_version = update_transform_source_metadata(
         notebook, _filepath, bump_version=bump_version, run_from_cli=False
     )
 
     if version != new_version:
         notebook.metadata["nbproject"]["version"] = new_version
-        new_uid, _, _ = get_ids_from_old_version(
-            is_new_version_of=transform, version=new_version, n_full_id=14
+        new_uid, _ = get_uid_from_old_version(
+            is_new_version_of=transform, version=new_version, n_full_id=16
         )
     else:
-        notebook.metadata["nbproject"]["id"] = uid_prefix
-        new_uid = new_uid_prefix + ids.base62(n_char=2)
+        notebook.metadata["nbproject"]["id"] = stem_uid
+        new_uid = new_stem_uid + ids.base62(n_char=4)
 
     # here we check that responses to both inputs (for new id and version) were not 'n'
     if updated:
@@ -123,20 +125,22 @@ def get_notebook_name_colab() -> str:
     return name.rstrip(".ipynb")
 
 
-def get_transform_kwargs_from_uid_prefix(
+def get_transform_kwargs_from_stem_uid(
     nbproject_id: str,
     nbproject_version: str,
-) -> Tuple[Optional[Transform], str, str, Optional[Transform]]:
-    id_ext = to_b64_str(hashlib.md5(nbproject_version.encode()).digest())[:2]
-    uid = nbproject_id + id_ext
-    version = nbproject_version
+) -> Tuple[Optional[Transform], str, str]:
+    from lamin_utils._base62 import encodebytes
+
+    # merely zero-padding the nbproject version such that the base62 encoding is at
+    # least 4 characters long does yield sufficiently diverse hashes within 4 characters
+    # it'd be nice because the uid_ext would be ordered, but it leads to collisions
+    uid_ext = encodebytes(hashlib.md5(nbproject_version.encode()).digest())[:4]
+    new_uid = nbproject_id + uid_ext
+    assert len(new_uid) == 16
     transform = Transform.filter(
-        uid__startswith=nbproject_id, version=version
+        uid__startswith=nbproject_id, version=nbproject_version
     ).one_or_none()
-    old_version_of = None
-    if transform is None:
-        old_version_of = Transform.filter(uid__startswith=nbproject_id).first()
-    return transform, uid, version, old_version_of
+    return transform, new_uid, nbproject_version
 
 
 class run_context:
@@ -228,7 +232,7 @@ class run_context:
                             "it looks like you are running ln.track() from a "
                             "notebook!\nplease install nbproject: pip install nbproject"
                         )
-                    elif isinstance(e, UpdateNbWithNonInteractiveEditorError):
+                    elif isinstance(e, UpdateNbWithNonInteractiveEditor):
                         raise e
                     elif isinstance(e, (NotebookNotSavedError, NoTitleError)):
                         raise e
@@ -245,7 +249,7 @@ class run_context:
                     is_tracked = False
                 else:
                     name = Path(module.__file__).stem  # type: ignore
-                    if not hasattr(module, "__lamindb_uid_prefix__"):
+                    if not hasattr(module, "__transform_stem_uid__"):
                         raise RuntimeError(
                             "no automated tracking because no uid attached to script!\n"
                             f"please run: lamin track {module.__file__}\n"
@@ -254,9 +258,8 @@ class run_context:
                         transform,
                         uid,
                         version,
-                        old_version_of,
-                    ) = get_transform_kwargs_from_uid_prefix(
-                        module.__lamindb_uid_prefix__,
+                    ) = get_transform_kwargs_from_stem_uid(
+                        module.__transform_stem_uid__,
                         module.__version__,  # type: ignore
                     )
                     short_name = Path(module.__file__).name  # type: ignore
@@ -265,7 +268,6 @@ class run_context:
                         version=version,
                         name=name,
                         reference=reference,
-                        is_new_version_of=old_version_of,
                         transform_type=TransformType.pipeline,
                         short_name=short_name,
                         is_interactive=False,
@@ -321,6 +323,10 @@ class run_context:
             logger.important(f"saved: {run}")
         cls.run = run
 
+        from ._track_environment import track_environment
+
+        track_environment(run)
+
         # at this point, we have a transform can display its parents if there are any
         parents = cls.transform.parents.all() if cls.transform is not None else []
         if len(parents) > 0:
@@ -431,7 +437,7 @@ class run_context:
                 cls._notebook_meta = metadata  # type: ignore
             else:
                 msg = msg_manual_init.format(notebook_path=notebook_path_str)
-                raise UpdateNbWithNonInteractiveEditorError(msg)
+                raise UpdateNbWithNonInteractiveEditor(msg)
 
         if _env in ("lab", "notebook"):
             # save the notebook in case that title was updated
@@ -446,7 +452,7 @@ class run_context:
             is_interactive = _seconds_modified(_filepath) < 1.5  # should be ~1 sec
             if not is_interactive and needs_init:
                 msg = msg_manual_init.format(notebook_path=_filepath)
-                raise UpdateNbWithNonInteractiveEditorError(msg)
+                raise UpdateNbWithNonInteractiveEditor(msg)
 
             nbproject_id = metadata["id"]
             nbproject_version = metadata["version"]
@@ -468,7 +474,6 @@ class run_context:
             transform = Transform.filter(uid=uid).one_or_none()
             name = filestem
             short_name = None
-            old_version_of = None
         # nbproject parsing successful
         elif nbproject_id is not None:
             name = nbproject_title
@@ -476,21 +481,18 @@ class run_context:
                 transform,
                 uid,
                 version,
-                old_version_of,
-            ) = get_transform_kwargs_from_uid_prefix(nbproject_id, nbproject_version)
+            ) = get_transform_kwargs_from_stem_uid(nbproject_id, nbproject_version)
             short_name = filestem
         cls._create_or_load_transform(
             uid=uid,
             version=version,
             name=name,
             reference=reference,
-            is_new_version_of=old_version_of,
             transform_type=TransformType.notebook,
             short_name=short_name,
             is_interactive=is_interactive,
             filepath=notebook_path,
             transform=transform,
-            metadata=metadata,
         )
 
     @classmethod
@@ -509,7 +511,7 @@ class run_context:
                 cls._notebook_meta = metadata  # type: ignore
             else:
                 msg = msg_manual_init.format(notebook_path=filepath)
-                raise UpdateNbWithNonInteractiveEditorError(msg)
+                raise UpdateNbWithNonInteractiveEditor(msg)
         else:
             from lamin_cli._transform import update_transform_source_metadata
 
@@ -533,13 +535,11 @@ class run_context:
         version: Optional[str],
         name: str,
         reference: Optional[str],
-        is_new_version_of: Optional[Transform],
         short_name: Optional[str],
         transform_type: TransformType,
         is_interactive: bool,
         filepath: str,
         transform: Optional[Transform] = None,
-        metadata: Optional[Dict] = None,
     ) -> bool:
         # make a new transform record
         if transform is None:
@@ -549,7 +549,6 @@ class run_context:
                 name=name,
                 short_name=short_name,
                 reference=reference,
-                is_new_version_of=is_new_version_of,
                 type=transform_type,
             )
             transform.save()

lamindb/dev/_track_environment.py

@@ -0,0 +1,18 @@
+import subprocess
+
+import lamindb_setup as ln_setup
+from lamin_utils import logger
+from lnschema_core.models import Run
+
+
+def track_environment(run: Run) -> None:
+    filepath = ln_setup.settings.storage.cache_dir / f"run_env_pip_{run.uid}.txt"
+    # create a requirements.txt
+    # we don't create a conda environment.yml mostly for its slowness
+    try:
+        result = subprocess.run(f"pip freeze > {str(filepath)}", shell=True)
+    except OSError as e:
+        result = None
+        logger.warning(f"could not run pip freeze with error {e}")
+    if result is not None and result.returncode == 0:
+        logger.info(f"tracked pip freeze > {str(filepath)}")

lamindb/dev/datasets/__init__.py

@@ -1,4 +1,4 @@
-"""Test datasets.
+"""Test collections.
 
 .. autosummary::
    :toctree: .

lamindb/dev/datasets/_core.py

@@ -144,7 +144,7 @@ def dir_iris_images() -> UPath:  # pragma: no cover
 def anndata_mouse_sc_lymph_node(
     populate_registries: bool = False,
 ) -> ad.AnnData:  # pragma: no cover
-    """Mouse lymph node scRNA-seq dataset from EBI.
+    """Mouse lymph node scRNA-seq collection from EBI.
 
     Subsampled to 10k genes.
 
@@ -226,11 +226,11 @@ def anndata_mouse_sc_lymph_node(
 
 
 def anndata_pbmc68k_reduced() -> ad.AnnData:
-    """Modified from scanpy.datasets.pbmc68k_reduced().
+    """Modified from scanpy.collections.pbmc68k_reduced().
 
     This code was run::
 
-        pbmc68k = sc.datasets.pbmc68k_reduced()
+        pbmc68k = sc.collections.pbmc68k_reduced()
         pbmc68k.obs.rename(columns={"bulk_labels": "cell_type"}, inplace=True)
         pbmc68k.obs["cell_type"] = pbmc68k.obs["cell_type"].cat.rename_categories(
             {"Dendritic": "Dendritic cells", "CD14+ Monocyte": "CD14+ Monocytes"}
@@ -254,7 +254,7 @@ def anndata_pbmc68k_reduced() -> ad.AnnData:
 
 
 def anndata_file_pbmc68k_test() -> Path:
-    """Modified from scanpy.datasets.pbmc68k_reduced().
+    """Modified from scanpy.collections.pbmc68k_reduced().
 
     Additional slots were added for testing purposes. Returns the filepath.
 
@@ -291,7 +291,7 @@ def anndata_human_immune_cells(
     """Cross-tissue immune cell analysis reveals tissue-specific features in humans.
 
     From: https://cellxgene.cziscience.com/collections/62ef75e4-cbea-454e-a0ce-998ec40223d3  # noqa
-    Dataset: Global
+    Collection: Global
 
     To reproduce the subsample::
 
@@ -404,18 +404,18 @@ def mudata_papalexi21_subset():  # pragma: no cover
 
 
 def df_iris() -> pd.DataFrame:
-    """The iris dataset as in sklearn.
+    """The iris collection as in sklearn.
 
     Original code::
 
-        sklearn.datasets.load_iris(as_frame=True).frame
+        sklearn.collections.load_iris(as_frame=True).frame
     """
     filepath, _ = urlretrieve("https://lamindb-test.s3.amazonaws.com/iris.parquet")
     return pd.read_parquet(filepath)
 
 
 def df_iris_in_meter() -> pd.DataFrame:
-    """The iris dataset with lengths in meter."""
+    """The iris collection with lengths in meter."""
     df = df_iris()
     # rename columns
     df.rename(
@@ -436,13 +436,13 @@ def df_iris_in_meter() -> pd.DataFrame:
 
 
 def df_iris_in_meter_study1() -> pd.DataFrame:
-    """The iris dataset with lengths in meter."""
+    """The iris collection with lengths in meter."""
     df_iris = df_iris_in_meter()
     return df_iris.iloc[: len(df_iris) // 2]
 
 
 def df_iris_in_meter_study2() -> pd.DataFrame:
-    """The iris dataset with lengths in meter."""
+    """The iris collection with lengths in meter."""
     df_iris = df_iris_in_meter()
     return df_iris.iloc[len(df_iris) // 2 :]
 
@@ -500,7 +500,7 @@ def dir_scrnaseq_cellranger(
 
 
 def schmidt22_crispra_gws_IFNG(basedir=".") -> Path:  # pragma: no cover
-    """CRISPRi screen dataset of Schmidt22.
+    """CRISPRi screen collection of Schmidt22.
 
     Originally from: https://zenodo.org/record/5784651
     """
@@ -512,7 +512,7 @@ def schmidt22_crispra_gws_IFNG(basedir=".") -> Path:  # pragma: no cover
 
 
 def schmidt22_perturbseq(basedir=".") -> Path:  # pragma: no cover
-    """Perturb-seq dataset of Schmidt22.
+    """Perturb-seq collection of Schmidt22.
 
     Subsampled and converted to h5ad from R file: https://zenodo.org/record/5784651
 

lamindb/dev/storage/_backed_access.py

@@ -48,7 +48,10 @@ else:
     from anndata._core.sparse_dataset import (
         BaseCompressedSparseDataset as SparseDataset,
     )
-    from anndata._core.sparse_dataset import CSRDataset, sparse_dataset  # type: ignore
+    from anndata._core.sparse_dataset import (  # type: ignore
+        CSRDataset,
+        sparse_dataset,
+    )
 
     def _check_group_format(*args):
         pass

lamindb/dev/storage/_zarr.py

@@ -72,7 +72,10 @@ def write_adata_zarr(
 
         if chunks is not None and not isinstance(adata.X, sparse.spmatrix):
             _write_elem_cb(
-                f, "X", adata.X, dataset_kwargs=dict(chunks=chunks, **dataset_kwargs)
+                f,
+                "X",
+                adata.X,
+                dataset_kwargs=dict(chunks=chunks, **dataset_kwargs),
             )
         else:
             _write_elem_cb(f, "X", adata.X, dataset_kwargs=dataset_kwargs)

lamindb/dev/versioning.py

@@ -1,7 +1,7 @@
 from typing import Optional, Tuple, Union
 
 from lnschema_core import ids
-from lnschema_core.models import Artifact, Transform
+from lnschema_core.models import IsVersioned
 
 
 def set_version(version: Optional[str] = None, previous_version: Optional[str] = None):
@@ -32,33 +32,29 @@ def init_uid(
     *,
     version: Optional[str] = None,
     n_full_id: int = 20,
+    is_new_version_of: Optional[IsVersioned] = None,
 ) -> str:
-    if n_full_id == 20:
-        gen_full_id = ids.base62_20
-    elif n_full_id == 14:
-        gen_full_id = ids.base62_14
+    if is_new_version_of is not None:
+        stem_uid = is_new_version_of.stem_uid
+    else:
+        if n_full_id == 20:
+            stem_uid = ids.base62_16()
+        elif n_full_id == 16:
+            stem_uid = ids.base62_12()
     if version is not None:
         if not isinstance(version, str):
             raise ValueError(
                 "`version` parameter must be `None` or `str`, e.g., '0.1', '1', '2',"
                 " etc."
             )
-    return gen_full_id()
-
+    return stem_uid + ids.base62_4()
 
-def get_initial_version_id(is_new_version_of: Union[Artifact, Transform]):
-    if is_new_version_of.initial_version_id is None:
-        initial_version_id = is_new_version_of.id
-    else:
-        initial_version_id = is_new_version_of.initial_version_id
-    return initial_version_id
 
-
-def get_ids_from_old_version(
-    is_new_version_of: Union[Artifact, Transform],
+def get_uid_from_old_version(
+    is_new_version_of: IsVersioned,
     version: Optional[str],
     n_full_id: int = 20,
-) -> Tuple[str, int, str]:
+) -> Tuple[str, str]:
     """{}."""
     msg = ""
     if is_new_version_of.version is None:
@@ -67,18 +63,15 @@ def get_ids_from_old_version(
     else:
         previous_version = is_new_version_of.version
     version = set_version(version, previous_version)
-    initial_version_id = get_initial_version_id(is_new_version_of)
     new_uid = init_uid(
         version=version,
         n_full_id=n_full_id,
+        is_new_version_of=is_new_version_of,
     )
     # the following covers the edge case where the old file was unversioned
     if is_new_version_of.version is None:
         is_new_version_of.version = previous_version
         is_new_version_of.save()
         if msg != "":
-            msg += (
-                f"& new version to '{version}' (initial_version_id ="
-                f" '{initial_version_id}')"
-            )
-    return new_uid, initial_version_id, version  # type: ignore
+            msg += f"& new version to '{version}'"
+    return new_uid, version