anndata 0.12.0rc4__py3-none-any.whl → 0.12.2__py3-none-any.whl

anndata/_core/aligned_df.py

@@ -59,7 +59,7 @@ def _gen_dataframe_mapping(
         df = pd.DataFrame(
             anno,
             index=None if length is None else mk_index(length),
-            columns=None if len(anno) else [],
+            columns=None if anno else [],
         )
 
     if length is None:

anndata/_core/anndata.py

@@ -56,13 +56,13 @@ if TYPE_CHECKING:
 
     from zarr.storage import StoreLike
 
-    from ..compat import Index1D, XDataset
+    from ..compat import Index1D, Index1DNorm, XDataset
     from ..typing import XDataType
     from .aligned_mapping import AxisArraysView, LayersView, PairwiseArraysView
     from .index import Index
 
 
-class AnnData(metaclass=utils.DeprecationMixinMeta):
+class AnnData(metaclass=utils.DeprecationMixinMeta):  # noqa: PLW1641
     """\
     An annotated data matrix.
 
@@ -197,6 +197,11 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
 
     _accessors: ClassVar[set[str]] = set()
 
+    # view attributes
+    _adata_ref: AnnData | None
+    _oidx: Index1DNorm | None
+    _vidx: Index1DNorm | None
+
     @old_positionals(
         "obsm",
         "varm",
@@ -226,8 +231,8 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
         asview: bool = False,
         obsp: np.ndarray | Mapping[str, Sequence[Any]] | None = None,
         varp: np.ndarray | Mapping[str, Sequence[Any]] | None = None,
-        oidx: Index1D | None = None,
-        vidx: Index1D | None = None,
+        oidx: Index1DNorm | int | np.integer | None = None,
+        vidx: Index1DNorm | int | np.integer | None = None,
     ):
         # check for any multi-indices that aren’t later checked in coerce_array
         for attr, key in [(obs, "obs"), (var, "var"), (X, "X")]:
@@ -237,6 +242,8 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
             if not isinstance(X, AnnData):
                 msg = "`X` has to be an AnnData object."
                 raise ValueError(msg)
+            assert oidx is not None
+            assert vidx is not None
             self._init_as_view(X, oidx, vidx)
         else:
             self._init_as_actual(
@@ -256,7 +263,12 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
                 filemode=filemode,
             )
 
-    def _init_as_view(self, adata_ref: AnnData, oidx: Index, vidx: Index):
+    def _init_as_view(
+        self,
+        adata_ref: AnnData,
+        oidx: Index1DNorm | int | np.integer,
+        vidx: Index1DNorm | int | np.integer,
+    ):
         if adata_ref.isbacked and adata_ref.is_view:
             msg = (
                 "Currently, you cannot index repeatedly into a backed AnnData, "
@@ -277,6 +289,9 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
             vidx += adata_ref.n_vars * (vidx < 0)
             vidx = slice(vidx, vidx + 1, 1)
         if adata_ref.is_view:
+            assert adata_ref._adata_ref is not None
+            assert adata_ref._oidx is not None
+            assert adata_ref._vidx is not None
             prev_oidx, prev_vidx = adata_ref._oidx, adata_ref._vidx
             adata_ref = adata_ref._adata_ref
             oidx, vidx = _resolve_idxs((prev_oidx, prev_vidx), (oidx, vidx), adata_ref)
@@ -1004,7 +1019,9 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
 
         write_attribute(self.file._file, attr, value)
 
-    def _normalize_indices(self, index: Index | None) -> tuple[slice, slice]:
+    def _normalize_indices(
+        self, index: Index | None
+    ) -> tuple[Index1DNorm | int | np.integer, Index1DNorm | int | np.integer]:
         return _normalize_indices(index, self.obs_names, self.var_names)
 
     # TODO: this is not quite complete...

anndata/_core/index.py

@@ -14,18 +14,18 @@ from ..compat import AwkArray, CSArray, CSMatrix, DaskArray, XDataArray
 from .xarray import Dataset2D
 
 if TYPE_CHECKING:
-    from ..compat import Index, Index1D
+    from ..compat import Index, Index1D, Index1DNorm
 
 
 def _normalize_indices(
     index: Index | None, names0: pd.Index, names1: pd.Index
-) -> tuple[slice, slice]:
+) -> tuple[Index1DNorm | int | np.integer, Index1DNorm | int | np.integer]:
     # deal with tuples of length 1
     if isinstance(index, tuple) and len(index) == 1:
         index = index[0]
     # deal with pd.Series
     if isinstance(index, pd.Series):
-        index: Index = index.values
+        index = index.values
     if isinstance(index, tuple):
         # TODO: The series should probably be aligned first
         index = tuple(i.values if isinstance(i, pd.Series) else i for i in index)
@@ -36,15 +36,8 @@ def _normalize_indices(
 
 
 def _normalize_index(  # noqa: PLR0911, PLR0912
-    indexer: slice
-    | np.integer
-    | int
-    | str
-    | Sequence[bool | int | np.integer]
-    | np.ndarray
-    | pd.Index,
-    index: pd.Index,
-) -> slice | int | np.ndarray:  # ndarray of int or bool
+    indexer: Index1D, index: pd.Index
+) -> Index1DNorm | int | np.integer:
     # TODO: why is this here? All tests pass without it and it seems at the minimum not strict enough.
     if not isinstance(index, pd.RangeIndex) and index.dtype in (np.float64, np.int64):
         msg = f"Don’t call _normalize_index with non-categorical/string names and non-range index {index}"
@@ -212,7 +205,7 @@ def _subset_awkarray(a: AwkArray, subset_idx: Index):
 
 # Registration for SparseDataset occurs in sparse_dataset.py
 @_subset.register(h5py.Dataset)
-def _subset_dataset(d, subset_idx):
+def _subset_dataset(d: h5py.Dataset, subset_idx: Index):
     if not isinstance(subset_idx, tuple):
         subset_idx = (subset_idx,)
     ordered = list(subset_idx)

anndata/_core/merge.py

@@ -904,12 +904,6 @@ def concat_arrays(  # noqa: PLR0911, PLR0912
             ],
             format="csr",
         )
-        scipy_version = Version(scipy.__version__)
-        # Bug where xstack produces a matrix not an array in 1.11.*
-        if use_sparse_array and (scipy_version.major, scipy_version.minor) == (1, 11):
-            if mat.format == "csc":
-                return sparse.csc_array(mat)
-            return sparse.csr_array(mat)
         return mat
     else:
         return np.concatenate(

anndata/_core/raw.py

@@ -17,7 +17,7 @@ if TYPE_CHECKING:
     from collections.abc import Mapping, Sequence
     from typing import ClassVar
 
-    from ..compat import CSMatrix
+    from ..compat import CSMatrix, Index, Index1DNorm
     from .aligned_mapping import AxisArraysView
     from .anndata import AnnData
     from .sparse_dataset import BaseCompressedSparseDataset
@@ -121,7 +121,7 @@ class Raw:
     def obs_names(self) -> pd.Index[str]:
         return self._adata.obs_names
 
-    def __getitem__(self, index):
+    def __getitem__(self, index: Index) -> Raw:
         oidx, vidx = self._normalize_indices(index)
 
         # To preserve two dimensional shape
@@ -169,7 +169,9 @@ class Raw:
             uns=self._adata.uns.copy(),
         )
 
-    def _normalize_indices(self, packed_index):
+    def _normalize_indices(
+        self, packed_index: Index
+    ) -> tuple[Index1DNorm | int | np.integer, Index1DNorm | int | np.integer]:
         # deal with slicing with pd.Series
         if isinstance(packed_index, pd.Series):
             packed_index = packed_index.values

anndata/_core/sparse_dataset.py

@@ -165,7 +165,11 @@ class BackedSparseMatrix(_cs_matrix):
     def _get_contiguous_compressed_slice(
         self, s: slice
     ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
-        new_indptr = self.indptr[s.start : s.stop + 1].copy()
+        new_indptr = self.indptr[s.start : s.stop + 1]
+        # If indptr is cached, we need to make a copy of the subset
+        # so as not to alter the underlying cached data.
+        if isinstance(self.indptr, np.ndarray):
+            new_indptr = new_indptr.copy()
 
         start = new_indptr[0]
         stop = new_indptr[-1]

anndata/_core/views.py

@@ -29,8 +29,12 @@ if TYPE_CHECKING:
     from collections.abc import Callable, Iterable, KeysView, Sequence
     from typing import Any, ClassVar
 
+    from numpy.typing import NDArray
+
     from anndata import AnnData
 
+    from ..compat import Index1DNorm
+
 
 @contextmanager
 def view_update(adata_view: AnnData, attr_name: str, keys: tuple[str, ...]):
@@ -433,18 +437,24 @@ except ImportError:
         pass
 
 
-def _resolve_idxs(old, new, adata):
-    t = tuple(_resolve_idx(old[i], new[i], adata.shape[i]) for i in (0, 1))
-    return t
+def _resolve_idxs(
+    old: tuple[Index1DNorm, Index1DNorm],
+    new: tuple[Index1DNorm, Index1DNorm],
+    adata: AnnData,
+) -> tuple[Index1DNorm, Index1DNorm]:
+    o, v = (_resolve_idx(old[i], new[i], adata.shape[i]) for i in (0, 1))
+    return o, v
 
 
 @singledispatch
-def _resolve_idx(old, new, l):
-    return old[new]
+def _resolve_idx(old: Index1DNorm, new: Index1DNorm, l: Literal[0, 1]) -> Index1DNorm:
+    raise NotImplementedError
 
 
 @_resolve_idx.register(np.ndarray)
-def _resolve_idx_ndarray(old, new, l):
+def _resolve_idx_ndarray(
+    old: NDArray[np.bool_] | NDArray[np.integer], new: Index1DNorm, l: Literal[0, 1]
+) -> NDArray[np.bool_] | NDArray[np.integer]:
     if is_bool_dtype(old) and is_bool_dtype(new):
         mask_new = np.zeros_like(old)
         mask_new[np.flatnonzero(old)[new]] = True
@@ -454,21 +464,17 @@ def _resolve_idx_ndarray(old, new, l):
     return old[new]
 
 
-@_resolve_idx.register(np.integer)
-@_resolve_idx.register(int)
-def _resolve_idx_scalar(old, new, l):
-    return np.array([old])[new]
-
-
 @_resolve_idx.register(slice)
-def _resolve_idx_slice(old, new, l):
+def _resolve_idx_slice(
+    old: slice, new: Index1DNorm, l: Literal[0, 1]
+) -> slice | NDArray[np.integer]:
     if isinstance(new, slice):
         return _resolve_idx_slice_slice(old, new, l)
     else:
         return np.arange(*old.indices(l))[new]
 
 
-def _resolve_idx_slice_slice(old, new, l):
+def _resolve_idx_slice_slice(old: slice, new: slice, l: Literal[0, 1]) -> slice:
     r = range(*old.indices(l))[new]
     # Convert back to slice
     start, stop, step = r.start, r.stop, r.step

anndata/_core/xarray.py

@@ -184,18 +184,6 @@ class Dataset2D:
         Handler class for doing the iloc-style indexing using :meth:`~xarray.Dataset.isel`.
         """
 
-        @dataclass(frozen=True)
-        class IlocGetter:
-            _ds: XDataset
-            _coord: str
-
-            def __getitem__(self, idx) -> Dataset2D:
-                # xarray seems to have some code looking for a second entry in tuples,
-                # so we unpack the tuple
-                if isinstance(idx, tuple) and len(idx) == 1:
-                    idx = idx[0]
-                return Dataset2D(self._ds.isel(**{self._coord: idx}))
-
         return IlocGetter(self.ds, self.index_dim)
 
     # See https://github.com/pydata/xarray/blob/568f3c1638d2d34373408ce2869028faa3949446/xarray/core/dataset.py#L1239-L1248
@@ -245,7 +233,7 @@ class Dataset2D:
         if df.index.name != index_key and index_key is not None:
             df = df.set_index(index_key)
         for col in set(self.columns) - non_nullable_string_cols:
-            df[col] = pd.array(self[col].data, dtype="string")
+            df[col] = df[col].astype(dtype="string")
         df.index.name = None  # matches old AnnData object
         return df
 
@@ -389,9 +377,12 @@ class Dataset2D:
         }
         el = self.ds.drop_vars(extension_arrays.keys())
         el = el.reindex({index_dim: index}, method=None, fill_value=fill_value)
-        for col in self.ds:
-            el[col] = pd.Series(self.ds[col], index=self.index).reindex(
-                index, fill_value=fill_value
+        for col, data in extension_arrays.items():
+            el[col] = XDataArray.from_series(
+                pd.Series(data.data, index=self.index).reindex(
+                    index.rename(self.index.name) if index is not None else index,
+                    fill_value=fill_value,
+                )
             )
         return Dataset2D(el)
 
@@ -399,3 +390,16 @@ class Dataset2D:
     def _items(self):
         for col in self:
             yield col, self[col]
+
+
+@dataclass(frozen=True)
+class IlocGetter:
+    _ds: XDataset
+    _coord: str
+
+    def __getitem__(self, idx) -> Dataset2D:
+        # xarray seems to have some code looking for a second entry in tuples,
+        # so we unpack the tuple
+        if isinstance(idx, tuple) and len(idx) == 1:
+            idx = idx[0]
+        return Dataset2D(self._ds.isel(**{self._coord: idx}))

anndata/_io/h5ad.py

@@ -4,7 +4,7 @@ import re
 from functools import partial
 from pathlib import Path
 from types import MappingProxyType
-from typing import TYPE_CHECKING, TypeVar
+from typing import TYPE_CHECKING, TypeVar, cast
 from warnings import warn
 
 import h5py
@@ -36,11 +36,12 @@ from .utils import (
 )
 
 if TYPE_CHECKING:
-    from collections.abc import Callable, Collection, Mapping, Sequence
+    from collections.abc import Callable, Collection, Container, Mapping, Sequence
     from os import PathLike
     from typing import Any, Literal
 
     from .._core.file_backing import AnnDataFileManager
+    from .._core.raw import Raw
 
 T = TypeVar("T")
 
@@ -82,29 +83,18 @@ def write_h5ad(
         # TODO: Use spec writing system for this
         # Currently can't use write_dispatched here because this function is also called to do an
         # inplace update of a backed object, which would delete "/"
-        f = f["/"]
+        f = cast("h5py.Group", f["/"])
         f.attrs.setdefault("encoding-type", "anndata")
         f.attrs.setdefault("encoding-version", "0.1.0")
 
-        if "X" in as_dense and isinstance(
-            adata.X, CSMatrix | BaseCompressedSparseDataset
-        ):
-            write_sparse_as_dense(f, "X", adata.X, dataset_kwargs=dataset_kwargs)
-        elif not (adata.isbacked and Path(adata.filename) == Path(filepath)):
-            # If adata.isbacked, X should already be up to date
-            write_elem(f, "X", adata.X, dataset_kwargs=dataset_kwargs)
-        if "raw/X" in as_dense and isinstance(
-            adata.raw.X, CSMatrix | BaseCompressedSparseDataset
-        ):
-            write_sparse_as_dense(
-                f, "raw/X", adata.raw.X, dataset_kwargs=dataset_kwargs
-            )
-            write_elem(f, "raw/var", adata.raw.var, dataset_kwargs=dataset_kwargs)
-            write_elem(
-                f, "raw/varm", dict(adata.raw.varm), dataset_kwargs=dataset_kwargs
-            )
-        elif adata.raw is not None:
-            write_elem(f, "raw", adata.raw, dataset_kwargs=dataset_kwargs)
+        _write_x(
+            f,
+            adata,  # accessing adata.X reopens adata.file if it’s backed
+            is_backed=adata.isbacked and adata.filename == filepath,
+            as_dense=as_dense,
+            dataset_kwargs=dataset_kwargs,
+        )
+        _write_raw(f, adata.raw, as_dense=as_dense, dataset_kwargs=dataset_kwargs)
         write_elem(f, "obs", adata.obs, dataset_kwargs=dataset_kwargs)
         write_elem(f, "var", adata.var, dataset_kwargs=dataset_kwargs)
         write_elem(f, "obsm", dict(adata.obsm), dataset_kwargs=dataset_kwargs)
@@ -115,6 +105,41 @@ def write_h5ad(
         write_elem(f, "uns", dict(adata.uns), dataset_kwargs=dataset_kwargs)
 
 
+def _write_x(
+    f: h5py.Group,
+    adata: AnnData,
+    *,
+    is_backed: bool,
+    as_dense: Container[str],
+    dataset_kwargs: Mapping[str, Any],
+) -> None:
+    if "X" in as_dense and isinstance(adata.X, CSMatrix | BaseCompressedSparseDataset):
+        write_sparse_as_dense(f, "X", adata.X, dataset_kwargs=dataset_kwargs)
+    elif is_backed:
+        pass  # If adata.isbacked, X should already be up to date
+    elif adata.X is None:
+        f.pop("X", None)
+    else:
+        write_elem(f, "X", adata.X, dataset_kwargs=dataset_kwargs)
+
+
+def _write_raw(
+    f: h5py.Group,
+    raw: Raw,
+    *,
+    as_dense: Container[str],
+    dataset_kwargs: Mapping[str, Any],
+) -> None:
+    if "raw/X" in as_dense and isinstance(
+        raw.X, CSMatrix | BaseCompressedSparseDataset
+    ):
+        write_sparse_as_dense(f, "raw/X", raw.X, dataset_kwargs=dataset_kwargs)
+        write_elem(f, "raw/var", raw.var, dataset_kwargs=dataset_kwargs)
+        write_elem(f, "raw/varm", dict(raw.varm), dataset_kwargs=dataset_kwargs)
+    elif raw is not None:
+        write_elem(f, "raw", raw, dataset_kwargs=dataset_kwargs)
+
+
 @report_write_key_on_error
 @write_spec(IOSpec("array", "0.2.0"))
 def write_sparse_as_dense(
@@ -176,7 +201,7 @@ def read_h5ad_backed(
 
 def read_h5ad(
     filename: PathLike[str] | str,
-    backed: Literal["r", "r+"] | bool | None = None,
+    backed: Literal["r", "r+"] | bool | None = None,  # noqa: FBT001
     *,
     as_sparse: Sequence[str] = (),
     as_sparse_fmt: type[CSMatrix] = sparse.csr_matrix,

anndata/_io/read.py

@@ -22,9 +22,11 @@ if TYPE_CHECKING:
     from collections.abc import Generator, Iterable, Iterator, Mapping
 
 
+@old_positionals("first_column_names", "dtype")
 def read_csv(
     filename: PathLike[str] | str | Iterator[str],
     delimiter: str | None = ",",
+    *,
     first_column_names: bool | None = None,
     dtype: str = "float32",
 ) -> AnnData:
@@ -46,7 +48,9 @@ def read_csv(
     dtype
         Numpy data type.
     """
-    return read_text(filename, delimiter, first_column_names, dtype)
+    return read_text(
+        filename, delimiter, first_column_names=first_column_names, dtype=dtype
+    )
 
 
 def read_excel(
@@ -331,9 +335,11 @@ def read_mtx(filename: PathLike[str] | str, dtype: str = "float32") -> AnnData:
     return AnnData(X)
 
 
+@old_positionals("first_column_names", "dtype")
 def read_text(
     filename: PathLike[str] | str | Iterator[str],
     delimiter: str | None = None,
+    *,
     first_column_names: bool | None = None,
     dtype: str = "float32",
 ) -> AnnData:
@@ -356,18 +362,26 @@ def read_text(
         Numpy data type.
     """
     if not isinstance(filename, PathLike | str | bytes):
-        return _read_text(filename, delimiter, first_column_names, dtype)
+        return _read_text(
+            filename, delimiter, first_column_names=first_column_names, dtype=dtype
+        )
 
     filename = Path(filename)
     if filename.suffix == ".gz":
         with gzip.open(str(filename), mode="rt") as f:
-            return _read_text(f, delimiter, first_column_names, dtype)
+            return _read_text(
+                f, delimiter, first_column_names=first_column_names, dtype=dtype
+            )
     elif filename.suffix == ".bz2":
         with bz2.open(str(filename), mode="rt") as f:
-            return _read_text(f, delimiter, first_column_names, dtype)
+            return _read_text(
+                f, delimiter, first_column_names=first_column_names, dtype=dtype
+            )
     else:
         with filename.open() as f:
-            return _read_text(f, delimiter, first_column_names, dtype)
+            return _read_text(
+                f, delimiter, first_column_names=first_column_names, dtype=dtype
+            )
 
 
 def _iter_lines(file_like: Iterable[str]) -> Generator[str, None, None]:
@@ -381,6 +395,7 @@ def _iter_lines(file_like: Iterable[str]) -> Generator[str, None, None]:
 def _read_text(  # noqa: PLR0912, PLR0915
     f: Iterator[str],
     delimiter: str | None,
+    *,
     first_column_names: bool | None,
     dtype: str,
 ) -> AnnData:

anndata/_io/specs/lazy_methods.py

@@ -132,7 +132,7 @@ def read_sparse_as_dask(
     path_or_sparse_dataset = (
         Path(filename(elem))
         if isinstance(elem, H5Group)
-        else ad.io.sparse_dataset(elem)
+        else ad.io.sparse_dataset(elem, should_cache_indptr=False)
     )
     elem_name = get_elem_name(elem)
     shape: tuple[int, int] = tuple(elem.attrs["shape"])
@@ -177,21 +177,37 @@ def read_sparse_as_dask(
     return da_mtx
 
 
+def resolve_chunks(
+    elem: H5Array | ZarrArray,
+    chunks_arg: tuple[int, ...] | None,
+    shape: tuple[int, ...],
+) -> tuple[int, ...]:
+    shape = tuple(elem.shape)
+    if chunks_arg is not None:
+        # None and -1 on a given axis indicate that one should use the shape
+        # in `dask`'s semantics.
+        return tuple(
+            c if c not in {None, -1} else s
+            for c, s in zip(chunks_arg, shape, strict=True)
+        )
+    elif elem.chunks is None:  # h5 unchunked
+        return tuple(min(_DEFAULT_STRIDE, s) for s in shape)
+    return elem.chunks
+
+
 @_LAZY_REGISTRY.register_read(H5Array, IOSpec("string-array", "0.2.0"))
 def read_h5_string_array(
     elem: H5Array,
     *,
     _reader: LazyReader,
-    chunks: tuple[int, int] | None = None,
+    chunks: tuple[int] | None = None,
 ) -> DaskArray:
     import dask.array as da
 
     from anndata._io.h5ad import read_dataset
 
-    return da.from_array(
-        read_dataset(elem),
-        chunks=chunks if chunks is not None else (_DEFAULT_STRIDE,) * len(elem.shape),
-    )
+    chunks = resolve_chunks(elem, chunks, tuple(elem.shape))
+    return da.from_array(read_dataset(elem), chunks=chunks)
 
 
 @_LAZY_REGISTRY.register_read(H5Array, IOSpec("array", "0.2.0"))
@@ -204,13 +220,7 @@ def read_h5_array(
     elem_name: str = elem.name
     shape = tuple(elem.shape)
     dtype = elem.dtype
-    chunks = (
-        tuple(
-            c if c not in {None, -1} else s for c, s in zip(chunks, shape, strict=True)
-        )
-        if chunks is not None
-        else tuple(min(_DEFAULT_STRIDE, s) for s in shape)
-    )
+    chunks = resolve_chunks(elem, chunks, shape)
 
     chunk_layout = tuple(
         compute_chunk_layout_for_axis_size(chunks[i], shape[i])
@@ -228,7 +238,6 @@ def read_h5_array(
 def read_zarr_array(
     elem: ZarrArray, *, _reader: LazyReader, chunks: tuple[int, ...] | None = None
 ) -> DaskArray:
-    chunks: tuple[int, ...] = chunks if chunks is not None else elem.chunks
     import dask.array as da
 
     return da.from_zarr(elem, chunks=chunks)
@@ -284,9 +293,10 @@ def read_dataframe(
     *,
     _reader: LazyReader,
     use_range_index: bool = False,
+    chunks: tuple[int] | None = None,
 ) -> Dataset2D:
     elem_dict = {
-        k: _reader.read_elem(elem[k])
+        k: _reader.read_elem(elem[k], chunks=chunks)
         for k in [*elem.attrs["column-order"], elem.attrs["_index"]]
     }
     # If we use a range index, the coord axis needs to have the special dim name