vdata 0.3.2__tar.gz → 0.3.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vdata
-Version: 0.3.2
+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.1
+Requires-Dist: ezarr>=1.1.3
 Requires-Dist: h5dataframe>=0.2.3 ; extra == 'update'
 Requires-Python: >=3.12
 Provides-Extra: update

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

@@ -1,6 +1,6 @@
 [project]
 name = "vdata"
-version = "0.3.2"
+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.1",
+    "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.2 → 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.2 → 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.2 → 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.2 → 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.2 → 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.2 → 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.2 → 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.2 → 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()