vdata 1.0rc1__py3-none-any.whl

vdata/IO/__init__.py

@@ -0,0 +1,19 @@
+# coding: utf-8
+# Created on 11/6/20 6:07 PM
+# Author : matteo
+
+# ====================================================
+# imports
+from .errors import IncoherenceError, ShapeError, VClosedFileError, VLockError, VReadOnlyError
+from .logger import generalLogger, getLoggingLevel, setLoggingLevel
+
+__all__ = [
+    'generalLogger', 
+    'setLoggingLevel', 
+    'getLoggingLevel', 
+    'ShapeError',
+    'IncoherenceError', 
+    'VLockError', 
+    'VClosedFileError',
+    'VReadOnlyError'
+]

vdata/IO/errors.py

@@ -0,0 +1,53 @@
+from . import logger
+
+
+# Errors
+class VBaseError(Exception):
+    """
+    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
+
+    def __str__(self) -> str:
+        logger.generalLogger.error(self.msg)
+        return self.msg
+
+
+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):
+    """
+    Custom error for modifications on read only data.
+    """
+
+    def __init__(self, msg: str = ""):
+        self.msg = "Read-only file !"
+        

vdata/IO/logger.py

@@ -0,0 +1,261 @@
+from __future__ import annotations
+
+import logging.config
+import os
+import sys
+import traceback
+import warnings
+from enum import Enum
+from pathlib import Path
+from types import TracebackType
+from typing import Any, Callable, Optional, Type
+
+from vdata.IO import errors
+
+warnings.simplefilter(action="ignore", category=FutureWarning)
+
+
+class LoggingLevel(Enum):
+    DEBUG = 10
+    INFO = 20
+    WARNING = 30
+    ERROR = 40
+    CRITICAL = 50
+
+
+class Color:
+    TCYAN = "\033[36m"
+    TORANGE = "\033[33m"
+    TRED = "\033[31m"
+    BBLACK = "\033[40m"
+    BGREY = "\033[100m"
+    ENDC = "\033[0m"
+
+
+class Tb:
+    trace: Optional[TracebackType] = None
+    exception: Type[BaseException] = BaseException
+
+
+def callable_msg(level: LoggingLevel) -> Callable[[Callable[..., None]], Callable[..., Any]]:
+    def inner(func: Callable[[_VLogger, str | Callable[[], str]], None]) -> Callable[..., Any]:
+        def wrapper(self: _VLogger, msg: str | Callable[[], str]) -> None:
+            if not self.logger.isEnabledFor(level.value):
+                return None
+
+            if callable(msg):
+                msg = msg()
+
+            return func(self, msg)
+
+        return wrapper
+
+    return inner
+
+
+# code
+class _VLogger:
+    """
+    Custom logger for reporting messages to the console.
+    Logging levels are :
+        - DEBUG
+        - INFO
+        - WARNING
+        - ERROR
+        - CRITICAL
+
+    The default minimal level for logging is <INFO>.
+    """
+
+    def __init__(self, logger_level: LoggingLevel = LoggingLevel.WARNING):
+        """
+        :param logger_level: minimal log level for the logger. (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+        """
+        # load configuration from logging.conf
+        logging.config.fileConfig(
+            Path(os.path.dirname(__file__)) / "logger.conf",
+            defaults={"log_level": logger_level.name},
+            disable_existing_loggers=False,
+        )
+
+        # get logger
+        self.logger = logging.getLogger("vdata.vlogger")
+
+    @property
+    def level(self) -> LoggingLevel:
+        """
+        Get the logging level.
+        :return: the logging level.
+        """
+        return LoggingLevel(self.logger.level)
+
+    @level.setter
+    def level(self, log_level: LoggingLevel | str) -> None:
+        """
+        Re-init the logger, for setting new minimal logging level
+        :param logger_level: minimal log level for the logger. (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+        """
+        log_level = _as_log_level(log_level)
+
+        self.logger.setLevel(log_level.name)
+        for handler in self.logger.handlers:
+            handler.setLevel(log_level.name)
+
+    @staticmethod
+    def _getBaseMsg(msg: str) -> str:
+        """
+        Build the message to log with format <[fileName.py] msg>
+
+        :param msg: the message to be logged
+        :return: the formatted message
+        """
+
+        # Get the name of the file that called the logger for displaying where the message came from
+        # if Tb.trace is None:
+        #     frames = inspect.stack(0)
+        #
+        #     caller_filename = frames[0].filename
+        #     index = 0
+        #
+        #     while index < len(frames) - 1 and (caller_filename.endswith("logger.py")
+        #                                        or caller_filename.endswith("errors.py")):
+        #         index += 1
+        #         caller_filename = frames[index].filename
+        #
+        #     caller = os.path.splitext(os.path.basename(caller_filename))[0]
+        #
+        #     # return base message
+        #     return f"[{caller}.py] {msg}"
+        #
+        # else:
+        #     traceback.print_tb(Tb.trace)
+        #     caller = ""
+        #
+        #     while Tb.trace is not None:
+        #         caller = Tb.trace.tb_frame.f_code.co_filename
+        #         Tb.trace = Tb.trace.tb_next
+        #
+        #     return f"[{os.path.basename(caller)} : {Tb.exception.__name__}] {msg}"
+
+        return msg
+
+    @callable_msg(LoggingLevel.DEBUG)
+    def debug(self, msg: str) -> None:
+        """
+        Log a debug message (level 10)
+
+        :param msg: the message to be logged
+        """
+        self.logger.debug(Color.BGREY + self._getBaseMsg(msg) + Color.ENDC)
+
+    @callable_msg(LoggingLevel.INFO)
+    def info(self, msg: str) -> None:
+        """
+        Log an info message (level 20)
+
+        :param msg: the message to be logged
+        """
+        self.logger.info(Color.TCYAN + self._getBaseMsg(msg) + Color.ENDC)
+
+    @callable_msg(LoggingLevel.WARNING)
+    def warning(self, msg: str) -> None:
+        """
+        Log a warning message (level 30)
+
+        :param msg: the message to be logged
+        """
+        self.logger.warning(Color.TORANGE + self._getBaseMsg(msg) + Color.ENDC)
+
+    @callable_msg(LoggingLevel.ERROR)
+    def error(self, msg: str) -> None:
+        """
+        Log an error message (level 40)
+
+        :param msg: the message to be logged
+        """
+        self.logger.error(Color.TRED + self._getBaseMsg(msg) + Color.ENDC)
+        quit()
+
+    def uncaught_error(self, msg: str) -> None:
+        """
+        Log and uncaught (not originating from a custom error class) error message (level 40)
+
+        :param msg: the message to be logged
+        """
+        traceback.print_tb(Tb.trace)
+
+        last = None
+        while Tb.trace is not None:
+            last = Tb.trace.tb_frame
+            Tb.trace = Tb.trace.tb_next
+
+        self.logger.error(
+            f"[{last.f_globals['__name__'] if last is not None else 'UNCAUGHT'} :" f" {Tb.exception.__name__}] {msg}"
+        )
+
+    @callable_msg(LoggingLevel.CRITICAL)
+    def critical(self, msg: str) -> None:
+        """
+        Log a critical message (level 50)
+
+        :param msg: the message to be logged
+        """
+        self.logger.critical(Color.TRED + Color.BBLACK + self._getBaseMsg(msg) + Color.ENDC)
+
+
+generalLogger = _VLogger()
+
+
+def _as_log_level(log_level: LoggingLevel | str) -> LoggingLevel:
+    if not isinstance(log_level, LoggingLevel):
+        try:
+            return LoggingLevel[log_level]
+
+        except KeyError as e:
+            raise KeyError(
+                f"Incorrect logging level '{log_level}', " f"should be in {[ll.value for ll in LoggingLevel]}"
+            ) from e
+
+    return log_level
+
+
+def setLoggingLevel(log_level: LoggingLevel | str) -> None:
+    """
+    Set the logging level for package vdata.
+    :param log_level: a logging level to set, in ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL']
+    """
+    generalLogger.level = _as_log_level(log_level)
+
+
+def getLoggingLevel() -> LoggingLevel:
+    """
+    Get the logging level for package vdata.
+    :return: the logging level for package vdata.
+    """
+    return generalLogger.level
+
+
+# disable traceback messages, except if the logging level is set to DEBUG
+def exception_handler(
+    exception_type: Type[BaseException],
+    exception: BaseException,
+    traceback_: TracebackType,
+    debug_hook: Callable[[type[BaseException], BaseException, TracebackType | None], Any] = sys.excepthook,
+) -> None:
+    Tb.trace = traceback_
+    Tb.exception = exception_type
+
+    if generalLogger.level == LoggingLevel.DEBUG:
+        if not issubclass(exception_type, errors.VBaseError):
+            generalLogger.uncaught_error(str(exception))
+        debug_hook(exception_type, exception, traceback_)
+    else:
+        if not issubclass(exception_type, errors.VBaseError):
+            generalLogger.uncaught_error(str(exception))
+        else:
+            print(exception)
+
+    traceback.print_tb(traceback_)
+
+
+sys.excepthook = exception_handler  # type: ignore[assignment]

vdata/__init__.py

@@ -0,0 +1,36 @@
+"""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,
+    ShapeError,
+    VLockError,
+    getLoggingLevel,
+    setLoggingLevel,
+)
+from vdata.tdf import Index, TemporalDataFrame, TemporalDataFrameView
+from vdata.timepoint import TimePoint
+
+read = VData.read
+read_from_csv = VData.read_from_csv
+read_from_anndata = VData.read_from_anndata
+
+mode = H5Mode
+
+__all__ = [
+    "VData",
+    "TemporalDataFrame",
+    "VDataView",
+    "TemporalDataFrameView",
+    "convert_anndata_to_vdata",
+    "setLoggingLevel",
+    "getLoggingLevel",
+    "concatenate",
+    "ShapeError",
+    "IncoherenceError",
+    "VLockError",
+    "TimePoint",
+    "Index",
+]

vdata/_meta.py

@@ -0,0 +1,3 @@
+class PrettyRepr(type):
+    def __repr__(self) -> str:
+        return f"vdata.{self.__name__}"

vdata/_typing.py

@@ -0,0 +1,46 @@
+from types import EllipsisType
+from typing import Collection, SupportsIndex, TypedDict, TypeVar, Union
+
+import ch5mpy as ch
+import numpy as np
+import numpy.typing as npt
+
+import vdata.timepoint as tp
+from vdata.array_view import NDArrayView
+from vdata.timedict import TimeDict
+
+_T = TypeVar("_T")
+_T_NP = TypeVar("_T_NP", bound=np.generic)
+
+IF = Union[int, float, np.int_, np.float_]
+IFS = Union[np.int_, int, np.float_, float, np.str_, str]
+
+AnyNDArrayLike = Union[npt.NDArray[_T_NP], ch.H5Array[_T_NP], NDArrayView[_T_NP]]
+
+AnyNDArrayLike_IF = Union[
+    npt.NDArray[np.int_ | np.float_], ch.H5Array[np.int_ | np.float_], NDArrayView[np.int_ | np.float_]
+]
+
+NDArray_IFS = npt.NDArray[np.int_ | np.float_ | np.str_]
+NDArrayLike_IFS = Union[npt.NDArray[np.int_ | np.float_ | np.str_], ch.H5Array[np.int_ | np.float_ | np.str_]]
+AnyNDArrayLike_IFS = Union[
+    npt.NDArray[np.int_ | np.float_ | np.str_],
+    ch.H5Array[np.int_ | np.float_ | np.str_],
+    NDArrayView[np.int_ | np.float_ | np.str_],
+]
+
+Collection_IFS = Collection[np.int_ | int | np.float_ | float | np.str_ | str]
+DictLike = Union[dict[str, _T], ch.H5Dict[_T]]
+AnyDictLike = Union[dict[str, _T], ch.H5Dict[_T], TimeDict]
+
+Slicer = Union[IFS, tp.TimePoint, Collection[Union[IFS, tp.TimePoint]], range, slice, EllipsisType]
+PreSlicer = Union[IFS, tp.TimePoint, Collection[Union[IFS, bool, tp.TimePoint]], range, slice, EllipsisType]
+Indexer = Union[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/anndata_proxy/__init__.py

@@ -0,0 +1,3 @@
+from vdata.anndata_proxy.anndata import AnnDataProxy
+
+__all__ = ["AnnDataProxy"]

vdata/anndata_proxy/anndata.py

@@ -0,0 +1,285 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Literal, Sequence
+
+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 H5DataFrameContainerProxy, TemporalDataFrameContainerProxy
+from vdata.anndata_proxy.dataframe import DataFrameProxy_TDF
+from vdata.data._file import NoData
+
+if TYPE_CHECKING:
+    from vdata.data import VData, VDataView
+
+
+def skip_time_axis(slicer: Any) -> tuple[Any, ...]:
+    if isinstance(slice, tuple):
+        return (slice(None),) + slicer
+
+    return (slice(None), slicer)
+
+
+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"
+
+    # region magic methods
+    def __init__(self, vdata: VData | VDataView, X: str | None = None) -> None:
+        """
+        Args:
+            vdata: a VData object to wrap.
+            X: an optional layer name to use as X.
+        """
+        self._X = None if X is None else str(X)
+
+        if self._X is not None and self._X not in vdata.layers:
+            raise ValueError(f"Could not find layer '{self._X}' in the given VData.")
+
+        self._init_from_vdata(vdata)
+
+    def _init_from_vdata(self, vdata: VData | VDataView) -> None:
+        self._vdata = vdata
+        self._layers = TemporalDataFrameContainerProxy(vdata, name="layers")
+        self._obs = DataFrameProxy_TDF(vdata.obs)
+        self._obsm = TemporalDataFrameContainerProxy(vdata, name="obsm")
+        self._obsp = H5DataFrameContainerProxy(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._uns = vdata.uns
+
+    def __repr__(self) -> str:
+        return f"AnnDataProxy from {self._vdata}"
+
+    def __sizeof__(self, show_stratified: bool | None = None) -> int:
+        del show_stratified
+        raise NotImplementedError
+
+    def __delitem__(self, index: Any) -> None:
+        raise NotImplementedError
+
+    def __getitem__(self, index: Any) -> AnnDataProxy:
+        """Returns a sliced view of the object."""
+        return AnnDataProxy(self._vdata[skip_time_axis(index)], X=self._X)
+
+    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
+
+    @property
+    def _n_vars(self) -> int:
+        return self._vdata.n_var
+
+    @property
+    def X(self) -> AnyNDArrayLike[Any] | None:
+        if self._X is None:
+            return None
+        return self._vdata.layers[self._X].values
+
+    @X.setter
+    def X(self, value: Any) -> None:
+        raise NotImplementedError
+
+    @X.deleter
+    def X(self) -> None:
+        self._X = None
+
+    @property
+    def layers(self) -> TemporalDataFrameContainerProxy:
+        return self._layers
+
+    @layers.setter
+    def layers(self, value: Any) -> None:
+        del value
+        raise NotImplementedError
+
+    @layers.deleter
+    def layers(self) -> None:
+        raise NotImplementedError
+
+    @property
+    def raw(self) -> None:
+        raise NotImplementedError
+
+    @raw.setter
+    def raw(self, value: AnnData) -> None:
+        raise NotImplementedError
+
+    @raw.deleter
+    def raw(self) -> None:
+        raise NotImplementedError
+
+    @property
+    def obs(self) -> DataFrameProxy_TDF:
+        return self._obs
+
+    @obs.setter
+    def obs(self, value: pd.DataFrame) -> None:
+        raise NotImplementedError
+
+    @obs.deleter
+    def obs(self) -> None:
+        raise NotImplementedError
+
+    @property
+    def obs_names(self) -> pd.Index:
+        """Names of observations (alias for `.obs.index`)."""
+        return self.obs.index
+
+    @obs_names.setter
+    def obs_names(self, names: Sequence[str]) -> None:
+        raise NotImplementedError
+
+    @property
+    def var(self) -> H5DataFrame:
+        """One-dimensional annotation of variables/ features (`pd.DataFrame`)."""
+        return self._var
+
+    @var.setter
+    def var(self, value: pd.DataFrame) -> None:
+        raise NotImplementedError
+
+    @var.deleter
+    def var(self) -> None:
+        raise NotImplementedError
+
+    @property
+    def var_names(self) -> pd.Index:
+        """Names of variables (alias for `.var.index`)."""
+        return self.var.index
+
+    @var_names.setter
+    def var_names(self, names: Sequence[str]) -> None:
+        raise NotImplementedError
+
+    @property
+    def uns(self) -> DictLike[Any]:
+        """Unstructured annotation (ordered dictionary)."""
+        return self._uns
+
+    @uns.setter
+    def uns(self, value: DictLike[Any]) -> None:
+        raise NotImplementedError
+
+    @uns.deleter
+    def uns(self) -> None:
+        raise NotImplementedError
+
+    @property
+    def obsm(self) -> TemporalDataFrameContainerProxy:
+        return self._obsm
+
+    @obsm.setter
+    def obsm(self, value: Any) -> None:
+        raise NotImplementedError
+
+    @obsm.deleter
+    def obsm(self) -> None:
+        raise NotImplementedError
+
+    @property
+    def varm(self) -> H5DataFrameContainerProxy:
+        return self._varm
+
+    @varm.setter
+    def varm(self, value: Any) -> None:
+        raise NotImplementedError
+
+    @varm.deleter
+    def varm(self) -> None:
+        raise NotImplementedError
+
+    @property
+    def obsp(self) -> H5DataFrameContainerProxy:
+        return self._obsp
+
+    @obsp.setter
+    def obsp(self, value: Any) -> None:
+        raise NotImplementedError
+
+    @obsp.deleter
+    def obsp(self) -> None:
+        raise NotImplementedError
+
+    @property
+    def varp(self) -> H5DataFrameContainerProxy:
+        return self._varp
+
+    @varp.setter
+    def varp(self, value: Any) -> None:
+        raise NotImplementedError
+
+    @varp.deleter
+    def varp(self) -> None:
+        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
+    def isbacked(self) -> bool:
+        """`True` if object is backed on disk, `False` otherwise."""
+        return self._vdata.is_backed
+
+    @property
+    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
+
+    def rename_categories(self, key: str, categories: Sequence[Any]) -> None:
+        raise NotImplementedError
+
+    def strings_to_categoricals(self, df: pd.DataFrame | None = None) -> None:
+        raise NotImplementedError
+
+    def _inplace_subset_var(self, index: Any) -> None:
+        self._init_from_vdata(self._vdata[skip_time_axis((slice(None), index))])
+
+    def _inplace_subset_obs(self, index: Any) -> None:
+        self._init_from_vdata(self._vdata[skip_time_axis(index)])
+
+    def copy(self, filename: Path | None = None) -> None:
+        """Full copy, optionally on disk."""
+        raise NotImplementedError
+
+    def write_h5ad(
+        self,
+        filename: Path | None = None,
+        compression: Literal["gzip", "lzf"] | None = None,
+        compression_opts: Any = None,
+        as_dense: Sequence[str] = (),
+    ) -> None:
+        raise NotImplementedError
+
+    # endregion