vdata 0.2.3__tar.gz → 0.3.0__tar.gz

{vdata-0.2.3 → vdata-0.3.0}/PKG-INFO

@@ -1,23 +1,20 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: vdata
-Version: 0.2.3
+Version: 0.3.0
 Summary: Annotated multivariate observation of timestamped data
-License: LICENSE
 Author: Matteo Bouvier
-Author-email: m.bouvier@vidium-solutions.com
-Requires-Python: >=3.10,<4.0
-Classifier: License :: Other/Proprietary License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: anndata (>=0.10.4,<0.11.0)
-Requires-Dist: ch5mpy (>=0.4.6,<0.5.0)
-Requires-Dist: h5dataframe (>=0.2.1,<0.3.0)
-Requires-Dist: numpy-indexed (>=0.3.7,<0.4.0)
-Requires-Dist: scanpy (>=1.9.6,<2.0.0)
-Requires-Dist: scipy (>=1.12.0,<2.0.0)
-Requires-Dist: tqdm (>=4.66.1,<5.0.0)
+Author-email: Matteo Bouvier <matteo.bouvier@hotmail.fr>
+License-Expression: CECILL-B
+License-File: LICENSE
+Requires-Dist: tqdm>=4.66.1
+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
+Requires-Dist: h5dataframe>=0.2.3 ; extra == 'update'
+Requires-Python: >=3.12
+Provides-Extra: update
 Description-Content-Type: text/markdown
 
 # 🗂 VData
@@ -124,4 +121,3 @@ You can cite the **VData** pre-print as :
 > Matteo Bouvier, Arnaud Bonnaffoux
 > 
 > bioRxiv 2023.08.29.555297; doi: https://doi.org/10.1101/2023.08.29.555297 
-

vdata-0.3.0/pyproject.toml

@@ -0,0 +1,60 @@
+[project]
+name = "vdata"
+version = "0.3.0"
+description = "Annotated multivariate observation of timestamped data"
+authors = [{ name = "Matteo Bouvier", email="matteo.bouvier@hotmail.fr"}]
+license = "CECILL-B"
+license-files = ["LICENSE"]
+readme = "README.md"
+requires-python = ">=3.12"
+
+dependencies = [
+    "tqdm>=4.66.1",
+    "anndata>=0.10.4",
+    "scipy>=1.12.0",
+    "numpy-indexed>=0.3.7",
+    "ch5mpy>=0.5.1",
+    "ezarr",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=7.4.4",
+    "pytest-xdist>=3.8.0",
+]
+
+docs= [
+    "mkdocs-material>=9.5.10",
+# mkdocstrings = {extras = ["python"], version = "^0.24.0"}
+    "mkdocs>=1.5.3"
+]
+
+[project.scripts]
+vdata-update = "vdata.cli:main"
+
+[project.optional-dependencies]
+update = [
+    "h5dataframe>=0.2.3",
+]
+
+[build-system]
+requires = ["uv_build>=0.8.15,<0.9.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-root = ""
+
+[tool.uv.sources]
+ezarr = { path = "../ezarr" }
+
+[tool.ruff]
+line-length = 120
+extend-select = ["I"]
+
+[tool.pyright]
+reportAny = false
+reportExplicitAny = false
+reportUnknownMemberType = false
+reportUnknownArgumentType = false
+reportUnusedCallResult = false
+reportMissingTypeStubs = false

{vdata-0.2.3 → vdata-0.3.0}/vdata/IO/__init__.py

@@ -1,4 +1,4 @@
-from .errors import IncoherenceError, ShapeError, VBaseError, VClosedFileError, VLockError, VReadOnlyError
+from .errors import IncoherenceError, ShapeError, VBaseError, VLockError, VReadOnlyError
 from .logger import generalLogger
 
 __all__ = [
@@ -7,6 +7,5 @@ __all__ = [
     "ShapeError",
     "IncoherenceError",
     "VLockError",
-    "VClosedFileError",
     "VReadOnlyError",
 ]

{vdata-0.2.3 → vdata-0.3.0}/vdata/IO/errors.py

@@ -1,14 +1,18 @@
-from . import logger
+from typing import override
 
+from vdata.IO import logger
 
-# Errors
-class VBaseError(Exception):
+
+class VBaseError(BaseException):
     """
     Base class for custom error. Error messages are redirected to the logger instead of being printed directly.
     """
+
     def __init__(self, msg: str = ""):
-        self.msg = msg
+        super().__init__()
+        self.msg: str = msg
 
+    @override
     def __str__(self) -> str:
         logger.generalLogger.error(self.msg)
         return self.msg
@@ -18,29 +22,18 @@ class ShapeError(VBaseError):
     """
     Custom error for errors in variable shapes.
     """
-    pass
 
 
 class IncoherenceError(VBaseError):
     """
     Custom error for incoherent data formats.
     """
-    pass
 
 
 class VLockError(VBaseError):
     """
     Custom error for tdf lock errors.
     """
-    pass
-
-
-class VClosedFileError(VBaseError):
-    """
-    Custom error for tdf lock errors.
-    """
-    def __init__(self, msg: str = ""):
-        self.msg = "Closed backing file !"
 
 
 class VReadOnlyError(VBaseError):
@@ -49,5 +42,5 @@ class VReadOnlyError(VBaseError):
     """
 
     def __init__(self, msg: str = ""):
-        self.msg = "Read-only file !"
-        
+        super().__init__(msg="Read-only file !")
+

{vdata-0.2.3 → vdata-0.3.0}/vdata/__init__.py

@@ -1,7 +1,5 @@
 """Annotated, temporal and multivariate observation data."""
 
-from ch5mpy import H5Mode
-
 from vdata.data import VData, VDataView, concatenate, convert_anndata_to_vdata
 from vdata.IO import (
     IncoherenceError,
@@ -18,8 +16,6 @@ read_from_csv = VData.read_from_csv
 read_from_anndata = VData.read_from_anndata
 read_from_pickle = VData.read_from_pickle
 
-mode = H5Mode
-
 __all__ = [
     "VData",
     "TemporalDataFrame",

vdata-0.3.0/vdata/_meta.py

@@ -0,0 +1,14 @@
+from abc import ABCMeta
+from typing import override
+
+
+class PrettyRepr(type):
+    @override
+    def __repr__(self) -> str:
+        return f"vdata.{self.__name__}"
+
+
+class PrettyReprABC(ABCMeta):
+    @override
+    def __repr__(self) -> str:
+        return f"vdata.{self.__name__}"

vdata-0.3.0/vdata/_typing.py

@@ -0,0 +1,39 @@
+from collections.abc import Collection, MutableMapping
+from types import EllipsisType
+from typing import SupportsIndex, TypedDict
+
+import ezarr as ez
+import numpy as np
+import numpy.typing as npt
+import zarr
+
+import vdata.timepoint as tp
+from vdata.array_view import NDArrayView
+
+type IF = int | float | np.integer | np.floating
+type IFS = IF | np.str_ | str
+type np_IF = np.integer | np.floating
+type np_IFS = np.integer | np.floating | np.str_
+
+type AnyNDArrayLike[T: np.generic] = npt.NDArray[T] | NDArrayView[T] | zarr.Array
+type AnyNDArrayLike_IF = npt.NDArray[np_IF] | NDArrayView[np_IF] | zarr.Array
+
+type NDArrayList_IFS = npt.NDArray[np_IFS] | list[IFS]
+type NDArrayLike_IFS = npt.NDArray[np_IFS] | zarr.Array
+type AnyNDArrayLike_IFS = npt.NDArray[np_IFS] | NDArrayView[np_IFS] | zarr.Array
+
+type Collection_IFS = Collection[IFS]
+type DictLike[T: ez.SupportsEZReadWrite] = MutableMapping[str, T] | ez.EZDict[T]
+
+type Slicer = IFS | tp.TimePoint | Collection[IFS | tp.TimePoint] | range | slice | EllipsisType
+type MultiSlicer = Collection[IFS | tp.TimePoint] | range | slice | EllipsisType
+type PreSlicer = IFS | tp.TimePoint | Collection[IFS | bool | tp.TimePoint] | range | slice | EllipsisType
+type Indexer = SupportsIndex | slice | npt.NDArray[np.int_] | npt.NDArray[np.bool_] | None
+
+
+class AttrDict(TypedDict):
+    name: str
+    timepoints_column_name: str | None
+    locked_indices: bool
+    locked_columns: bool
+    repeating_index: bool

{vdata-0.2.3 → vdata-0.3.0}/vdata/anndata_proxy/anndata.py

@@ -1,18 +1,17 @@
 from __future__ import annotations
 
+from collections.abc import Sequence
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal, Sequence
+from typing import TYPE_CHECKING, Any, Literal, override
 
 import numpy.typing as npt
 import pandas as pd
 from anndata import AnnData
-from h5dataframe import H5DataFrame
 from scipy import sparse
 
 from vdata._typing import AnyNDArrayLike, DictLike
-from vdata.anndata_proxy.containers import ArrayStack2DProxy, H5DataFrameContainerProxy, TemporalDataFrameContainerProxy
+from vdata.anndata_proxy.containers import ArrayStack2DProxy, EZDataFrameContainerProxy, TemporalDataFrameContainerProxy
 from vdata.anndata_proxy.dataframe import DataFrameProxy_TDF
-from vdata.data._file import NoData
 
 if TYPE_CHECKING:
     from vdata.data import VData, VDataView
@@ -30,9 +29,8 @@ class AnnDataProxy(AnnData):  # type: ignore[misc]
     Class faking to be an anndata.AnnData object but actually wrapping a VData.
     """
 
-    __slots__ = "_vdata", "_X", "_layers", "_obs", "_obsm", "_obsp", "_var", "_varm", "_varp", "_uns"
+    __slots__: tuple[str, ...] = "_vdata", "_X", "_layers", "_obs", "_obsm", "_obsp", "_var", "_varm", "_varp", "_uns"
 
-    # region magic methods
     def __init__(self, vdata: VData | VDataView, X: str | None = None) -> None:
         """
         Args:
@@ -51,10 +49,10 @@ class AnnDataProxy(AnnData):  # type: ignore[misc]
         self._layers = TemporalDataFrameContainerProxy(vdata, name="layers", columns=vdata.var.index)
         self._obs = DataFrameProxy_TDF(vdata.obs)
         self._obsm = TemporalDataFrameContainerProxy(vdata, name="obsm", columns=None)
-        self._obsp = H5DataFrameContainerProxy(vdata.obsp, name="Obsp", index=vdata.obs.index, columns=vdata.obs.index)
+        self._obsp = EZDataFrameContainerProxy(vdata.obsp, name="Obsp", index=vdata.obs.index, columns=vdata.obs.index)
         self._var = vdata.var
-        self._varm = H5DataFrameContainerProxy(vdata.varm, name="Varm", index=vdata.var.index)
-        self._varp = H5DataFrameContainerProxy(vdata.varp, name="Varp", index=vdata.var.index, columns=vdata.var.index)
+        self._varm = EZDataFrameContainerProxy(vdata.varm, name="Varm", index=vdata.var.index)
+        self._varp = EZDataFrameContainerProxy(vdata.varp, name="Varp", index=vdata.var.index, columns=vdata.var.index)
         self._uns = vdata.uns
 
     def __repr__(self) -> str:
@@ -74,9 +72,6 @@ class AnnDataProxy(AnnData):  # type: ignore[misc]
     def __setitem__(self, index: Any, val: int | float | npt.NDArray[Any] | sparse.spmatrix) -> None:
         raise NotImplementedError
 
-    # endregion
-
-    # region attributes
     @property
     def _n_obs(self) -> int:
         return self._vdata.n_obs_total
@@ -151,7 +146,7 @@ class AnnDataProxy(AnnData):  # type: ignore[misc]
         raise NotImplementedError
 
     @property
-    def var(self) -> H5DataFrame:
+    def var(self) -> EZDataFrame:
         """One-dimensional annotation of variables/ features (`pd.DataFrame`)."""
         return self._var
 
@@ -198,7 +193,7 @@ class AnnDataProxy(AnnData):  # type: ignore[misc]
         raise NotImplementedError
 
     @property
-    def varm(self) -> H5DataFrameContainerProxy:
+    def varm(self) -> EZDataFrameContainerProxy:
         return self._varm
 
     @varm.setter
@@ -210,7 +205,7 @@ class AnnDataProxy(AnnData):  # type: ignore[misc]
         raise NotImplementedError
 
     @property
-    def obsp(self) -> H5DataFrameContainerProxy:
+    def obsp(self) -> EZDataFrameContainerProxy:
         return self._obsp
 
     @obsp.setter
@@ -222,7 +217,7 @@ class AnnDataProxy(AnnData):  # type: ignore[misc]
         raise NotImplementedError
 
     @property
-    def varp(self) -> H5DataFrameContainerProxy:
+    def varp(self) -> EZDataFrameContainerProxy:
         return self._varp
 
     @varp.setter
@@ -234,50 +229,42 @@ class AnnDataProxy(AnnData):  # type: ignore[misc]
         raise NotImplementedError
 
     @property
-    def filename(self) -> Path | None:
-        if self._vdata.data is NoData._:
-            return None
-        return Path(self._vdata.data.filename)
-
-    @filename.setter
-    def filename(self, filename: Path | None) -> None:
-        raise NotImplementedError
-
-    # endregion
-
-    # region predicates
-    @property
+    @override
     def isbacked(self) -> bool:
         """`True` if object is backed on disk, `False` otherwise."""
         return self._vdata.is_backed
 
     @property
+    @override
     def is_view(self) -> bool:
         """`True` if object is view of another AnnData object, `False` otherwise."""
         return self._vdata.is_view
 
-    # endregion
-
-    # region methods
     def as_vdata(self) -> VData | VDataView:
         return self._vdata
 
+    @override
     def rename_categories(self, key: str, categories: Sequence[Any]) -> None:
         raise NotImplementedError
 
+    @override
     def strings_to_categoricals(self, df: pd.DataFrame | None = None) -> None:
         raise NotImplementedError
 
+    @override
     def _sanitize(self) -> None:
         # prevent unwanted data modification in the underlying vdata object
         return
 
+    @override
     def _inplace_subset_var(self, index: Any) -> None:
         self._init_from_vdata(self._vdata[skip_time_axis((slice(None), index))])
 
+    @override
     def _inplace_subset_obs(self, index: Any) -> None:
         self._init_from_vdata(self._vdata[skip_time_axis(index)])
 
+    @override
     def copy(self, filename: Path | None = None) -> None:
         """Full copy, optionally on disk."""
         raise NotImplementedError
@@ -290,5 +277,3 @@ class AnnDataProxy(AnnData):  # type: ignore[misc]
         as_dense: Sequence[str] = (),
     ) -> None:
         raise NotImplementedError
-
-    # endregion

{vdata-0.2.3 → vdata-0.3.0}/vdata/anndata_proxy/containers.py

@@ -2,30 +2,42 @@ from __future__ import annotations
 
 import operator as op
 from functools import partialmethod
-from typing import Any, Callable, Collection, ItemsView, KeysView, MutableMapping, Union, ValuesView, cast
+from typing import (
+    Any,
+    Callable,
+    ClassVar,
+    Collection,
+    ItemsView,
+    KeysView,
+    MutableMapping,
+    Union,
+    ValuesView,
+    cast,
+    override,
+)
 
 import numpy as np
 import numpy.typing as npt
 import scipy.sparse as ss
-from h5dataframe import H5DataFrame
 
+# from h5dataframe import EZDataFrame
 import vdata
 from vdata._typing import IFS, AnyNDArrayLike, AnyNDArrayLike_IFS
 from vdata.tdf import TemporalDataFrame, TemporalDataFrameBase
 
-_NP_IF = Union[np.int_, np.float_]
+type _NP_IF = np.integer | np.floating
 
 
 class TemporalDataFrameContainerProxy:
-    __slots__ = "_vdata", "_tdfs", "_name", "_columns"
+    __slots__: tuple[str, ...] = "_vdata", "_tdfs", "_name", "_columns"
 
-    # region magic methods
     def __init__(self, vdata: vdata.VData | vdata.VDataView, name: str, columns: Collection[IFS] | None) -> None:
-        self._vdata = vdata
+        self._vdata: vdata.VData | vdata.VDataView = vdata
         self._tdfs: MutableMapping[str, TemporalDataFrameBase] = getattr(vdata, name)
-        self._name = name.capitalize()
-        self._columns = columns
+        self._name: str = name.capitalize()
+        self._columns: Collection[IFS] | None = columns
 
+    @override
     def __repr__(self) -> str:
         return f"{self._name} with keys: {', '.join(self._tdfs.keys())}"
 
@@ -46,9 +58,6 @@ class TemporalDataFrameContainerProxy:
     def __contains__(self, key: str) -> bool:
         return key in self.keys()
 
-    # endregion
-
-    # region methods
     def keys(self) -> KeysView[str]:
         return self._tdfs.keys()
 
@@ -58,21 +67,19 @@ class TemporalDataFrameContainerProxy:
     def items(self) -> ItemsView[str, TemporalDataFrameBase]:
         return self._tdfs.items()
 
-    # endregion
-
 
 class ArrayStack2DProxy:
-    __slots__ = "_array_numeric", "_array_string", "layer_name"
-    ndim = 2
+    __slots__: tuple[str, ...] = "_array_numeric", "_array_string", "layer_name"
+    ndim: ClassVar[int] = 2
 
-    # region magic methods
     def __init__(
         self, array_numeric: AnyNDArrayLike[_NP_IF], array_string: AnyNDArrayLike[np.str_], layer_name: str | None
     ) -> None:
-        self._array_numeric = array_numeric if array_numeric.size else None
-        self._array_string = array_string if array_string.size else None
-        self.layer_name = layer_name
+        self._array_numeric: AnyNDArrayLike[_NP_IF] | None = array_numeric if array_numeric.size else None
+        self._array_string: AnyNDArrayLike[_NP_IF] | None = array_string if array_string.size else None
+        self.layer_name: str = layer_name
 
+    @override
     def __repr__(self) -> str:
         return repr(self.stack(n=5)) + "\n..." if self.shape[1] > 5 else ""
 
@@ -97,14 +104,14 @@ class ArrayStack2DProxy:
 
         return cast(npt.NDArray[_NP_IF], operation(self._array_numeric, other))
 
-    __add__ = __radd__ = partialmethod(_op, operation=op.add)
-    __sub__ = __rsub__ = partialmethod(_op, operation=op.sub)
-    __mul__ = __rmul__ = partialmethod(_op, operation=op.mul)
-    __truediv__ = __rtruediv__ = partialmethod(_op, operation=op.truediv)
-    __gt__ = partialmethod(_op, operation=op.gt)
-    __ge__ = partialmethod(_op, operation=op.ge)
-    __lt__ = partialmethod(_op, operation=op.lt)
-    __le__ = partialmethod(_op, operation=op.le)
+    __add__ = __radd__ = partialmethod(_op, operation=op.add)  # pyright: ignore[reportUnannotatedClassAttribute]
+    __sub__ = __rsub__ = partialmethod(_op, operation=op.sub)  # pyright: ignore[reportUnannotatedClassAttribute]
+    __mul__ = __rmul__ = partialmethod(_op, operation=op.mul)  # pyright: ignore[reportUnannotatedClassAttribute]
+    __truediv__ = __rtruediv__ = partialmethod(_op, operation=op.truediv)  # pyright: ignore[reportUnannotatedClassAttribute]
+    __gt__ = partialmethod(_op, operation=op.gt)  # pyright: ignore[reportUnannotatedClassAttribute]
+    __ge__ = partialmethod(_op, operation=op.ge)  # pyright: ignore[reportUnannotatedClassAttribute]
+    __lt__ = partialmethod(_op, operation=op.lt)  # pyright: ignore[reportUnannotatedClassAttribute]
+    __le__ = partialmethod(_op, operation=op.le)  # pyright: ignore[reportUnannotatedClassAttribute]
 
     def __array__(self, dtype: npt.DTypeLike = None) -> npt.NDArray[Any]:
         if dtype is None:
@@ -112,9 +119,6 @@ class ArrayStack2DProxy:
 
         return self.stack().astype(dtype)
 
-    # endregion
-
-    # region attributes
     @property
     def shape(self) -> tuple[int, int]:
         if self._array_numeric is not None and self._array_string is not None:
@@ -141,9 +145,6 @@ class ArrayStack2DProxy:
 
         return np.dtype(np.object_)
 
-    # endregion
-
-    # region methods
     def stack(self, n: int | None = None) -> npt.NDArray[Any]:
         _subset = slice(None) if n is None else slice(0, n)
 
@@ -174,16 +175,13 @@ class ArrayStack2DProxy:
             None,
         )
 
-    # endregion
-
 
-class H5DataFrameContainerProxy:
-    __slots__ = "_h5dfs", "_index", "_columns", "_name", "_sparse_matrices"
+class EZDataFrameContainerProxy:
+    __slots__: tuple[str, ...] = "_h5dfs", "_index", "_columns", "_name", "_sparse_matrices"
 
-    # region magic methods
     def __init__(
         self,
-        h5dfs: MutableMapping[str, H5DataFrame],
+        h5dfs: MutableMapping[str, EZDataFrame],
         name: str,
         index: AnyNDArrayLike_IFS,
         columns: AnyNDArrayLike_IFS | None = None,
@@ -196,6 +194,7 @@ class H5DataFrameContainerProxy:
         # FIXME : find better way
         self._sparse_matrices: set[str] = set()
 
+    @override
     def __repr__(self) -> str:
         return f"{self._name} with keys: {', '.join(self._h5dfs.keys())}"
 
@@ -210,15 +209,10 @@ class H5DataFrameContainerProxy:
             self._sparse_matrices.add(str(key))
             value = np.array(value.todense())
 
-        self._h5dfs[str(key)] = H5DataFrame(value, index=self._index, columns=self._columns)
+        self._h5dfs[str(key)] = EZDataFrame(value, index=self._index, columns=self._columns)
 
     def __contains__(self, key: str) -> bool:
         return key in self._h5dfs.keys()
 
-    # endregion
-
-    # region methods
     def keys(self) -> KeysView[str]:
         return self._h5dfs.keys()
-
-    # endregion

{vdata-0.2.3 → vdata-0.3.0}/vdata/anndata_proxy/dataframe.py

@@ -7,20 +7,19 @@ import pandas as pd
 
 from vdata._typing import IFS, Slicer
 from vdata.tdf import TemporalDataFrameBase, TemporalDataFrameView
-from vdata.timepoint import TimePointArray
+from vdata.timepoint import TimePointNArray
 
 
 class DataFrameProxy_TDF:
     __slots__ = ("_tdf",)
 
-    # region magic methods
     def __init__(self, tdf: TemporalDataFrameBase) -> None:
         self._tdf = tdf
 
     def __repr__(self) -> str:
         return f"Proxy<TDF -> DataFrame> for\n{self._tdf}"
 
-    def __getitem__(self, key: Slicer) -> pd.Series[int | float | str] | TimePointArray:
+    def __getitem__(self, key: Slicer) -> pd.Series[int | float | str] | TimePointNArray:
         if key == self._tdf.get_timepoints_column_name():
             return self._tdf.timepoints_column
 
@@ -37,9 +36,6 @@ class DataFrameProxy_TDF:
     def __iter__(self) -> Iterable[str]:
         return iter(self.columns)
 
-    # endregion
-
-    # region attributes
     @property
     def index(self) -> pd.Index:
         return pd.Index(self._tdf.index.values)
@@ -48,10 +44,5 @@ class DataFrameProxy_TDF:
     def columns(self) -> pd.Index:
         return pd.Index(np.concatenate((np.array([self._tdf.get_timepoints_column_name()]), self._tdf.columns)))
 
-    # endregion
-
-    # region methods
     def keys(self) -> pd.Index:
         return self.columns
-
-    # endregion