vdata 0.3.3__tar.gz → 0.3.4__tar.gz

{vdata-0.3.3 → vdata-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vdata
-Version: 0.3.3
+Version: 0.3.4
 Summary: Annotated multivariate observation of timestamped data
 Author: Matteo Bouvier
 Author-email: Matteo Bouvier <matteo.bouvier@hotmail.fr>
@@ -11,7 +11,7 @@ Requires-Dist: anndata>=0.10.4
 Requires-Dist: scipy>=1.12.0
 Requires-Dist: numpy-indexed>=0.3.7
 Requires-Dist: ch5mpy>=0.5.1
-Requires-Dist: ezarr>=1.1.2
+Requires-Dist: ezarr>=1.1.3
 Requires-Dist: h5dataframe>=0.2.3 ; extra == 'update'
 Requires-Python: >=3.12
 Provides-Extra: update

{vdata-0.3.3 → vdata-0.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "vdata"
-version = "0.3.3"
+version = "0.3.4"
 description = "Annotated multivariate observation of timestamped data"
 authors = [{ name = "Matteo Bouvier", email="matteo.bouvier@hotmail.fr"}]
 license = "CECILL-B"
@@ -14,7 +14,7 @@ dependencies = [
     "scipy>=1.12.0",
     "numpy-indexed>=0.3.7",
     "ch5mpy>=0.5.1",
-    "ezarr>=1.1.2",
+    "ezarr>=1.1.3",
 ]
 
 [dependency-groups]
@@ -30,7 +30,9 @@ docs= [
 ]
 
 [project.scripts]
-vdata-update = "vdata.cli:main"
+vdata-update = "vdata.cli:udpate"
+vdata-copy = "vdata.cli:copy"
+vdata-info = "vdata.cli:info"
 
 [project.optional-dependencies]
 update = [

{vdata-0.3.3 → vdata-0.3.4}/vdata/IO/errors.py

@@ -9,7 +9,7 @@ class VBaseError(BaseException):
     """
 
     def __init__(self, msg: str = ""):
-        super().__init__()
+        super().__init__(msg)
         self.msg: str = msg
 
     @override
@@ -44,3 +44,10 @@ class VReadOnlyError(VBaseError):
     def __init__(self, msg: str = ""):
         super().__init__(msg="Read-only file !")
 
+
+class InvalidVDataFileError(VBaseError):
+    """
+    File or directory is not valid as a VData storage
+    """
+
+    msg: str = "File or directory is not a valid VData"

{vdata-0.3.3 → vdata-0.3.4}/vdata/__init__.py

@@ -1,8 +1,13 @@
 """Annotated, temporal and multivariate observation data."""
 
 from importlib.metadata import metadata
+from pathlib import Path
+
+import ch5mpy as ch
+import ezarr
 
 from vdata.data import VData, VDataView, concatenate, convert_anndata_to_vdata
+from vdata.data.name import WRITE_PROTOCOL_VERSION
 from vdata.IO import (
     IncoherenceError,
     ShapeError,
@@ -11,6 +16,7 @@ from vdata.IO import (
 )
 from vdata.tdf import RepeatingIndex, TemporalDataFrame, TemporalDataFrameView
 from vdata.timepoint import TimePoint
+from vdata.utils import copy_vdata
 
 read = VData.read
 read_from_csv = VData.read_from_csv
@@ -20,17 +26,27 @@ read_from_pickle = VData.read_from_pickle
 __version__ = metadata("vdata").get("version")
 
 
+def get_version(path: str | Path) -> int:
+    try:
+        return ch.H5Dict.read(path).attributes.get("__vdata_write_version__", 0)
+
+    except IsADirectoryError:
+        return ezarr.EZDict.open(path).attrs["__vdata_write_version__"]  # pyright: ignore[reportReturnType]
+
+
 __all__ = [
-    "VData",
+    "concatenate",
+    "convert_anndata_to_vdata",
+    "copy_vdata",
+    "IncoherenceError",
+    "RepeatingIndex",
+    "ShapeError",
     "TemporalDataFrame",
-    "VDataView",
     "TemporalDataFrameView",
-    "convert_anndata_to_vdata",
-    "concatenate",
+    "TimePoint",
     "VBaseError",
-    "ShapeError",
-    "IncoherenceError",
+    "VData",
+    "VDataView",
     "VLockError",
-    "TimePoint",
-    "RepeatingIndex",
+    "WRITE_PROTOCOL_VERSION",
 ]

vdata-0.3.4/vdata/cli.py

@@ -0,0 +1,98 @@
+import argparse
+import subprocess
+import traceback
+from pathlib import Path
+
+import ch5mpy as ch
+from py import sys
+
+import vdata
+from vdata.update.update import update_vdata
+from vdata.utils import copy_vdata
+
+
+def print_err(msg: str) -> None:
+    print("\033[31m[ERROR] " + msg + "\033[0m", file=sys.stderr)
+
+
+def update() -> int:
+    parser = argparse.ArgumentParser(prog="vdata-update", description="Update a VData from an older version")
+
+    parser.add_argument("filename")
+    parser.add_argument("-o", "--out-file", default=None, type=str)
+    parser.add_argument("-v", "--verbose", default=False, action="store_true")
+
+    args = parser.parse_args()
+
+    data = ch.H5Dict.read(args.filename, mode=ch.H5Mode.READ_WRITE)
+
+    ez_filename = Path(data.filename)
+    ez_filename = ez_filename.with_stem("~" + ez_filename.stem)
+
+    try:
+        update_vdata(data, output_file=args.out_file, verbose=args.verbose)
+
+    except Exception as e:
+        print_err(" ".join(filter(lambda a: isinstance(a, str), e.args)))  # pyright: ignore[reportUnnecessaryIsInstance]
+
+        if args.verbose:
+            traceback.print_tb(e.__traceback__)
+
+        return 1
+
+    print("\033[32m[Done]\033[0m")
+    return 0
+
+
+def copy() -> int:
+    parser = argparse.ArgumentParser(prog="vdata-copy", description="Copy a VData to a new location")
+
+    parser.add_argument("source")
+    parser.add_argument("destination")
+    parser.add_argument("-e", "--exclude", default=[], action="append", choices=["obsm", "obsp", "varm", "varp", "uns"])
+    parser.add_argument("-v", "--verbose", default=False, action="store_true")
+
+    args = parser.parse_args()
+
+    try:
+        copy_vdata(args.source, args.destination, args.exclude, verbose=args.verbose)
+
+    except BaseException as e:
+        print_err(" ".join(filter(lambda a: isinstance(a, str), e.args)))  # pyright: ignore[reportUnnecessaryIsInstance]
+
+        if args.verbose:
+            traceback.print_tb(e.__traceback__)
+
+        return 1
+
+    print("\033[32m[Done]\033[0m")
+    return 0
+
+
+def info() -> int:
+    parser = argparse.ArgumentParser(prog="vdata-copy", description="Copy a VData to a new location")
+
+    parser.add_argument("filename")
+
+    args = parser.parse_args()
+
+    size = subprocess.check_output(["du", "-sh", args.filename]).split()[0].decode("utf-8")
+    data = vdata.read(args.filename)
+
+    print(f"""\
+size:      \t{size}
+
+name:      \t{data.name}
+timepoints:\t{", ".join(map(str, data.timepoints_values))}
+shape:     \t{data.n_obs} obs x {data.n_var} vars x {data.n_timepoints} timepoints
+
+layers:    \t{", ".join(data.layers.keys())}
+obs:       \t{", ".join(data.obs.columns)}
+obsm:      \t{", ".join(data.obsm.keys())}
+obsp:      \t{", ".join(data.obsp.keys())}
+var:       \t{", ".join(data.var.keys())}
+varm:      \t{", ".join(data.varm.keys())}
+varp:      \t{", ".join(data.varp.keys())}
+uns:       \t{", ".join(data.uns.keys())}
+""")
+    return 0

{vdata-0.3.3 → vdata-0.3.4}/vdata/data/_parse/data.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
-from collections.abc import Mapping, MutableMapping, Sequence
+from collections.abc import Collection, Mapping, MutableMapping
 from dataclasses import dataclass, field
+from pathlib import Path
 from typing import Any
 
 import ezarr as ez
@@ -9,6 +10,7 @@ import numpy as np
 import numpy.typing as npt
 import pandas as pd
 from anndata import AnnData
+from anndata._core.xarray import Dataset2D
 from ezarr.dataframe import EZDataFrame
 from scipy.sparse import spmatrix
 
@@ -130,10 +132,10 @@ class ParsingDataIn:
         | Mapping[str, pd.DataFrame | EZDataFrame | TemporalDataFrameBase]
         | None
     )
-    obs: pd.DataFrame | EZDataFrame | TemporalDataFrameBase
+    obs: pd.DataFrame | EZDataFrame | Dataset2D | TemporalDataFrameBase
     obsm: Mapping[str, pd.DataFrame | EZDataFrame | TemporalDataFrameBase]
     obsp: Mapping[str, pd.DataFrame | EZDataFrame | npt.NDArray[np_IFS]]
-    var: pd.DataFrame | EZDataFrame
+    var: pd.DataFrame | EZDataFrame | Dataset2D
     varm: Mapping[str, pd.DataFrame | EZDataFrame]
     varp: Mapping[str, pd.DataFrame | EZDataFrame | npt.NDArray[np_IFS]]
     timepoints: pd.DataFrame | EZDataFrame
@@ -166,8 +168,8 @@ class ParsingDataIn:
         varp: Mapping[str, pd.DataFrame | EZDataFrame | npt.NDArray[np_IFS]] | None,
         timepoints: pd.DataFrame | EZDataFrame | None,
         time_col_name: str | None,
-        timepoints_list: Sequence[str | tp.TimePoint] | tp.TimePointNArray | None,
-        uns: dict[str, Any] | ez.EZDict[Any] | None,
+        timepoints_list: Collection[str | tp.TimePoint] | tp.TimePointNArray | None,
+        uns: MutableMapping[str, Any] | ez.EZDict[Any] | None,
     ) -> ParsingDataIn:
         _timepoints_list = parse_timepoints_list(timepoints_list, time_col_name, obs)
 
@@ -320,5 +322,5 @@ class ParsingDataOut:
             varm=data.setdefault("varm", {}),
             varp=data.setdefault("varp", {}),
             timepoints=_timepoints,
-            uns=data["uns"],
+            uns=data.setdefault("uns", {}),
         )

{vdata-0.3.3 → vdata-0.3.4}/vdata/data/_parse/objects/objects.py

@@ -1,6 +1,5 @@
 from typing import Any
 
-import pandas as pd
 from ezarr.dataframe import EZDataFrame
 
 from vdata.data._parse.data import ParsingDataIn, ParsingDataOut
@@ -33,7 +32,7 @@ def parse_objects(data: ParsingDataIn) -> ParsingDataOut:
         _obs,
         parse_obsm(data),
         parse_obsp(data),
-        EZDataFrame(data.var) if isinstance(data.var, pd.DataFrame) else data.var,
+        EZDataFrame(data.var) if not isinstance(data.var, EZDataFrame) else data.var,
         parse_varm(data),
         parse_varp(data),
         _valid_timepoints(data, _obs),

{vdata-0.3.3 → vdata-0.3.4}/vdata/data/_parse/objects/obs.py

@@ -65,9 +65,6 @@ def parse_obsm(data: ParsingDataIn) -> dict[str, TemporalDataFrame | TemporalDat
 
     generalLogger.debug(f"    3. \u2713 'obsm' is a {type(data.obsm).__name__}.")
 
-    if data.obs is None and not len(data.layers):
-        raise ValueError("'obsm' parameter cannot be set unless either 'data' or 'obs' are set.")
-
     if not isinstance(data.obsm, dict):
         raise TypeError("'obsm' must be a dictionary of DataFrames.")
 
@@ -76,10 +73,7 @@ def parse_obsm(data: ParsingDataIn) -> dict[str, TemporalDataFrame | TemporalDat
     for key, value in data.obsm.items():
         if isinstance(value, (pd.DataFrame, EZDataFrame)):
             if data.timepoints_list is None:
-                if data.obs is not None:
-                    data.timepoints_list = TimePointNArray(data.obs.timepoints_column)
-                else:
-                    data.timepoints_list = first_in(data.layers).timepoints_column
+                data.timepoints_list = TimePointNArray(data.obs.timepoints_column)
 
             valid_obsm[str(key)] = TemporalDataFrame(value, timepoints=data.timepoints_list, name=str(key))
 

{vdata-0.3.3 → vdata-0.3.4}/vdata/data/_parse/time.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
-from collections.abc import Sequence
+from collections.abc import Collection
 from typing import TYPE_CHECKING, cast
 
 import numpy as np
 import pandas as pd
+from anndata._core.xarray import Dataset2D
 from ezarr.dataframe import EZDataFrame
 
 import vdata.timepoint as tp
@@ -19,9 +20,9 @@ if TYPE_CHECKING:
 
 
 def parse_timepoints_list(
-    timepoints_list: Sequence[str | tp.TimePoint] | tp.TimePointNArray | None,
+    timepoints_list: Collection[str | tp.TimePoint] | tp.TimePointNArray | None,
     time_col_name: str | None,
-    obs: pd.DataFrame | EZDataFrame | TemporalDataFrameBase | None,
+    obs: pd.DataFrame | EZDataFrame | Dataset2D | TemporalDataFrameBase | None,
 ) -> tp.TimePointNArray | NDArrayView[tp.TimePoint] | None:
     if timepoints_list is not None:
         return tp.as_timepointarray(timepoints_list)

{vdata-0.3.3 → vdata-0.3.4}/vdata/data/arrays/layers.py

@@ -83,7 +83,7 @@ class VLayersArrayContainer(VTDFArrayContainer):
                     f"Column names of layer '{TDF_index}' ({tdf.columns}) do not match var's index. ({self._vdata.var.index})"
                 )
 
-            if not np.all(self._vdata.timepoints.value.values == tdf.timepoints):
+            if not np.all(self._vdata.timepoints_values == tdf.timepoints):
                 raise IncoherenceError(
                     f"Time points of layer '{TDF_index}' ({tdf.timepoints}) do not match time_point's index. ({self._vdata.timepoints.value.values})"
                 )

{vdata-0.3.3 → vdata-0.3.4}/vdata/data/arrays/obs.py

@@ -78,9 +78,9 @@ class VObsmArrayContainer(VTDFArrayContainer):
                     f"Index of TemporalDataFrame '{TDF_index}' ({tdf.index}) does not match obs' index. ({self._vdata.obs.index})"
                 )
 
-            if np.any(self._vdata.timepoints.value.values != tdf.timepoints):
+            if np.any(self._vdata.timepoints_values != tdf.timepoints):
                 raise IncoherenceError(
-                    f"Time points of TemporalDataFrame '{TDF_index}' ({tdf.timepoints}) do not match time_point's index. ({self._vdata.timepoints.value.values})"
+                    f"Time points of TemporalDataFrame '{TDF_index}' ({tdf.timepoints}) do not match vdata's timepoints. ({self._vdata.timepoints_values})"
                 )
 
             tdf.lock_indices()

{vdata-0.3.3 → vdata-0.3.4}/vdata/data/vdata.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import pickle
+import shutil
 from collections.abc import Collection, Mapping, MutableMapping, Sequence
 from pathlib import Path
 from types import TracebackType
@@ -18,6 +19,7 @@ from zarr.core.common import AccessModeLiteral
 from zarr.errors import GroupNotFoundError
 from zarr.storage import LocalStore, ZipStore
 
+import vdata
 import vdata.timepoint as tp
 from vdata._meta import PrettyRepr
 from vdata._typing import IFS, PreSlicer, np_IFS
@@ -84,7 +86,7 @@ class VData(ez.SupportsEZReadWrite):
         timepoints: pd.DataFrame | EZDataFrame | None = None,
         uns: MutableMapping[str, Any] | None = None,
         time_col_name: str | None = None,
-        timepoints_list: Sequence[str | tp.TimePoint] | tp.TimePointNArray | None = None,
+        timepoints_list: Collection[str | tp.TimePoint] | tp.TimePointNArray | None = None,
         name: str = "",
     ):
         """
@@ -380,7 +382,6 @@ class VData(ez.SupportsEZReadWrite):
     def timepoints(self) -> EZDataFrame:
         """
         Get time points data.
-        :return: the time points DataFrame.
         """
         return self._timepoints
 
@@ -395,14 +396,17 @@ class VData(ez.SupportsEZReadWrite):
             raise VReadOnlyError
 
         if not isinstance(df, (pd.DataFrame, EZDataFrame)):  # pyright: ignore[reportUnnecessaryIsInstance]
-            raise TypeError("'time points' must be a pandas DataFrame.")  # pyright: ignore[reportUnreachable]
+            raise TypeError("'timepoints' must be a pandas DataFrame.")  # pyright: ignore[reportUnreachable]
 
         elif df.shape[0] != self.n_timepoints:
-            raise ShapeError(f"'time points' has {df.shape[0]} lines, it should have {self.n_timepoints}.")
+            raise ShapeError(f"'timepoints' has {df.shape[0]} rows, it should have {self.n_timepoints}.")
 
         elif "value" not in df.columns:
             raise ValueError("Time points DataFrame should contain a 'value' column.")
 
+        elif "unit" not in df.columns:
+            raise ValueError("Time points DataFrame should contain a 'unit' column.")
+
         df["value"] = tp.as_timepointarray(df["value"])
         self._timepoints = EZDataFrame(df)
 
@@ -410,28 +414,22 @@ class VData(ez.SupportsEZReadWrite):
     def timepoints_values(self) -> tp.TimePointNArray | NDArrayView[tp.TimePoint]:
         """
         Get the list of time points values (with the unit if possible).
-
-        :return: the list of time points values (with the unit if possible).
         """
-        return tp.as_timepointarray(self.timepoints.value)
+        return tp.as_timepointarray(self.timepoints_strings)
 
     @property
     def timepoints_strings(self) -> list[str]:
         """
         Get the list of time points as strings.
-
-        :return: the list of time points as strings.
         """
-        return [str(tp.value) for tp in self.timepoints_values]
+        return [str(value) + unit for value, unit in zip(self.timepoints.value, self.timepoints.unit)]  # pyright: ignore[reportUnknownVariableType]
 
     @property
     def timepoints_numerical(self) -> list[float]:
         """
         Get the list of bare values from the time points.
-
-        :return: the list of bare values from the time points.
         """
-        return [tp.value for tp in self.timepoints_values]
+        return self.timepoints.value.values[:].tolist()  # pyright: ignore[reportUnknownVariableType]
 
     @property
     def obs(self) -> TemporalDataFrameBase:
@@ -714,7 +712,7 @@ class VData(ez.SupportsEZReadWrite):
 
     def write(self, file: str | Path | None = None, verbose: bool = True) -> None:
         """
-        Save this VData object in HDF5 file format.
+        Save this VData object to a local file.
 
         Args:
             file: path to save the VData
@@ -742,16 +740,19 @@ class VData(ez.SupportsEZReadWrite):
         write_vdata_to_csv(self, directory, sep, na_rep, index, header)
 
     @classmethod
-    def read(cls, path: str | Path, mode: AccessModeLiteral = "a") -> VData:
+    def read(cls, path: str | Path, mode: AccessModeLiteral = "a", secure: bool = False, verbose: bool = True) -> VData:
         """
         Read a saved VData from a local file.
 
         Args:
             - path: path to a h5 file.
-            - mode: mode for opening the h5 file.
+            - mode: mode for opening the h5 file. (default: "a")
+            - secure: create a temporary file to work on instead of opening the file at `path` directly. (default: False)
+            - verbose: verbose output in case of update. (default: True)
         """
-        if not Path(path).suffix == ".vd":
-            raise IOError(f"Cannot read file with suffix '{Path(path).suffix}', should be '.vd'")
+        path = Path(path)
+        if not path.suffix == ".vd":
+            raise IOError(f"Cannot read file with suffix '{path.suffix}', should be '.vd'")
 
         try:
             data = ez.EZDict[Any].open(path, mode=mode)
@@ -768,7 +769,18 @@ class VData(ez.SupportsEZReadWrite):
                     f"Found old VData with {version=} but could not update, please install `vdata[update]`"
                 )
 
-            _, data = update_vdata(data, verbose=True)
+            _, data = update_vdata(data, verbose=verbose)
+
+        if secure:
+            temp_path = path.with_stem("~" + path.stem)
+
+            if not temp_path.exists():
+                shutil.copytree(path, temp_path)
+
+            elif vdata.get_version(temp_path) < vdata.get_version(path):
+                raise FileExistsError(f"{path} was updated, but {temp_path} exists")
+
+            data = ez.EZDict[Any].open(temp_path, mode=mode)
 
         return VData.__ez_read__(data)
 

{vdata-0.3.3 → vdata-0.3.4}/vdata/tdf/base.py

@@ -700,11 +700,11 @@ class TemporalDataFrameBase(ABC, ez.SupportsEZReadWrite):
         return len(self._timepoints_index.at(timepoint))
 
     @property
-    def columns_num(self) -> AnyNDArrayLike_IFS:
+    def columns_num(self) -> npt.NDArray[np_IFS]:
         """
         Get the list of column names for numerical data.
         """
-        return self._columns_numerical
+        return np.asarray(self._columns_numerical)
 
     @columns_num.setter
     def columns_num(self, values: AnyNDArrayLike_IFS) -> None:
@@ -724,11 +724,11 @@ class TemporalDataFrameBase(ABC, ez.SupportsEZReadWrite):
         return self._columns_numerical.shape[0]
 
     @property
-    def columns_str(self) -> AnyNDArrayLike_IFS:
+    def columns_str(self) -> npt.NDArray[np_IFS]:
         """
         Get the list of column names for string data.
         """
-        return self._columns_string
+        return np.asarray(self._columns_string)
 
     @columns_str.setter
     def columns_str(self, values: AnyNDArrayLike_IFS) -> None:

{vdata-0.3.3 → vdata-0.3.4}/vdata/timepoint/index.py

@@ -112,7 +112,9 @@ class TimePointIndex(ez.SupportsEZReadWrite):
         return TimePointIndex(timepoints, ranges)
 
     def as_array(self) -> TimePointNArray:
-        return TimePointNArray(np.repeat(self._timepoints, np.diff(self._ranges, prepend=0)))
+        return TimePointNArray(
+            np.repeat(self._timepoints, np.diff(self._ranges, prepend=0)), unit=self._timepoints.unit
+        )
 
     def len(self, timepoint: TimePoint) -> int:
         index_tp = np.where(self._timepoints[:] == timepoint)[0][0]

{vdata-0.3.3 → vdata-0.3.4}/vdata/update/tdf.py

@@ -16,6 +16,7 @@ import vdata
 from vdata.timepoint import TimePointIndex, TimePointNArray, TimePointZArray
 from vdata.timepoint.array import as_timepointarray
 from vdata.update.array import update_array
+from vdata.update.utils import save_class_info
 
 
 def _update_tdf_v0_to_v1(data: ch.H5Dict[Any], output_file: Path | None, **kwargs: Any) -> None:  # pyright: ignore[reportUnusedParameter]
@@ -63,7 +64,7 @@ def _update_tdf_v1_to_v2(data: ch.H5Dict[Any], output_file: Path | None, **kwarg
     (data @ "timepoints_index" @ "timepoints").attributes.set(
         __h5_type__="object",
         __h5_class__=np.void(pickle.dumps(TimePointNArray, protocol=pickle.HIGHEST_PROTOCOL)),
-        unit="h",
+        unit=data["timepoints_array"][0][-1],
     )
 
     del data["timepoints_array"]
@@ -80,7 +81,6 @@ def _update_tdf_v2_to_v3(data: ch.H5Dict[Any], output_file: Path | None, **kwarg
             "repeating_index": bool(data.attributes["repeating_index"]),
             "locked_indices": bool(data.attributes["locked_indices"]),
             "locked_columns": bool(data.attributes["locked_columns"]),
-            Attribute.EZType: EZType.Object,
         }
     )
 
@@ -90,23 +90,12 @@ def _update_tdf_v2_to_v3(data: ch.H5Dict[Any], output_file: Path | None, **kwarg
             "timepoints": data @ "timepoints_index" @ "timepoints",
             "ranges": data @ "timepoints_index" @ "ranges",
         }
-        ez_data["timepoints_index"].attrs.put({Attribute.EZType: EZType.Object})
-        with warnings.catch_warnings(action="ignore", category=UnstableSpecificationWarning):
-            (ez_data @ "timepoints_index").create_array(
-                Attribute.EZClass,
-                data=np.void(pickle.dumps(TimePointIndex, protocol=pickle.HIGHEST_PROTOCOL)),
-                overwrite=True,
-            )
+        save_class_info(TimePointIndex, ez_data["timepoints_index"])
 
         (ez_data @ "timepoints_index" @ "timepoints").attrs.put(  # pyright: ignore[reportOperatorIssue]
-            {"unit": str(data["timepoints_index"]["timepoints"].attributes["unit"]), Attribute.EZType: EZType.Object}
+            {"unit": str(data["timepoints_index"]["timepoints"].attributes["unit"])}
         )
-        with warnings.catch_warnings(action="ignore", category=UnstableSpecificationWarning):
-            (ez_data @ "timepoints_index" @ "timepoints").create_array(  # pyright: ignore[reportOperatorIssue]
-                Attribute.EZClass,
-                data=np.void(pickle.dumps(TimePointZArray, protocol=pickle.HIGHEST_PROTOCOL)),
-                overwrite=True,
-            )
+        save_class_info(TimePointZArray, ez_data @ "timepoints_index" @ "timepoints")  # pyright: ignore[reportOperatorIssue]
 
         ez_data["index"] = data @ "index"
         ez_data["columns_numerical"] = data @ "columns_numerical"
@@ -114,12 +103,7 @@ def _update_tdf_v2_to_v3(data: ch.H5Dict[Any], output_file: Path | None, **kwarg
         ez_data["array_numerical"] = data @ "numerical_array"
         ez_data["array_string"] = data @ "string_array"
 
-        with warnings.catch_warnings(action="ignore", category=UnstableSpecificationWarning):
-            ez_data.create_array(
-                Attribute.EZClass,
-                data=np.void(pickle.dumps(vdata.TemporalDataFrame, protocol=pickle.HIGHEST_PROTOCOL)),
-                overwrite=True,
-            )
+    save_class_info(vdata.TemporalDataFrame, ez_data)
 
 
 class tdf_updator(Protocol):

{vdata-0.3.3 → vdata-0.3.4}/vdata/update/update.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import shutil
+import warnings
 from pathlib import Path
 from typing import Any
 
@@ -12,6 +13,7 @@ from h5dataframe import H5DataFrame
 from tqdm.auto import tqdm
 from zarr.codecs.numcodecs import LZ4
 from zarr.core.array import CompressorsLike
+from zarr.errors import ZarrUserWarning
 
 import vdata
 from vdata.data.name import WRITE_PROTOCOL_VERSION
@@ -133,21 +135,25 @@ def _get_output_file(data_file: Path, output_file: str | Path | None, from_versi
     return ez_filename
 
 
+with warnings.catch_warnings(action="ignore", category=ZarrUserWarning):
+    _default_compressors = (LZ4(),)
+
+
 def update_vdata(
     data: Path | str | ch.H5Dict[Any] | ez.EZDict[Any],
     *,
     output_file: str | Path | None = None,
     verbose: bool = False,
-    compressors: CompressorsLike = LZ4(),  # pyright: ignore[reportCallInDefaultInitializer]
+    compressors: CompressorsLike = _default_compressors,
 ) -> tuple[int, ez.EZDict[Any]]:
     """
-    Update an h5 file containing a vdata saved in an older version.
+    Update a saved vdata from an older version.
 
     Args:
         data: path to the h5 file to update.
         output_file: path to the updated output vdata file.
         verbose: print a progress bar ? (default: False)
-        compressors:
+        compressors: zarr compressors to use when writing Arrays. (default: LZ4)
     """
     if isinstance(data, ez.EZDict):
         assert data.attrs.get("__vdata_write_version__") == WRITE_PROTOCOL_VERSION, (
@@ -175,7 +181,7 @@ def update_vdata(
 
     for v in range(data_version, WRITE_PROTOCOL_VERSION):
         progressBar: tqdm[Any] | NoBar = (
-            tqdm(total=nb_items_to_write, desc=f" Updating VData {filename} [version {v} => {v + 1}]", unit="object")
+            tqdm(total=nb_items_to_write, desc=f"Updating VData {filename} [version {v} => {v + 1}]", unit="object")
             if verbose
             else NoBar()
         )

vdata-0.3.4/vdata/update/utils.py

@@ -0,0 +1,22 @@
+import pickle
+import warnings
+from typing import Any
+
+import ezarr as ez
+import numpy as np
+from ezarr.names import Attribute, EZType
+from zarr.errors import UnstableSpecificationWarning
+
+
+def save_class_info(klass: type, ez_data: ez.EZDict[Any]) -> None:
+    ez_data.attrs.update(
+        {
+            Attribute.EZType: EZType.Object,
+        }
+    )
+    with warnings.catch_warnings(action="ignore", category=UnstableSpecificationWarning):
+        ez_data.create_array(
+            Attribute.EZClass,
+            data=np.void(pickle.dumps(klass, protocol=pickle.HIGHEST_PROTOCOL)),  # pyright: ignore[reportArgumentType]
+            overwrite=True,
+        )

{vdata-0.3.3 → vdata-0.3.4}/vdata/update/vdf.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import pickle
-import warnings
 from pathlib import Path
 from typing import Any, Protocol
 
@@ -11,11 +10,11 @@ import numpy as np
 import numpy.typing as npt
 import zarr
 from ezarr.dataframe import EZDataFrame
-from ezarr.names import Attribute, EZType
 from h5dataframe import H5DataFrame
-from zarr.errors import UnstableSpecificationWarning
 
+import vdata.timepoint as tp
 from vdata.update.array import update_array
+from vdata.update.utils import save_class_info
 
 
 def get_common_dtype(dt1: npt.DTypeLike, dt2: npt.DTypeLike) -> type[np.generic]:
@@ -76,24 +75,26 @@ def _update_vdf_v2_to_v3(data: ch.H5Dict[Any], output_file: Path | None, **kwarg
     assert output_file is not None
     ez_data = ez.EZDict[Any](zarr.open_group(output_file, path=data.file.name))
 
-    ez_data.attrs.put(
-        {
-            Attribute.EZType: EZType.Object,
-        }
-    )
+    is_timepoints = ez_data.group.basename == "timepoints"
 
     compressors = kwargs.get("compressors")
     with ez_data.parameters(compressors):
         ez_data["index"] = data @ "index"
-        ez_data["arrays"] = {name: arr for name, arr in (data @ "arrays").items()}
-        ez_data["arrays"].attrs.put({"columns_order": list((data @ "arrays").keys())})
-
-        with warnings.catch_warnings(action="ignore", category=UnstableSpecificationWarning):
-            ez_data.create_array(
-                Attribute.EZClass,
-                data=np.void(pickle.dumps(EZDataFrame, protocol=pickle.HIGHEST_PROTOCOL)),  # pyright: ignore[reportArgumentType]
-                overwrite=True,
-            )
+        ez_data["arrays"] = {
+            name: arr for name, arr in (data @ "arrays").items() if not is_timepoints or not name == "value"
+        }
+        ez_data["arrays"].attrs.put(
+            {"columns_order": [name for name in (data @ "arrays").keys() if not is_timepoints or not name == "value"]}
+        )
+
+        if is_timepoints:
+            tps = tp.as_timepointarray(data["arrays"]["value"])
+            ez_data["arrays"]["value"] = np.array(tps)
+            ez_data["arrays"]["unit"] = np.repeat(tps.unit, len(tps))
+
+            ez_data["arrays"].attrs["columns_order"] = ["value", "unit"] + ez_data["arrays"].attrs["columns_order"]
+
+        save_class_info(EZDataFrame, ez_data)
 
 
 class vdf_updator(Protocol):

{vdata-0.3.3 → vdata-0.3.4}/vdata/utils.py

@@ -1,24 +1,26 @@
 from __future__ import annotations
 
-from collections.abc import Collection, Mapping
+import shutil
+from collections.abc import Collection, Mapping, Sequence
 from itertools import islice
 from math import ceil, floor
-from typing import TYPE_CHECKING, Any, TypeGuard, TypeVar
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Literal, TypeGuard
 
 import numpy as np
 import numpy.typing as npt
 import zarr
+from tqdm.auto import tqdm
 
 from vdata.array_view import NDArrayView
+from vdata.IO.errors import InvalidVDataFileError
 
 if TYPE_CHECKING:
     from vdata._typing import PreSlicer
 
-_V = TypeVar("_V")
-
 
 # misc ------------------------------------------------------------------------
-def first_in(d: Mapping[Any, _V]) -> _V:
+def first_in[V](d: Mapping[Any, V]) -> V:
     return next(iter(d.values()))
 
 
@@ -105,7 +107,7 @@ def repr_index(
 
 
 # type coercion ---------------------------------------------------------------
-def deep_dict_convert(obj: Mapping[Any, Any]) -> dict[Any, Any]:
+def deep_dict_convert(obj: Any) -> dict[Any, Any]:
     """
     'Deep' convert a mapping of any kind (and children mappings) into regular dictionaries.
 
@@ -118,4 +120,63 @@ def deep_dict_convert(obj: Mapping[Any, Any]) -> dict[Any, Any]:
     if not isinstance(obj, Mapping):
         return obj
 
-    return {k: deep_dict_convert(v) for k, v in obj.items()}
+    return {k: deep_dict_convert(v) for k, v in obj.items()}  # pyright: ignore[reportUnknownVariableType]
+
+
+# copy ------------------------------------------------------------------------
+def is_valid_storage(path: Path) -> bool:
+    if not path.exists() or not path.is_dir():
+        return False
+
+    sub_dir = [p.name for p in path.iterdir()]
+
+    for key in ("layers", "obs", "var", "timepoints", "zarr.json"):
+        if key not in sub_dir:
+            return False
+
+    return True
+
+
+def copy_vdata(
+    source: str | Path,
+    destination: str | Path,
+    exclude: list[Literal["obsm", "obsp", "varm", "varp", "uns"]],
+    verbose: bool = False,
+) -> None:
+    source = Path(source)
+    destination = Path(destination).with_suffix(".vd")
+
+    if not source.exists():
+        raise FileNotFoundError("")
+
+    if not is_valid_storage(source):
+        raise InvalidVDataFileError(f"{source} is not a valid stored VData")
+
+    destination.parent.mkdir(parents=True, exist_ok=True)
+
+    # for file in filter(lambda p: p.name not in exclude, source.iterdir()):
+    def _ignore(src: str, _) -> Sequence[str]:
+        if src == str(source):
+            return exclude
+
+        return ()
+
+    if verbose:
+        total = (
+            sum(
+                len([file for file in dir.rglob("*") if file.is_file()])
+                for dir in source.iterdir()
+                if dir.name not in exclude
+            )
+            + 1
+        )
+        progress = tqdm(total=total, desc=f"Copying VData {source}", unit="files")
+
+        def _copy(src: str, dst: str) -> str:
+            progress.update()
+            return shutil.copy2(src, dst)
+
+        shutil.copytree(source, destination, ignore=_ignore, copy_function=_copy)
+
+    else:
+        shutil.copytree(source, destination, ignore=_ignore)

vdata-0.3.3/vdata/cli.py

@@ -1,41 +0,0 @@
-import argparse
-import traceback
-from pathlib import Path
-
-import ch5mpy as ch
-from py import sys
-
-from vdata.update.update import update_vdata
-
-
-def print_err(msg: str) -> None:
-    print("\033[31m[ERROR] " + msg + "\033[0m", file=sys.stderr)
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(prog="vdata-update", description="Update a VData from an older version")
-
-    parser.add_argument("filename")
-    parser.add_argument("-o", "--out-file", default=None, type=str)
-    parser.add_argument("-v", "--verbose", default=False, action="store_true")
-
-    args = parser.parse_args()
-
-    data = ch.H5Dict.read(args.filename, mode=ch.H5Mode.READ_WRITE)
-
-    ez_filename = Path(data.filename)
-    ez_filename = ez_filename.with_stem("~" + ez_filename.stem)
-
-    try:
-        update_vdata(data, output_file=args.out_file, verbose=args.verbose)
-
-    except Exception as e:
-        print_err(" ".join(filter(lambda a: isinstance(a, str), e.args)))  # pyright: ignore[reportUnnecessaryIsInstance]
-
-        if args.verbose:
-            traceback.print_tb(e.__traceback__)
-
-        return 1
-
-    print("\033[32m[Done]\033[0m")
-    return 0