vdata 0.3.4__tar.gz → 0.3.6__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "vdata"
-version = "0.3.4"
+version = "0.3.6"
 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.3",
+    "ezarr>=1.1.4",
 ]
 
 [dependency-groups]
@@ -25,7 +25,7 @@ dev = [
 
 docs= [
     "mkdocs-material>=9.5.10",
-# mkdocstrings = {extras = ["python"], version = "^0.24.0"}
+    "mkdocstrings[python]>=0.24.0",
     "mkdocs>=1.5.3"
 ]
 

vdata-0.3.6/vdata/IO/__init__.py

@@ -0,0 +1,12 @@
+from vdata.IO.errors import IncoherenceError, InvalidVDataFileError, ShapeError, VBaseError, VLockError, VReadOnlyError
+from vdata.IO.logger import generalLogger
+
+__all__ = [
+    "generalLogger",
+    "IncoherenceError",
+    "InvalidVDataFileError",
+    "ShapeError",
+    "VBaseError",
+    "VLockError",
+    "VReadOnlyError",
+]

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

@@ -3,17 +3,9 @@
 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,
-    VBaseError,
-    VLockError,
-)
+from vdata.IO import IncoherenceError, InvalidVDataFileError, ShapeError, VBaseError, VLockError, VReadOnlyError
 from vdata.tdf import RepeatingIndex, TemporalDataFrame, TemporalDataFrameView
 from vdata.timepoint import TimePoint
 from vdata.utils import copy_vdata
@@ -27,6 +19,9 @@ __version__ = metadata("vdata").get("version")
 
 
 def get_version(path: str | Path) -> int:
+    import ch5mpy as ch
+    import ezarr
+
     try:
         return ch.H5Dict.read(path).attributes.get("__vdata_write_version__", 0)
 
@@ -39,6 +34,7 @@ __all__ = [
     "convert_anndata_to_vdata",
     "copy_vdata",
     "IncoherenceError",
+    "InvalidVDataFileError",
     "RepeatingIndex",
     "ShapeError",
     "TemporalDataFrame",
@@ -48,5 +44,6 @@ __all__ = [
     "VData",
     "VDataView",
     "VLockError",
+    "VReadOnlyError",
     "WRITE_PROTOCOL_VERSION",
 ]

{vdata-0.3.4 → vdata-0.3.6}/vdata/_typing.py

@@ -1,10 +1,14 @@
 from collections.abc import Collection
+from pathlib import Path
 from types import EllipsisType
 from typing import SupportsIndex, TypedDict
 
 import numpy as np
 import numpy.typing as npt
 import zarr
+from zarr.abc.store import Store
+from zarr.core.buffer import Buffer
+from zarr.storage import StorePath
 
 import vdata.timepoint as tp
 from vdata.array_view import NDArrayView
@@ -28,6 +32,8 @@ 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
 
+type StoreLike = Store | StorePath | Path | str | dict[str, Buffer]
+
 
 class AttrDict(TypedDict):
     name: str

{vdata-0.3.4 → vdata-0.3.6}/vdata/data/_parse/anndata.py

@@ -44,10 +44,12 @@ def parse_AnnData(adata: AnnData, data: ParsingDataIn) -> ParsingDataOut:
     generalLogger.debug("  VData creation from an AnnData.")
 
     # import and cast obs to a TemporalDataFrame
+    if data.timepoints_column_name is not None:
+        del data.obs[data.timepoints_column_name]
+
     obs = TemporalDataFrame(
         adata.obs,
         timepoints=data.timepoints_list,
-        time_col_name=data.time_col_name,
         name="obs",
         lock=(True, False),
     )

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

@@ -33,7 +33,7 @@ def at_least_empty_dict(d: Mapping[Any, Any] | None) -> Mapping[Any, Any]:
 def _get_time_list(
     time_list: tp.TimePointNArray | NDArrayView[tp.TimePoint] | None,
     data: Any,
-    time_col_name: str | None,
+    timepoints_column_name: str | None,
 ) -> tp.TimePointNArray | NDArrayView[tp.TimePoint] | None:
     if time_list is not None:
         return time_list
@@ -47,8 +47,8 @@ def _get_time_list(
         if isinstance(df, TemporalDataFrameBase):
             return df.timepoints_column
 
-        elif isinstance(df, (pd.DataFrame, EZDataFrame)) and time_col_name is not None:
-            return tp.as_timepointarray(df[time_col_name])
+        elif isinstance(df, (pd.DataFrame, EZDataFrame)) and timepoints_column_name is not None:
+            return tp.as_timepointarray(df[timepoints_column_name])
 
     return None
 
@@ -61,13 +61,13 @@ def _valid_obs(
     | None,
     obs: pd.DataFrame | EZDataFrame | TemporalDataFrameBase | None,
     time_list: tp.TimePointNArray | NDArrayView[tp.TimePoint] | None,
-    time_col_name: str | None,
+    timepoints_column_name: str | None,
 ) -> TemporalDataFrameBase:
     if obs is None:
         generalLogger.debug("Default empty TemporalDataFrame for obs.")
 
         _obs_index = get_obs_index(data, obs)
-        _time_list = _get_time_list(time_list, data, time_col_name)
+        _time_list = _get_time_list(time_list, data, timepoints_column_name)
 
         _obs = TemporalDataFrame(
             timepoints=_time_list,
@@ -81,7 +81,9 @@ def _valid_obs(
     generalLogger.debug(f"    2. \u2713 'obs' is a {type(obs).__name__}.")
 
     if isinstance(obs, (pd.DataFrame, EZDataFrame)):
-        _obs = TemporalDataFrame(obs, timepoints=time_list, time_col_name=time_col_name, name="obs", index=obs.index)
+        _obs = TemporalDataFrame(
+            obs, timepoints=time_list, timepoints_column_name=timepoints_column_name, name="obs", index=obs.index
+        )
         _obs.lock_indices()
         return _obs
 
@@ -104,14 +106,14 @@ def _valid_var(
     | Mapping[str, pd.DataFrame | EZDataFrame | TemporalDataFrameBase]
     | None,
     var: pd.DataFrame | EZDataFrame | None,
-    time_col_name: str | None,
+    timepoints_column_name: str | None,
 ) -> EZDataFrame:
     if var is None:
         generalLogger.debug("Default empty DataFrame for vars.")
         _index = get_var_index(data, var)
 
-        if _index is not None and time_col_name is not None:
-            ix = np.where(_index == time_col_name)[0][0]
+        if _index is not None and timepoints_column_name is not None:
+            ix = np.where(_index == timepoints_column_name)[0][0]
             _index = np.delete(_index, ix)
 
         return EZDataFrame(pd.DataFrame(index=_index))
@@ -139,7 +141,7 @@ class ParsingDataIn:
     varm: Mapping[str, pd.DataFrame | EZDataFrame]
     varp: Mapping[str, pd.DataFrame | EZDataFrame | npt.NDArray[np_IFS]]
     timepoints: pd.DataFrame | EZDataFrame
-    time_col_name: str | None
+    timepoints_column_name: str | None
     timepoints_list: tp.TimePointNArray | NDArrayView[tp.TimePoint] | None
     uns: Mapping[str, Any]
     layers: dict[str, TemporalDataFrame | TemporalDataFrameView] = field(init=False)
@@ -166,23 +168,24 @@ class ParsingDataIn:
         var: pd.DataFrame | EZDataFrame | None,
         varm: Mapping[str, pd.DataFrame | EZDataFrame] | None,
         varp: Mapping[str, pd.DataFrame | EZDataFrame | npt.NDArray[np_IFS]] | None,
-        timepoints: pd.DataFrame | EZDataFrame | None,
-        time_col_name: str | None,
+        timepoints: pd.DataFrame | EZDataFrame | tp.TimePointLike | None,
+        timepoints_column_name: str | 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)
+        _timepoints_list = parse_timepoints_list(timepoints_list, timepoints_column_name, obs)
+        _obs = _valid_obs(data, obs, _timepoints_list, timepoints_column_name)
 
         return ParsingDataIn(
             data,
-            _valid_obs(data, obs, _timepoints_list, time_col_name),
+            _obs,
             at_least_empty_dict(obsm),
             at_least_empty_dict(obsp),
-            _valid_var(data, var, time_col_name),
+            _valid_var(data, var, timepoints_column_name),
             at_least_empty_dict(varm),
             at_least_empty_dict(varp),
             parse_timepoints(timepoints),
-            time_col_name,
+            timepoints_column_name,
             _timepoints_list,
             at_least_empty_dict(uns),
         )
@@ -198,7 +201,7 @@ class ParsingDataIn:
         varm: Any,
         varp: Any,
         timepoints: Any,
-        time_col_name: Any,
+        timepoints_column_name: Any,
         timepoints_list: Any,
         uns: Any,
     ) -> ParsingDataIn:
@@ -236,8 +239,8 @@ class ParsingDataIn:
             varm=adata.varm,
             varp=adata.varp,
             timepoints=parse_timepoints(timepoints),
-            time_col_name=time_col_name,
-            timepoints_list=parse_timepoints_list(timepoints_list, time_col_name, adata.obs),
+            timepoints_column_name=timepoints_column_name,
+            timepoints_list=parse_timepoints_list(timepoints_list, timepoints_column_name, adata.obs),
             uns=adata.uns,
         )
 
@@ -265,7 +268,7 @@ class ParsingDataOut:
             dataset = getattr(self, attr)
             if len(dataset) and first_in(dataset).shape[0] != n_timepoints:
                 raise IncoherenceError(
-                    f"{attr} has {first_in(dataset).shape[0]} time point{'' if first_in(dataset).shape[0] == 1 else 's'} but {n_timepoints} {'was' if n_timepoints == 1 else 'were'} given."
+                    f"{attr}:{dataset} has {first_in(dataset).shape[0]} time point{'' if first_in(dataset).shape[0] == 1 else 's'} but {n_timepoints} {'was' if n_timepoints == 1 else 'were'} given."
                 )
 
         generalLogger.debug("Time points were coherent across arrays.")

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

@@ -15,7 +15,7 @@ def _parse_data_from_dataframe(df: pd.DataFrame, data: ParsingDataIn) -> Tempora
     tdf = TemporalDataFrame(
         df,
         timepoints=data.timepoints_list,
-        time_col_name=data.time_col_name,
+        timepoints_column_name=data.timepoints_column_name,
         name="data",
     )
 
@@ -30,7 +30,8 @@ def _parse_data_from_tdf(tdf: TemporalDataFrame, data: ParsingDataIn) -> Tempora
     tdf.unlock_columns()
 
     if data.timepoints.empty:
-        data.timepoints = pd.DataFrame({"value": tdf.timepoints})
+        for idx, tp in enumerate(tdf.timepoints):
+            data.timepoints.loc[idx] = (tp.value, tp.unit)
 
     elif np.any(data.timepoints.value.values != tdf.timepoints):
         raise ValueError("'time points' found in DataFrame do not match 'layers' time points.")
@@ -81,6 +82,5 @@ def parse_layers(data: ParsingDataIn) -> None:
         return
 
     raise TypeError(
-        f"Type '{type(data.data)}' is not allowed for 'data' parameter, should be a dict,"
-        f"a pandas DataFrame, a TemporalDataFrame or an AnnData object."
+        f"Type '{type(data.data)}' is not allowed for 'data' parameter, should be a dict, a pandas DataFrame, a TemporalDataFrame or an AnnData object."
     )

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

@@ -15,7 +15,8 @@ from vdata.tdf import TemporalDataFrameBase
 def _valid_timepoints(data: ParsingDataIn, obs: TemporalDataFrameBase) -> Any:  # EZDataFrame:
     if data.timepoints.empty:
         generalLogger.debug("Default empty DataFrame for time points.")
-        data.timepoints["value"] = obs.timepoints
+        for row in [(tp.value, tp.unit) for tp in obs.timepoints]:
+            data.timepoints.loc[len(data.timepoints)] = row
 
     log_timepoints(data.timepoints)
     return data.timepoints if isinstance(data.timepoints, EZDataFrame) else EZDataFrame(data.timepoints)

vdata-0.3.6/vdata/data/_parse/time.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+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
+from vdata.array_view import NDArrayView
+from vdata.data._parse.utils import log_timepoints
+from vdata.IO.logger import generalLogger
+from vdata.tdf import TemporalDataFrameBase, TemporalDataFrameView
+from vdata.utils import first_in
+
+if TYPE_CHECKING:
+    from vdata.data._parse.data import ParsingDataIn
+
+
+def parse_timepoints_list(
+    timepoints_list: Collection[str | tp.TimePoint] | tp.TimePointNArray | None,
+    timepoints_column_name: str | 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)
+
+    elif obs is not None and timepoints_column_name is not None:
+        if timepoints_column_name not in obs.columns:
+            raise ValueError(f"Could not find column '{timepoints_column_name}' in obs.")
+
+        if isinstance(obs, TemporalDataFrameBase):
+            column = cast(TemporalDataFrameView, obs[timepoints_column_name])
+            return tp.as_timepointarray(column.values)
+
+        return tp.as_timepointarray(obs[timepoints_column_name])
+
+    return None
+
+    # TODO : could also get timepoints_list from obsm and obsp
+
+
+def parse_timepoints(timepoints: pd.DataFrame | EZDataFrame | tp.TimePointLike | None) -> EZDataFrame:
+    if timepoints is None:
+        generalLogger.debug("  'time points' DataFrame was not given.")
+        return EZDataFrame(pd.DataFrame(columns=np.array(["value", "unit"])), dtypes={"value": float, "unit": str})
+
+    if not isinstance(timepoints, (pd.DataFrame, EZDataFrame)):
+        try:
+            timepoint = tp.TimePoint(timepoints)
+
+        except ValueError:
+            raise TypeError(f"'time points' must be a DataFrame or TimePointLike, got '{timepoints}'.")
+
+        else:
+            return EZDataFrame({"value": [timepoint.value], "unit": [timepoint.unit]})
+
+    if "value" not in timepoints.columns:
+        raise ValueError("'time points' must have at least a column 'value' to store time points value.")
+
+    to_drop = ["value"]
+
+    if "unit" in timepoints.columns:
+        timepoints_col = tp.as_timepointarray(
+            [f"{value}{unit}" for value, unit in zip(timepoints.value, timepoints.unit)]
+        )
+        to_drop.append("unit")
+
+    else:
+        timepoints_col = tp.as_timepointarray(timepoints["value"])
+
+    timepoints_col.sort()
+
+    timepoints = EZDataFrame(timepoints.drop(to_drop, axis=1))
+    timepoints.insert(0, "value", np.array(timepoints_col))
+    timepoints.insert(1, "unit", np.repeat(timepoints_col.unit, len(timepoints_col)))
+    log_timepoints(timepoints)
+
+    return timepoints
+
+
+def check_time_match(data: ParsingDataIn) -> None:
+    """
+    Build timepoints DataFrame if it was not given by the user but 'timepoints_list' or 'timepoints_column_name' were given.
+    Otherwise, if both timepoints and 'timepoints_list' or 'timepoints_column_name' were given, check that they match.
+    """
+    if data.timepoints.empty and data.timepoints_list is None and data.timepoints_column_name is None:
+        # timepoints cannot be guessed
+        return
+
+    # build timepoints DataFrame from timepoints_list or timepoints_column_name
+    if data.timepoints.empty and data.timepoints_list is not None:
+        timepoints = np.unique(data.timepoints_list, equal_nan=False)
+
+        data.timepoints["value"] = np.array(timepoints)
+        data.timepoints["unit"] = np.repeat(timepoints.unit, len(timepoints))
+
+        return
+
+    if data.timepoints.empty and len(data.layers):
+        timepoints = np.unique(first_in(data.layers).timepoints, equal_nan=False)
+
+        data.timepoints["value"] = np.array(timepoints)
+        data.timepoints["unit"] = np.repeat(timepoints.unit, len(timepoints))
+
+        return
+
+    # check that timepoints and _time_list and _timepoints_column_name match
+    if data.timepoints_list is not None and not np.all(
+        np.isin(data.timepoints_list, tp.as_timepointarray(data.timepoints.value))
+    ):
+        raise ValueError("There are values in 'timepoints_list' unknown in 'timepoints'.")
+
+    elif data.timepoints_column_name is not None and not np.all(
+        np.isin(tp.as_timepointarray(data.obs["timepoints"]), tp.as_timepointarray(data.timepoints.value))
+    ):
+        raise ValueError(f"There are values in obs['{data.timepoints_column_name}'] unknown in 'timepoints'.")

{vdata-0.3.4 → vdata-0.3.6}/vdata/data/_parse/utils.py

@@ -7,6 +7,5 @@ from vdata.utils import repr_array
 def log_timepoints(timepoints: pd.DataFrame) -> None:
     generalLogger.debug(f"  {len(timepoints)} time point{' was' if len(timepoints) == 1 else 's were'} found finally.")
     generalLogger.debug(
-        f"    \u21b3 Time point{' is' if len(timepoints) == 1 else 's are'} : "
-        f"{repr_array(list(timepoints.value)) if len(timepoints) else '[]'}"
+        f"    \u21b3 Time point{' is' if len(timepoints) == 1 else 's are'} : {repr_array(list(timepoints.value)) if len(timepoints) else '[]'}"
     )

{vdata-0.3.4 → vdata-0.3.6}/vdata/data/concatenate.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
+from collections.abc import Sequence
 from copy import deepcopy
-from typing import Sequence
 
 import numpy as np
 import pandas as pd
@@ -10,13 +10,13 @@ from vdata.data.vdata import VData
 from vdata.IO import generalLogger
 
 
-def concatenate(arr: Sequence[VData], name: str = "") -> "VData":
+def concatenate(arr: Sequence[VData], name: str = "") -> VData:
     """
     Concatenate together multiple VData objects, which share the same layer keys, vars and time points.
 
     Args:
-        - arr: sequence of at least 2 VData objects to concatenate.
-        - name: a name for the concatenated VData object.
+        arr: sequence of at least 2 VData objects to concatenate.
+        name: a name for the concatenated VData object.
 
     Returns:
         A concatenated VData object.
@@ -24,7 +24,7 @@ def concatenate(arr: Sequence[VData], name: str = "") -> "VData":
     if len(arr) < 2:
         raise ValueError("At least 2 VData objects must be provided.")
 
-    if not all(isinstance(arg, VData) for arg in arr):
+    if not all(isinstance(arg, VData) for arg in arr):  # pyright: ignore[reportUnnecessaryIsInstance]
         raise TypeError("Only Vdata objects are allowed.")
 
     generalLogger.debug(

{vdata-0.3.4 → vdata-0.3.6}/vdata/data/convert.py

@@ -1,22 +1,22 @@
 from __future__ import annotations
 
 import pickle
+import shutil
+import warnings
 from collections.abc import Collection, Iterable
 from pathlib import Path
-import shutil
 from typing import Any, Literal, overload
-import warnings
 
 import ch5mpy as ch
 import ezarr as ez
-from ezarr.names import Attribute, EZType
 import numpy as np
 import numpy.typing as npt
 from anndata import AnnData
 from ezarr.dataframe import EZDataFrame
+from ezarr.names import Attribute, EZType
 from tqdm.auto import tqdm
 from zarr.codecs.numcodecs import LZ4
-from zarr.errors import UnstableSpecificationWarning
+from zarr.errors import UnstableSpecificationWarning, ZarrUserWarning
 
 import vdata
 import vdata.timepoint as tp
@@ -231,7 +231,9 @@ def convert_to_TDF(
         }
     )
 
-    compressors = LZ4()
+    with warnings.catch_warnings(action="ignore", category=ZarrUserWarning):
+        compressors = LZ4()
+
     with data.parameters(compressors):
         data["timepoints_index"] = timepoints
         data["index"] = index[sorting_indices]
@@ -284,7 +286,10 @@ def _convert_anndata_to_vdata(
             np.ones(data["obs"][next(iter(data["obs"]))].shape[0]) * timepoint.value, unit=timepoint.unit
         )
 
-    z_data["timepoints"] = EZDataFrame({"value": np.unique(timepoints_list, equal_nan=False)})
+    _unique_tps = np.unique(timepoints_list, equal_nan=False)
+    z_data["timepoints"] = EZDataFrame(
+        {"value": _unique_tps, "unit": np.repeat(timepoints_list.unit, len(_unique_tps))}
+    )
     progressBar.update()
 
     # obs ---------------------------------------------------------------------
@@ -394,10 +399,10 @@ def convert_anndata_to_vdata(
     /!\ WARNING : if done inplace, you won't be able to open the file as an anndata anymore !
 
     Args:
-        - path: path to the anndata h5 file to convert.
-        - timepoint: a unique timepoint to set for the data in the anndata.
-        - timepoints_column_name: the name of the column in anndata's obs to use as indicator of time point for the data.
-        - drop_X: do not preserve the 'X' dataset ? (default: False)
+        path: path to the anndata h5 file to convert.
+        timepoint: a unique timepoint to set for the data in the anndata.
+        timepoints_column_name: the name of the column in anndata's obs to use as indicator of time point for the data.
+        drop_X: do not preserve the 'X' dataset ? (default: False)
     """
     path = Path(path)
     data = ch.H5Dict.read(path, mode=ch.H5Mode.READ_WRITE)

{vdata-0.3.4 → vdata-0.3.6}/vdata/data/read.py

@@ -14,14 +14,14 @@ from vdata.timepoint import TimePoint
 from vdata.utils import spacer
 
 
-def _get_time_col_name(
+def _get_timepoints_column_name(
     time_list: Sequence[str | TimePoint] | Literal["*"] | None,
-    time_col_name: str | None,
+    timepoints_column_name: str | None,
     metadata: dict[str, Any] | None,
     *metadata_keys: str,
 ) -> str | None:
-    if time_list is not None or time_col_name is not None:
-        return time_col_name
+    if time_list is not None or timepoints_column_name is not None:
+        return timepoints_column_name
 
     if metadata is None:
         return None
@@ -48,7 +48,7 @@ def _get_col_dtype(
 def read_from_csv(
     path: str | Path,
     time_list: Sequence[str | TimePoint] | Literal["*"] | None = None,
-    time_col_name: str | None = None,
+    timepoints_column_name: str | None = None,
     name: str = "",
 ) -> vdata.VData:
     """
@@ -111,7 +111,9 @@ def read_from_csv(
                 obs = TemporalDataFrame.read_from_csv(
                     parsed_directory / f.name,
                     timepoints=time_list,
-                    time_col_name=_get_time_col_name(time_list, time_col_name, metadata, "obs"),
+                    timepoints_column_name=_get_timepoints_column_name(
+                        time_list, timepoints_column_name, metadata, "obs"
+                    ),
                 )
 
         else:
@@ -126,7 +128,9 @@ def read_from_csv(
                     dataset_dict[dataset.name[:-4]] = TemporalDataFrame.read_from_csv(
                         parsed_directory / f.name / dataset.name,
                         timepoints=time_list,
-                        time_col_name=_get_time_col_name(time_list, time_col_name, metadata, f.name, dataset.name[:-4]),
+                        timepoints_column_name=_get_timepoints_column_name(
+                            time_list, timepoints_column_name, metadata, f.name, dataset.name[:-4]
+                        ),
                         columns_dtype=_get_col_dtype(metadata, f.name, dataset.name[:-4]),
                     )