anndata 0.12.7__py3-none-any.whl → 0.12.8__py3-none-any.whl

anndata/_core/anndata.py

@@ -362,7 +362,12 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):  # noqa: PLW1641
 
         # init from file
         if filename is not None:
-            self.file = AnnDataFileManager(self, filename, filemode)
+            fileobj, filename = (
+                (filename, None)
+                if isinstance(filename, h5py.File)
+                else (None, filename)
+            )
+            self.file = AnnDataFileManager(self, filename, filemode, fileobj)
         else:
             self.file = AnnDataFileManager(self, None)
 

anndata/_core/index.py

@@ -25,12 +25,6 @@ def _normalize_indices(
     # 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.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)
     ax0, ax1 = unpack_index(index)
     ax0 = _normalize_index(ax0, names0)
     ax1 = _normalize_index(ax1, names1)
@@ -45,6 +39,9 @@ def _normalize_index(  # noqa: PLR0911, PLR0912
         msg = f"Don’t call _normalize_index with non-categorical/string names and non-range index {index}"
         raise TypeError(msg)
 
+    if isinstance(indexer, pd.Index | pd.Series):
+        indexer = indexer.array
+
     # the following is insanely slow for sequences,
     # we replaced it using pandas below
     def name_idx(i):
@@ -65,16 +62,21 @@ def _normalize_index(  # noqa: PLR0911, PLR0912
     elif isinstance(indexer, str):
         return index.get_loc(indexer)  # int
     elif isinstance(
-        indexer, Sequence | np.ndarray | pd.Index | CSMatrix | np.matrix | CSArray
+        indexer,
+        Sequence
+        | np.ndarray
+        | pd.api.extensions.ExtensionArray
+        | CSMatrix
+        | np.matrix
+        | CSArray,
     ):
-        if hasattr(indexer, "shape") and (
-            (indexer.shape == (index.shape[0], 1))
-            or (indexer.shape == (1, index.shape[0]))
+        if (shape := getattr(indexer, "shape", None)) is not None and (
+            shape == (index.shape[0], 1) or shape == (1, index.shape[0])
         ):
             if isinstance(indexer, CSMatrix | CSArray):
                 indexer = indexer.toarray()
             indexer = np.ravel(indexer)
-        if not isinstance(indexer, np.ndarray | pd.Index):
+        if not isinstance(indexer, np.ndarray):
             indexer = np.array(indexer)
             if len(indexer) == 0:
                 indexer = indexer.astype(int)
@@ -111,7 +113,7 @@ def _normalize_index(  # noqa: PLR0911, PLR0912
             return indexer.data.compute()
         return indexer.data
     msg = f"Unknown indexer {indexer!r} of type {type(indexer)}"
-    raise IndexError()
+    raise IndexError(msg)
 
 
 def _fix_slice_bounds(s: slice, length: int) -> slice:

anndata/_core/merge.py

@@ -10,7 +10,7 @@ from collections.abc import Callable, Mapping, MutableSet
 from functools import partial, reduce, singledispatch
 from itertools import repeat
 from operator import and_, or_, sub
-from typing import TYPE_CHECKING, Literal, TypeVar
+from typing import TYPE_CHECKING, Literal, TypeVar, cast
 from warnings import warn
 
 import numpy as np
@@ -44,7 +44,7 @@ if TYPE_CHECKING:
 
     from anndata._types import Join_T
 
-    from ..compat import XDataArray, XDataset
+    from ..compat import XDataArray
 
 T = TypeVar("T")
 
@@ -244,110 +244,89 @@ def as_cp_sparse(x) -> CupySparseMatrix:
 def unify_dtypes(
     dfs: Iterable[pd.DataFrame | Dataset2D],
 ) -> list[pd.DataFrame | Dataset2D]:
-    """
-    Attempts to unify datatypes from multiple dataframes.
+    """Attempt to unify datatypes from multiple dataframes.
 
     For catching cases where pandas would convert to object dtype.
     """
     dfs = list(dfs)
     # Get shared categorical columns
-    df_dtypes = [dict(df.dtypes) for df in dfs]
+    df_dtypes = [
+        cast("pd.Series[ExtensionDtype]", df.dtypes).to_dict()
+        if isinstance(df, pd.DataFrame)
+        else df.dtypes
+        for df in dfs
+    ]
     columns = reduce(lambda x, y: x.union(y), [df.columns for df in dfs])
-
-    dtypes: dict[str, list[np.dtype | ExtensionDtype]] = {col: [] for col in columns}
-    for col in columns:
-        for df in df_dtypes:
-            dtypes[col].append(df.get(col, None))
-
+    dtypes = {
+        col: (
+            [df[col] for df in df_dtypes if col in df],
+            any(col not in df for df in df_dtypes),
+        )
+        for col in columns
+    }
     if len(dtypes) == 0:
         return dfs
-    else:
-        dfs = [df.copy(deep=False) for df in dfs]
 
     new_dtypes = {
         col: target_dtype
-        for col, dtype in dtypes.items()
-        if (target_dtype := try_unifying_dtype(dtype)) is not None
+        for col, (dts, has_missing) in dtypes.items()
+        if (target_dtype := try_unifying_dtype(dts, has_missing=has_missing))
+        is not None
     }
 
+    dfs = [df.copy(deep=False) for df in dfs]
     for df in dfs:
         for col, dtype in new_dtypes.items():
             if col in df:
                 df[col] = df[col].astype(dtype)
-
     return dfs
 
 
-def try_unifying_dtype(  # noqa PLR0911, PLR0912
-    col: Sequence[np.dtype | ExtensionDtype],
-) -> pd.core.dtypes.base.ExtensionDtype | None:
-    """
-    If dtypes can be unified, returns the dtype they would be unified to.
+def try_unifying_dtype(
+    dtypes: Sequence[np.dtype | ExtensionDtype], *, has_missing: bool
+) -> ExtensionDtype | type[object] | None:
+    """Determine unified dtype if possible.
 
-    Returns None if they can't be unified, or if we can expect pandas to unify them for
-    us.
+    Returns None if they can’t be unified, or if we can expect pandas to unify them for us.
 
     Params
     ------
-    col:
-        A list of dtypes to unify. Can be numpy/ pandas dtypes, or None (which denotes
-        a missing value)
+    dtypes
+        A list of dtypes to unify. Can be numpy or pandas dtypes
+    has_missing
+        Whether the result needs to accommodate missing values
     """
-    dtypes: set[pd.CategoricalDtype] = set()
     # Categorical
-    if any(isinstance(dtype, pd.CategoricalDtype) for dtype in col):
-        ordered = False
-        for dtype in col:
-            if isinstance(dtype, pd.CategoricalDtype):
-                dtypes.add(dtype)
-                ordered = ordered | dtype.ordered
-            elif not pd.isnull(dtype):
-                return None
-        if len(dtypes) > 0:
-            categories = reduce(
-                lambda x, y: x.union(y),
-                (dtype.categories for dtype in dtypes if not pd.isnull(dtype)),
-            )
+    if any(isinstance(dtype, pd.CategoricalDtype) for dtype in dtypes):
+        if not all(isinstance(dtype, pd.CategoricalDtype) for dtype in dtypes):
+            return None
+        if TYPE_CHECKING:
+            dtypes = cast("Sequence[pd.CategoricalDtype]", dtypes)
+
+        all_categories = reduce(
+            lambda x, y: x.union(y), (dtype.categories for dtype in dtypes)
+        )
+        if not any(dtype.ordered for dtype in dtypes):
+            return pd.CategoricalDtype(natsorted(all_categories), ordered=False)
+
+        dtypes_with_categories = [
+            dtype for dtype in dtypes if len(dtype.categories) > 0
+        ]
+        if dtypes_with_categories and all(
+            len(dtype.categories) == len(all_categories)
+            and dtype.ordered
+            and np.all(all_categories == dtype.categories)
+            for dtype in dtypes_with_categories
+        ):
+            return dtypes_with_categories[0]
+
+        return object
 
-            if not ordered:
-                return pd.CategoricalDtype(natsorted(categories), ordered=False)
-            else:  # for xarray Datasets, see https://github.com/pydata/xarray/issues/10247
-                categories_intersection = reduce(
-                    lambda x, y: x.intersection(y),
-                    (
-                        dtype.categories
-                        for dtype in dtypes
-                        if not pd.isnull(dtype) and len(dtype.categories) > 0
-                    ),
-                )
-                if len(categories_intersection) < len(categories):
-                    return object
-                else:
-                    same_orders = all(
-                        dtype.ordered
-                        for dtype in dtypes
-                        if not pd.isnull(dtype) and len(dtype.categories) > 0
-                    )
-                    same_orders &= all(
-                        np.all(categories == dtype.categories)
-                        for dtype in dtypes
-                        if not pd.isnull(dtype) and len(dtype.categories) > 0
-                    )
-                    if same_orders:
-                        return next(
-                            dtype
-                            for dtype in dtypes
-                            if not pd.isnull(dtype) and len(dtype.categories) > 0
-                        )
-                    return object
     # Boolean
-    elif all(pd.api.types.is_bool_dtype(dtype) or dtype is None for dtype in col):
-        if any(dtype is None for dtype in col):
-            return pd.BooleanDtype()
-        else:
-            return None
-    else:
-        return None
+    if all(pd.api.types.is_bool_dtype(dtype) for dtype in dtypes) and has_missing:
+        return pd.BooleanDtype()
+
+    return None
 
 
 def check_combinable_cols(cols: list[pd.Index], join: Join_T):
@@ -1207,15 +1186,13 @@ def make_dask_col_from_extension_dtype(
     A :class:`dask.Array`: representation of the column.
     """
     import dask.array as da
-    import xarray as xr
-    from xarray.core.indexing import LazilyIndexedArray
 
     from anndata._io.specs.lazy_methods import (
         compute_chunk_layout_for_axis_size,
         get_chunksize,
         maybe_open_h5,
     )
-    from anndata.compat import XDataArray
+    from anndata.compat import xarray as xr
     from anndata.experimental import read_elem_lazy
 
     base_path_or_zarr_group = col.attrs.get("base_path_or_zarr_group")
@@ -1224,7 +1201,6 @@ def make_dask_col_from_extension_dtype(
         base_path_or_zarr_group is not None and elem_name is not None
     ):  # lazy, backed by store
         dims = col.dims
-        coords = col.coords.copy()
         with maybe_open_h5(base_path_or_zarr_group, elem_name) as f:
             maybe_chunk_size = get_chunksize(read_elem_lazy(f))
             chunk_size = (
@@ -1238,17 +1214,14 @@ def make_dask_col_from_extension_dtype(
             # reopening is important to get around h5py's unserializable lock in processes
             with maybe_open_h5(base_path_or_zarr_group, elem_name) as f:
                 v = read_elem_lazy(f)
-                variable = xr.Variable(data=LazilyIndexedArray(v), dims=dims)
-                data_array = XDataArray(
-                    variable,
-                    coords=coords,
-                    dims=dims,
+                variable = xr.Variable(
+                    data=xr.core.indexing.LazilyIndexedArray(v), dims=dims
                 )
                 idx = tuple(
                     slice(start, stop)
                     for start, stop in block_info[None]["array-location"]
                 )
-                chunk = np.array(data_array.data[idx])
+                chunk = np.array(variable.data[idx])
             return chunk
 
         if col.dtype == "category" or col.dtype == "string" or use_only_object_dtype:  # noqa PLR1714
@@ -1268,7 +1241,7 @@ def make_dask_col_from_extension_dtype(
 
 def make_xarray_extension_dtypes_dask(
     annotations: Iterable[Dataset2D], *, use_only_object_dtype: bool = False
-) -> Generator[XDataset, None, None]:
+) -> Generator[Dataset2D, None, None]:
     """
     Creates a generator of Dataset2D objects with dask arrays in place of :class:`pandas.api.extensions.ExtensionArray` dtype columns.
 
@@ -1710,6 +1683,9 @@ def concat(  # noqa: PLR0912, PLR0913, PLR0915
                 alt_annotations, use_only_object_dtype=True
             )
         )
+        for a in annotations_with_only_dask:
+            if a.true_index_dim != a.index_dim:
+                a.index = a.true_index
         annotations_with_only_dask = [
             a.ds.rename({a.true_index_dim: "merge_index"})
             for a in annotations_with_only_dask
@@ -1717,7 +1693,6 @@ def concat(  # noqa: PLR0912, PLR0913, PLR0915
         alt_annot = Dataset2D(
             xr.merge(annotations_with_only_dask, join=join, compat="override")
         )
-        alt_annot.true_index_dim = "merge_index"
 
     X = concat_Xs(adatas, reindexers, axis=axis, fill_value=fill_value)
 

anndata/_core/xarray.py

@@ -117,7 +117,8 @@ class Dataset2D:
 
     @property
     def true_index_dim(self) -> str:
-        """
+        """Key of the “true” index.
+
         Because xarray loads its coordinates/indexes in memory,
         we allow for signaling that a given variable, which is not a coordinate, is the "true" index.
 
@@ -130,7 +131,7 @@ class Dataset2D:
         return self.ds.attrs.get("indexing_key", self.index_dim)
 
     @true_index_dim.setter
-    def true_index_dim(self, val: str):
+    def true_index_dim(self, val: str | None) -> None:
         if val is None or (val == self.index_dim and "indexing_key" in self.ds.attrs):
             del self.ds.attrs["indexing_key"]
         elif val not in self.ds.dims:
@@ -146,8 +147,10 @@ class Dataset2D:
 
     @property
     def index(self) -> pd.Index:
-        """:attr:`~anndata.AnnData` internally looks for :attr:`~pandas.DataFrame.index` so this ensures usability
-        A :class:`pandas.Index` object corresponding to :attr:`anndata.experimental.backed.Dataset2D.index_dim`
+        """A :class:`pandas.Index` object corresponding to :attr:`anndata.experimental.backed.Dataset2D.index_dim`.
+
+        :attr:`~anndata.AnnData` internally looks for :attr:`~pandas.DataFrame.index` so this ensures usability.
+
         Returns
         -------
         The index of the of the dataframe as resolved from :attr:`~xarray.Dataset.coords`.
@@ -155,14 +158,26 @@ class Dataset2D:
         return self.ds.indexes[self.index_dim]
 
     @index.setter
-    def index(self, val) -> None:
+    def index(self, val: object | pd.Index | XDataArray) -> None:
         index_dim = self.index_dim
-        self.ds.coords[index_dim] = (index_dim, val)
-        if isinstance(val, pd.Index) and val.name is not None and val.name != index_dim:
-            self.ds.update(self.ds.rename({self.index_dim: val.name}))
-            del self.ds.coords[index_dim]
+        if (
+            isinstance(val, pd.Index | XDataArray)
+            and val.name is not None
+            and val.name != index_dim
+        ):
+            # swap the names of the dimensions out and drop the old index variable, setting `coords` in the process if `val` came from this dataset.
+            self._ds = self.ds.swap_dims({index_dim: val.name}).drop_vars(index_dim)
+            # swapping dims only changes the name, but not the underlying value i.e., the coordinate, if the underlying value was not present in the dataset.
+            # If we were to `__setitem__` on `.coords` without checking, `val` could have the old `index_dim` as its `name` because it was present in the dataset.
+            if val.name not in self.ds.coords:
+                self.ds.coords[val.name] = val
+            self._validate_shape_invariants(self._ds)
+        else:
+            self.ds.coords[index_dim] = (index_dim, val)
         # without `indexing_key` explicitly set on `self.ds.attrs`, `self.true_index_dim` will use the `self.index_dim`
-        if "indexing_key" in self.ds.attrs:
+        if "indexing_key" in self.ds.attrs and (
+            hasattr(val, "name") and val.name == self.ds.attrs["indexing_key"]
+        ):
             del self.ds.attrs["indexing_key"]
 
     @property
@@ -172,12 +187,14 @@ class Dataset2D:
 
     @property
     def true_index(self) -> pd.Index:
-        """:attr:`~anndata.experimental.backed.Dataset2D.true_xr_index` as a :class:`pandas.Index`"""
-        return self.true_xr_index.to_index()
+        """:attr:`~anndata.experimental.backed.Dataset2D.true_xr_index` as a :class:`pandas.Index`."""
+        idx = self.true_xr_index.to_index()
+        idx.name = self.true_xr_index.name
+        return idx
 
     @property
     def shape(self) -> tuple[int, int]:
-        """:attr:`~anndata.AnnData` internally looks for :attr:`~pandas.DataFrame.shape` so this ensures usability
+        """:attr:`~anndata.AnnData` internally looks for :attr:`~pandas.DataFrame.shape` so this ensures usability.
 
         Returns
         -------
@@ -187,7 +204,7 @@ class Dataset2D:
 
     @property
     def iloc(self) -> Dataset2DIlocIndexer:
-        """:attr:`~anndata.AnnData` internally looks for :attr:`~pandas.DataFrame.iloc` so this ensures usability
+        """:attr:`~anndata.AnnData` internally looks for :attr:`~pandas.DataFrame.iloc` so this ensures usability.
 
         Returns
         -------
@@ -268,6 +285,17 @@ class Dataset2D:
             columns.discard(index_key)
         return pd.Index(columns)
 
+    @columns.setter
+    def columns(self, val) -> None:
+        if len(self.columns.symmetric_difference(val)) > 0:
+            msg = "Trying to rename the keys of the mapping with new names - please use a different API to rename the keys of the underlying dataset mapping."
+            raise ValueError(msg)
+        warnings.warn(
+            "Renaming or reordering columns on `Dataset2D` has no effect because the underlying data structure has no apparent ordering on its keys",
+            UserWarning,
+            stacklevel=2,
+        )
+
     def __setitem__(
         self, key: Hashable | Iterable[Hashable] | Mapping, value: Any
     ) -> None:
@@ -348,9 +376,9 @@ class Dataset2D:
         return len(self.ds)
 
     @property
-    def dtypes(self) -> pd.Series:
+    def dtypes(self) -> Mapping[Hashable, np.dtype]:
         """
-        Return a Series with the dtypes of the variables in the Dataset2D.
+        Return a Mapping with the dtypes of the variables in the Dataset2D.
         """
         return self.ds.dtypes
 

anndata/_io/h5ad.py

@@ -172,9 +172,8 @@ def write_sparse_as_dense(
 def read_h5ad_backed(
     filename: str | PathLike[str], mode: Literal["r", "r+"]
 ) -> AnnData:
-    d = dict(filename=filename, filemode=mode)
-
     f = h5py.File(filename, mode)
+    d = dict(filename=f)
 
     attributes = ["obsm", "varm", "obsp", "varp", "uns", "layers"]
     df_attributes = ["obs", "var"]
@@ -191,6 +190,7 @@ def read_h5ad_backed(
     d["raw"] = _read_raw(f, attrs={"var", "varm"})
 
     adata = AnnData(**d)
+    assert adata.file._file is f
 
     # Backwards compat to <0.7
     if isinstance(f["obs"], h5py.Dataset):

anndata/_io/specs/lazy_methods.py

@@ -16,11 +16,12 @@ from anndata._core.xarray import Dataset2D, requires_xarray
 from anndata.abc import CSCDataset, CSRDataset
 from anndata.compat import (
     NULLABLE_NUMPY_STRING_TYPE,
+    NUMPY_2,
     DaskArray,
     H5Array,
     H5Group,
-    XDataArray,
     XDataset,
+    XVariable,
     ZarrArray,
     ZarrGroup,
 )
@@ -248,24 +249,18 @@ def _gen_xarray_dict_iterator_from_elems(
     elem_dict: dict[str, LazyDataStructures],
     dim_name: str,
     index: np.NDArray,
-) -> Generator[tuple[str, XDataArray], None, None]:
+) -> Generator[tuple[str, XVariable], None, None]:
     from anndata.experimental.backed._lazy_arrays import CategoricalArray, MaskedArray
 
-    from ...compat import XDataArray
     from ...compat import xarray as xr
 
     for k, v in elem_dict.items():
         if isinstance(v, DaskArray) and k != dim_name:
-            data_array = XDataArray(v, coords=[index], dims=[dim_name], name=k)
+            variable = xr.Variable([dim_name], data=v)
         elif isinstance(v, CategoricalArray | MaskedArray) and k != dim_name:
             variable = xr.Variable(
-                data=xr.core.indexing.LazilyIndexedArray(v), dims=[dim_name]
-            )
-            data_array = XDataArray(
-                variable,
-                coords=[index],
-                dims=[dim_name],
-                name=k,
+                [dim_name],
+                data=xr.core.indexing.LazilyIndexedArray(v),
                 attrs={
                     "base_path_or_zarr_group": v.base_path_or_zarr_group,
                     "elem_name": v.elem_name,
@@ -277,13 +272,11 @@ def _gen_xarray_dict_iterator_from_elems(
                 },
             )
         elif k == dim_name:
-            data_array = XDataArray(
-                index, coords=[index], dims=[dim_name], name=dim_name
-            )
+            variable = xr.Variable([dim_name], data=index)
         else:
             msg = f"Could not read {k}: {v} from into xarray Dataset2D"
             raise ValueError(msg)
-        yield k, data_array
+        yield k, variable
 
 
 DUMMY_RANGE_INDEX_KEY = "_anndata_dummy_range_index"
@@ -325,11 +318,9 @@ def read_dataframe(
         _gen_xarray_dict_iterator_from_elems(elem_dict, dim_name, index)
     )
     if use_range_index:
-        elem_xarray_dict[DUMMY_RANGE_INDEX_KEY] = XDataArray(
-            index,
-            coords=[index],
-            dims=[DUMMY_RANGE_INDEX_KEY],
-            name=DUMMY_RANGE_INDEX_KEY,
+        elem_xarray_dict[DUMMY_RANGE_INDEX_KEY] = XVariable(
+            [DUMMY_RANGE_INDEX_KEY],
+            data=index,
         )
     ds = Dataset2D(XDataset(elem_xarray_dict))
     ds.is_backed = True
@@ -377,9 +368,14 @@ def read_nullable(
         Path(filename(elem)) if isinstance(elem, H5Group) else elem
     )
     elem_name = get_elem_name(elem)
+    values = elem["values"]
+    # HDF5 stores strings as bytes; use .astype("T") to decode on access
+    # h5py recommends .astype("T") over .asstr() when using numpy ≥2
+    if encoding_type == "nullable-string-array" and isinstance(elem, H5Group):
+        values = values.astype("T") if NUMPY_2 else values.asstr()
     return MaskedArray(
-        values=elem["values"],
-        mask=elem.get("mask", None),
+        values=values,
+        mask=elem["mask"],
         dtype_str=encoding_type,
         base_path_or_zarr_group=base_path_or_zarr_group,
         elem_name=elem_name,

anndata/_io/specs/methods.py

@@ -95,9 +95,21 @@ GLOBAL_LOCK = Lock()
 #     return False
 
 
-def zarr_v3_compressor_compat(dataset_kwargs) -> dict:
-    if not is_zarr_v2() and (compressor := dataset_kwargs.pop("compressor", None)):
-        dataset_kwargs["compressors"] = compressor
+def zarr_v3_compressor_compat(dataset_kwargs: dict) -> dict:
+    """Handle mismatch between our compressor kwarg and :func:`zarr.create_array` in v3's `compressors` arg
+    See https://zarr.readthedocs.io/en/stable/api/zarr/create/#zarr.create_array
+
+    Parameters
+    ----------
+    dataset_kwarg
+        The kwarg dict potentially containing "compressor"
+
+    Returns
+    -------
+        The kwarg dict with "compressor" moved to "compressors" if zarr v3 is in use.
+    """
+    if not is_zarr_v2() and "compressor" in dataset_kwargs:
+        dataset_kwargs["compressors"] = dataset_kwargs.pop("compressor")
     return dataset_kwargs
 
 
@@ -1098,7 +1110,10 @@ def write_categorical(
 
     _writer.write_elem(g, "codes", v.codes, dataset_kwargs=dataset_kwargs)
     _writer.write_elem(
-        g, "categories", v.categories._values, dataset_kwargs=dataset_kwargs
+        g,
+        "categories",
+        v.categories.to_numpy(),
+        dataset_kwargs=dataset_kwargs,
     )
 
 

anndata/_io/utils.py

@@ -1,17 +1,22 @@
 from __future__ import annotations
 
 from collections.abc import Callable
-from functools import WRAPPER_ASSIGNMENTS, wraps
+from functools import WRAPPER_ASSIGNMENTS, cache, wraps
 from itertools import pairwise
 from typing import TYPE_CHECKING, Literal, cast
 from warnings import warn
 
+import numpy as np
+import pandas as pd
+
 from .._core.sparse_dataset import BaseCompressedSparseDataset
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Mapping
     from typing import Any, Literal
 
+    from pandas.core.dtypes.dtypes import BaseMaskedDtype
+
     from .._types import StorageType, _WriteInternal
     from ..compat import H5Group, ZarrGroup
     from ..typing import RWAble
@@ -119,6 +124,30 @@ def check_key(key):
         raise TypeError(msg)
 
 
+@cache
+def pandas_nullable_dtype(dtype: np.dtype) -> BaseMaskedDtype:
+    """Infer nullable dtype from numpy dtype.
+
+    There is no public pandas API for this, so this is the cleanest way.
+    See <https://github.com/pandas-dev/pandas/issues/63608>
+    """
+    try:
+        from pandas.core.dtypes.dtypes import BaseMaskedDtype
+    except ImportError:
+        pass
+    else:
+        return BaseMaskedDtype.from_numpy_dtype(dtype)
+
+    match dtype.kind:
+        case "b":
+            array_type = pd.arrays.BooleanArray
+        case "i" | "u":
+            array_type = pd.arrays.IntegerArray
+        case _:
+            raise NotImplementedError
+    return array_type(np.ones(1, dtype), np.ones(1, bool)).dtype
+
+
 # -------------------------------------------------------------------------------
 # Generic functions
 # -------------------------------------------------------------------------------

anndata/_io/zarr.py

@@ -150,8 +150,12 @@ def read_dataframe(group: zarr.Group | zarr.Array) -> pd.DataFrame:
 def open_write_group(
     store: StoreLike, *, mode: AccessModeLiteral = "w", **kwargs
 ) -> zarr.Group:
-    if not is_zarr_v2() and "zarr_format" not in kwargs:
-        kwargs["zarr_format"] = settings.zarr_write_format
+    if "zarr_format" not in kwargs:
+        if settings.zarr_write_format == 2 or is_zarr_v2():
+            msg = "Writing zarr v2 data will no longer be the default in the next minor release. v3 data will be written by default. If you are explicitly setting this configuration, consider migrating to the zarr v3 file format."
+            warn(msg, UserWarning, stacklevel=2)
+        if not is_zarr_v2():
+            kwargs["zarr_format"] = settings.zarr_write_format
     return zarr.open_group(store, mode=mode, **kwargs)
 
 

anndata/compat/__init__.py

@@ -51,6 +51,7 @@ Index1D = (
     | Sequence[bool]
     | pd.Series  # bool, int, str
     | pd.Index
+    | pd.api.extensions.ExtensionArray  # bool | int | str
     | NDArray[np.str_]
     | np.matrix  # bool
     | CSMatrix  # bool
@@ -71,6 +72,26 @@ H5Group = h5py.Group
 H5Array = h5py.Dataset
 H5File = h5py.File
 
+# h5py recommends using .astype("T") over .asstr() when using numpy ≥2
+if TYPE_CHECKING:
+    from h5py._hl.dataset import AsStrView as H5AsStrView
+    from h5py._hl.dataset import AsTypeView as H5AsTypeView
+else:
+    try:
+        try:
+            from h5py._hl.dataset import AsStrView as H5AsStrView
+            from h5py._hl.dataset import AsTypeView as H5AsTypeView
+        except ImportError:
+            # h5py 3.11 uses AsStrWrapper/AstypeWrapper (lowercase 't')
+            from h5py._hl.dataset import AsStrWrapper as H5AsStrView
+            from h5py._hl.dataset import AstypeWrapper as H5AsTypeView
+    except ImportError:  # pragma: no cover
+        warn("AsTypeView changed import location", DeprecationWarning, stacklevel=1)
+        _ds = h5py.File.in_memory().create_dataset("x", shape=(), dtype="S1")
+        H5AsStrView = type(_ds.asstr())
+        H5AsTypeView = type(_ds.astype("U1"))
+        del _ds
+
 
 #############################
 # Optional deps
@@ -209,11 +230,10 @@ else:
 # IO helpers
 #############################
 
+NUMPY_2 = Version(version("numpy")) >= Version("2")
 
 NULLABLE_NUMPY_STRING_TYPE = (
-    np.dtype("O")
-    if Version(version("numpy")) < Version("2")
-    else np.dtypes.StringDType(na_object=pd.NA)
+    np.dtypes.StringDType(na_object=pd.NA) if NUMPY_2 else np.dtype("O")
 )
 
 PANDAS_SUPPORTS_NA_VALUE = Version(version("pandas")) >= Version("2.3")

anndata/experimental/backed/_io.py

@@ -59,19 +59,25 @@ def read_lazy(
     Preparing example objects
 
     >>> import anndata as ad
-    >>> from urllib.request import urlretrieve
+    >>> import pooch
     >>> import scanpy as sc
     >>> base_url = "https://datasets.cellxgene.cziscience.com"
-    >>> def get_cellxgene_data(id_: str):
-    ...     out_path = sc.settings.datasetdir / f"{id_}.h5ad"
-    ...     if out_path.exists():
-    ...         return out_path
-    ...     file_url = f"{base_url}/{id_}.h5ad"
-    ...     sc.settings.datasetdir.mkdir(parents=True, exist_ok=True)
-    ...     urlretrieve(file_url, out_path)
-    ...     return out_path
-    >>> path_b_cells = get_cellxgene_data("a93eab58-3d82-4b61-8a2f-d7666dcdb7c4")
-    >>> path_fetal = get_cellxgene_data("d170ff04-6da0-4156-a719-f8e1bbefbf53")
+    >>> # To update hashes: pooch.retrieve(url, known_hash=None) prints the new hash
+    >>> def get_cellxgene_data(id_: str, hash_: str):
+    ...     return pooch.retrieve(
+    ...         f"{base_url}/{id_}.h5ad",
+    ...         known_hash=hash_,
+    ...         fname=f"{id_}.h5ad",
+    ...         path=sc.settings.datasetdir,
+    ...     )
+    >>> path_b_cells = get_cellxgene_data(
+    ...     "a93eab58-3d82-4b61-8a2f-d7666dcdb7c4",
+    ...     "sha256:dac90fe2aa8b78aee2c1fc963104592f8eff7b873ca21d01a51a5e416734651c",
+    ... )
+    >>> path_fetal = get_cellxgene_data(
+    ...     "d170ff04-6da0-4156-a719-f8e1bbefbf53",
+    ...     "sha256:d497eebca03533919877b6fc876e8c9d8ba063199ddc86dd9fbcb9d1d87a3622",
+    ... )
     >>> b_cells_adata = ad.experimental.read_lazy(path_b_cells)
     >>> fetal_adata = ad.experimental.read_lazy(path_fetal)
     >>> print(b_cells_adata)

anndata/experimental/backed/_lazy_arrays.py

@@ -10,10 +10,13 @@ from anndata._core.index import _subset
 from anndata._core.views import as_view
 from anndata._io.specs.lazy_methods import get_chunksize
 
+from ..._io.utils import pandas_nullable_dtype
 from ..._settings import settings
 from ...compat import (
     NULLABLE_NUMPY_STRING_TYPE,
     H5Array,
+    H5AsStrView,
+    H5AsTypeView,
     XBackendArray,
     XDataArray,
     XZarrArrayWrapper,
@@ -24,8 +27,9 @@ if TYPE_CHECKING:
     from pathlib import Path
     from typing import Literal
 
+    from numpy.typing import NDArray
     from pandas._libs.missing import NAType
-    from pandas.core.dtypes.base import ExtensionDtype
+    from pandas.core.dtypes.dtypes import BaseMaskedDtype
 
     from anndata.compat import ZarrGroup
 
@@ -36,12 +40,13 @@ if TYPE_CHECKING:
         from xarray.core.indexing import ExplicitIndexer
 
 
-K = TypeVar("K", H5Array, ZarrArray)
+K = TypeVar("K", H5Array | H5AsStrView | H5AsTypeView, ZarrArray)
 
 
 class ZarrOrHDF5Wrapper(XZarrArrayWrapper, Generic[K]):
-    def __init__(self, array: K):
-        self.chunks = array.chunks
+    def __init__(self, array: K) -> None:
+        # AstypeView from h5py .astype() lacks chunks attribute
+        self.chunks = getattr(array, "chunks", None)
         if isinstance(array, ZarrArray):
             super().__init__(array)
             return
@@ -73,7 +78,7 @@ class ZarrOrHDF5Wrapper(XZarrArrayWrapper, Generic[K]):
         if (
             isinstance(key, np.ndarray)
             and np.issubdtype(key.dtype, np.integer)
-            and isinstance(self._array, H5Array)
+            and isinstance(self._array, H5Array | H5AsTypeView | H5AsStrView)
         ):
             key_mask = np.zeros(self._array.shape).astype("bool")
             key_mask[key] = True
@@ -89,7 +94,7 @@ class CategoricalArray(XBackendArray, Generic[K]):
     """
 
     _codes: ZarrOrHDF5Wrapper[K]
-    _categories: ZarrArray | H5Array
+    _categories: K
     shape: tuple[int, ...]
     base_path_or_zarr_group: Path | ZarrGroup
     elem_name: str
@@ -97,7 +102,7 @@ class CategoricalArray(XBackendArray, Generic[K]):
     def __init__(
         self,
         codes: K,
-        categories: ZarrArray | H5Array,
+        categories: K,
         base_path_or_zarr_group: Path | ZarrGroup,
         elem_name: str,
         *args,
@@ -153,11 +158,11 @@ class MaskedArray(XBackendArray, Generic[K]):
 
     def __init__(
         self,
-        values: ZarrArray | H5Array,
+        values: K,
         dtype_str: Literal[
             "nullable-integer", "nullable-boolean", "nullable-string-array"
         ],
-        mask: ZarrArray | H5Array,
+        mask: K,
         base_path_or_zarr_group: Path | ZarrGroup,
         elem_name: str,
     ):
@@ -169,40 +174,33 @@ class MaskedArray(XBackendArray, Generic[K]):
         self.file_format = "zarr" if isinstance(mask, ZarrArray) else "h5"
         self.elem_name = elem_name
 
-    def __getitem__(self, key: ExplicitIndexer) -> PandasExtensionArray | np.ndarray:
-        from xarray.core.extension_array import PandasExtensionArray
-
+    def __getitem__(
+        self, key: ExplicitIndexer
+    ) -> PandasExtensionArray | NDArray[np.str_]:
         values = self._values[key]
         mask = self._mask[key]
-        if self._dtype_str == "nullable-integer":
-            # numpy does not support nan ints
-            extension_array = pd.arrays.IntegerArray(values, mask=mask)
-        elif self._dtype_str == "nullable-boolean":
-            extension_array = pd.arrays.BooleanArray(values, mask=mask)
-        elif self._dtype_str == "nullable-string-array":
+
+        if isinstance(self.dtype, np.dtypes.StringDType):
             # https://github.com/pydata/xarray/issues/10419
             values = values.astype(self.dtype)
             values[mask] = pd.NA
             return values
-        else:
-            msg = f"Invalid dtype_str {self._dtype_str}"
-            raise RuntimeError(msg)
-        return PandasExtensionArray(extension_array)
+
+        from xarray.core.extension_array import PandasExtensionArray
+
+        cls = self.dtype.construct_array_type()
+        return PandasExtensionArray(cls(values, mask))
 
     @cached_property
-    def dtype(self) -> np.dtypes.StringDType[NAType] | ExtensionDtype:
-        if self._dtype_str == "nullable-integer":
-            return pd.array(
-                [],
-                dtype=str(pd.api.types.pandas_dtype(self._values.dtype)).capitalize(),
-            ).dtype
-        elif self._dtype_str == "nullable-boolean":
-            return pd.BooleanDtype()
-        elif self._dtype_str == "nullable-string-array":
+    def dtype(self) -> BaseMaskedDtype | np.dtypes.StringDType[NAType]:
+        if self._dtype_str == "nullable-string-array":
             # https://github.com/pydata/xarray/issues/10419
             return NULLABLE_NUMPY_STRING_TYPE
-        msg = f"Invalid dtype_str {self._dtype_str}"
-        raise RuntimeError(msg)
+        try:
+            return pandas_nullable_dtype(self._values.dtype)
+        except NotImplementedError:
+            msg = f"Invalid dtype_str {self._dtype_str}"
+            raise RuntimeError(msg) from None
 
 
 @_subset.register(XDataArray)

anndata/experimental/merge.py

@@ -551,19 +551,25 @@ def concat_on_disk(  # noqa: PLR0913
 
     First, let’s get some “big” datasets with a compatible ``var`` axis:
 
-    >>> import httpx
+    >>> import pooch
     >>> import scanpy as sc
     >>> base_url = "https://datasets.cellxgene.cziscience.com"
-    >>> def get_cellxgene_data(id_: str):
-    ...     out_path = sc.settings.datasetdir / f'{id_}.h5ad'
-    ...     if out_path.exists():
-    ...         return out_path
-    ...     file_url = f"{base_url}/{id_}.h5ad"
-    ...     sc.settings.datasetdir.mkdir(parents=True, exist_ok=True)
-    ...     out_path.write_bytes(httpx.get(file_url).content)
-    ...     return out_path
-    >>> path_b_cells = get_cellxgene_data('a93eab58-3d82-4b61-8a2f-d7666dcdb7c4')
-    >>> path_fetal = get_cellxgene_data('d170ff04-6da0-4156-a719-f8e1bbefbf53')
+    >>> # To update hashes: pooch.retrieve(url, known_hash=None) prints the new hash
+    >>> def get_cellxgene_data(id_: str, hash_: str):
+    ...     return pooch.retrieve(
+    ...         f"{base_url}/{id_}.h5ad",
+    ...         known_hash=hash_,
+    ...         fname=f"{id_}.h5ad",
+    ...         path=sc.settings.datasetdir,
+    ...     )
+    >>> path_b_cells = get_cellxgene_data(
+    ...     'a93eab58-3d82-4b61-8a2f-d7666dcdb7c4',
+    ...     'sha256:dac90fe2aa8b78aee2c1fc963104592f8eff7b873ca21d01a51a5e416734651c',
+    ... )
+    >>> path_fetal = get_cellxgene_data(
+    ...     'd170ff04-6da0-4156-a719-f8e1bbefbf53',
+    ...     'sha256:d497eebca03533919877b6fc876e8c9d8ba063199ddc86dd9fbcb9d1d87a3622',
+    ... )
 
     Now we can concatenate them on-disk:
 
@@ -613,10 +619,10 @@ def concat_on_disk(  # noqa: PLR0913
 
     if (
         len(in_files) == 1
-        and isinstance(in_files[0], str | PathLike)
+        and isinstance(in_file := in_files[0], str | PathLike)
         and is_out_path_like
     ):
-        shutil.copy2(in_files[0], out_file)
+        (shutil.copytree if in_file.is_dir() else shutil.copy2)(in_file, out_file)
         return
 
     if keys is None:

anndata/tests/helpers.py

@@ -75,12 +75,13 @@ DEFAULT_KEY_TYPES = (
 DEFAULT_COL_TYPES = (
     pd.CategoricalDtype(ordered=False),
     pd.CategoricalDtype(ordered=True),
-    np.int64,
-    np.float64,
-    np.uint8,
-    np.bool_,
-    pd.BooleanDtype,
-    pd.Int32Dtype,
+    np.dtype(np.int64),
+    np.dtype(np.float64),
+    np.dtype(np.uint8),
+    np.dtype(bool),
+    pd.BooleanDtype(),
+    pd.Int32Dtype(),
+    pd.UInt8Dtype(),
 )
 
 
@@ -108,13 +109,11 @@ def gen_vstr_recarray(m, n, dtype=None):
 
 
 def issubdtype(
-    a: np.dtype | pd.api.extensions.ExtensionDtype | type,
-    b: type[DT] | tuple[type[DT], ...],
+    a: np.dtype | pd.api.extensions.ExtensionDtype, b: type[DT] | tuple[type[DT], ...]
 ) -> TypeGuard[DT]:
+    assert not isinstance(a, type)
     if isinstance(b, tuple):
         return any(issubdtype(a, t) for t in b)
-    if isinstance(a, type) and issubclass(a, pd.api.extensions.ExtensionDtype):
-        return issubclass(a, b)
     if isinstance(a, pd.api.extensions.ExtensionDtype):
         return isinstance(a, b)
     try:
@@ -126,6 +125,7 @@ def issubdtype(
 def gen_random_column(  # noqa: PLR0911
     n: int, dtype: np.dtype | pd.api.extensions.ExtensionDtype
 ) -> tuple[str, np.ndarray | pd.api.extensions.ExtensionArray]:
+    assert isinstance(dtype, np.dtype | pd.api.extensions.ExtensionDtype)
     if issubdtype(dtype, pd.CategoricalDtype):
         # TODO: Think about allowing index to be passed for n
         letters = np.fromiter(iter(ascii_letters), "U1")
@@ -142,13 +142,9 @@ def gen_random_column(  # noqa: PLR0911
             ),
         )
     if issubdtype(dtype, IntegerDtype):
-        return (
-            "nullable-int",
-            pd.arrays.IntegerArray(
-                np.random.randint(0, 1000, size=n, dtype=np.int32),
-                mask=np.random.randint(0, 2, size=n, dtype=bool),
-            ),
-        )
+        name, values = gen_random_column(n, dtype.numpy_dtype)
+        mask = np.random.randint(0, 2, size=n, dtype=bool)
+        return f"nullable-{name}", pd.arrays.IntegerArray(values, mask)
     if issubdtype(dtype, pd.StringDtype):
         letters = np.fromiter(iter(ascii_letters), "U1")
         array = pd.array(np.random.choice(letters, n), dtype=pd.StringDtype())
@@ -162,7 +158,7 @@ def gen_random_column(  # noqa: PLR0911
     if not issubdtype(dtype, np.number):  # pragma: no cover
         pytest.fail(f"Unexpected dtype: {dtype}")
 
-    n_bits = 8 * (dtype().itemsize if isinstance(dtype, type) else dtype.itemsize)
+    n_bits = 8 * dtype.itemsize
 
     if issubdtype(dtype, np.unsignedinteger):
         return f"uint{n_bits}", np.random.randint(0, 255, n, dtype=dtype)

{anndata-0.12.7.dist-info → anndata-0.12.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anndata
-Version: 0.12.7
+Version: 0.12.8
 Summary: Annotated data.
 Project-URL: Documentation, https://anndata.readthedocs.io/
 Project-URL: Source, https://github.com/scverse/anndata
@@ -74,11 +74,11 @@ Requires-Dist: boltons; extra == 'test'
 Requires-Dist: dask[array]!=2024.8.*,!=2024.9.*,!=2025.2.*,!=2025.3.*,!=2025.4.*,!=2025.5.*,!=2025.6.*,!=2025.7.*,!=2025.8.*,>=2023.5.1; extra == 'test'
 Requires-Dist: dask[distributed]; extra == 'test'
 Requires-Dist: filelock; extra == 'test'
-Requires-Dist: httpx<1.0; extra == 'test'
 Requires-Dist: joblib; extra == 'test'
 Requires-Dist: loompy>=3.0.5; extra == 'test'
 Requires-Dist: matplotlib; extra == 'test'
 Requires-Dist: openpyxl; extra == 'test'
+Requires-Dist: pooch; extra == 'test'
 Requires-Dist: pyarrow; extra == 'test'
 Requires-Dist: pytest; extra == 'test'
 Requires-Dist: pytest-cov; extra == 'test'
@@ -96,11 +96,11 @@ Requires-Dist: boltons; extra == 'test-min'
 Requires-Dist: dask[array]!=2024.8.*,!=2024.9.*,!=2025.2.*,!=2025.3.*,!=2025.4.*,!=2025.5.*,!=2025.6.*,!=2025.7.*,!=2025.8.*,>=2023.5.1; extra == 'test-min'
 Requires-Dist: dask[distributed]; extra == 'test-min'
 Requires-Dist: filelock; extra == 'test-min'
-Requires-Dist: httpx<1.0; extra == 'test-min'
 Requires-Dist: joblib; extra == 'test-min'
 Requires-Dist: loompy>=3.0.5; extra == 'test-min'
 Requires-Dist: matplotlib; extra == 'test-min'
 Requires-Dist: openpyxl; extra == 'test-min'
+Requires-Dist: pooch; extra == 'test-min'
 Requires-Dist: pyarrow; extra == 'test-min'
 Requires-Dist: pytest; extra == 'test-min'
 Requires-Dist: pytest-cov; extra == 'test-min'

{anndata-0.12.7.dist-info → anndata-0.12.8.dist-info}/RECORD

@@ -13,45 +13,45 @@ anndata/_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 anndata/_core/access.py,sha256=pts7fGUKgGZANSsu_qAA7L10qHM-jT1zIehbl3441OY,873
 anndata/_core/aligned_df.py,sha256=bM9kkEFURRLeUOUMk90WxVnRC-ZsXGEDx36kDj5gC9I,4278
 anndata/_core/aligned_mapping.py,sha256=BYU1jslMWIhtFTtUMaXY8ZCyt0J4_ZsJTmj6J2yAXTQ,14257
-anndata/_core/anndata.py,sha256=e_IgHjIpXPQPJqakeH83bl8Quu9T0N--Mb_QHINayv4,79276
+anndata/_core/anndata.py,sha256=s-ExKqeQXuvin9dk0vKa1GLx6tRvrAX5HlvmqRR9uRw,79455
 anndata/_core/extensions.py,sha256=9Rsho6qnr3PJHULrYGiZHCBinBZYJK6zyf3cFsl_gBY,10425
 anndata/_core/file_backing.py,sha256=6DhBfLQPDFDpoe6wSgnOFtpC4Hnbh-UgOPbqvYDxm8g,5603
-anndata/_core/index.py,sha256=F3TQBUbWpt09Pb4MpwB7xfCI9uPuv7jrqx8X74CwVDU,13472
-anndata/_core/merge.py,sha256=wFsUotHnQsnFp84UoCp78XMw3zVfvUH5eIi-8hkb7zo,60880
+anndata/_core/index.py,sha256=dz2jhrklxsNIDN-q0WhiXhxwtOreK-T8Iate-MGXpH0,13350
+anndata/_core/merge.py,sha256=xtVLQzUIUiIv3seNWtMmURaxkJ1X4LXSzHCP_m_HJCs,59738
 anndata/_core/raw.py,sha256=x_PwwaDQscVQOFJ38kF7sNQ47LxowpS38h2RQfU5Zwo,7925
 anndata/_core/sparse_dataset.py,sha256=R2BeSLiREiwk9FNjdLCR3VfbYatz-7BK0l2F9XqCiTk,27280
 anndata/_core/storage.py,sha256=mHzqp7YBJ-rGQFulMAx__D-Z7y4omHPyb1cP7YxfbFE,2555
 anndata/_core/views.py,sha256=-tiUwugw0bRYXzewruhU0xXT7nnDLdYf4CiFByLl34w,15067
-anndata/_core/xarray.py,sha256=0de8K7YjG9mnT-dFSRoxVxgwQktjrGI9n5Yy-1YJSHg,16624
+anndata/_core/xarray.py,sha256=XKpmkp9IyMuMAFI9ho5PoKKQSx9vX-Gau_k6moHJQ5w,18095
 anndata/_io/__init__.py,sha256=GTNeUZ8d8aA3sK4P33tyljIc60KapLbkqBC6J1y3l9U,346
-anndata/_io/h5ad.py,sha256=JT5DxTXXibz2jh1mjaQB3_0QYdhJ3gv4IcWLPjKD-dw,13976
+anndata/_io/h5ad.py,sha256=IPM2WrS6Xg2-LRkya3uVeNdCBcjQlxEFKHYdcGItg9c,13986
 anndata/_io/read.py,sha256=Z0QdFkaaXmGo5a25O9N9Ej2v8U7b9oV9Umw98YtB5uA,15950
-anndata/_io/utils.py,sha256=3Lg27Q0Uo3HYlz980bG2Y02_VFIt0PiXMNIj_o-mgC4,9490
+anndata/_io/utils.py,sha256=RqD5JAiGtfQmxxsmr3GSg4i0Oq2XckK1MhttjdsoFLM,10309
 anndata/_io/write.py,sha256=r55w6yPIIuUSLW9wyYL8GnkzHHQdAxy6xiCEw9cAC38,4811
-anndata/_io/zarr.py,sha256=Z996SZ8LV1Fpa_q8o70vHnBzNLOLlVjhf_Rs5EM_Slo,5461
+anndata/_io/zarr.py,sha256=k0hhYKxf7FwgpYUyDFwfpLOrWTjx5BDW1XUX6c8xhcs,5813
 anndata/_io/specs/__init__.py,sha256=Z6l8xqa7B480U3pqrNIg4-fhUvpBW85w4xA3i3maAUM,427
-anndata/_io/specs/lazy_methods.py,sha256=aCdmmYLrOHlMyT18t3sLE2I51YGT-jDna2F3m7b_kv0,13093
-anndata/_io/specs/methods.py,sha256=awmdbUMAP9Xjkid56LAbyWNQfKcCOrkx0BeQ6CDKek4,46422
+anndata/_io/specs/lazy_methods.py,sha256=ueV9ICJ87a-mY3fTTaYd98ug7JwOh4dfJY4bQj_HU8c,13055
+anndata/_io/specs/methods.py,sha256=jB0qq-f4UxppfbvhoFAbYVBE6Nz3u-UIfFuqM7BwOiw,46870
 anndata/_io/specs/registry.py,sha256=6Z_ffk3uOIagzRPcDCvEoszcgD-U3n8wYnGiPA71ZeI,17539
-anndata/compat/__init__.py,sha256=9696gHdOUz2yKih9epmT8WGSr6UX0pI8dJYTrqn0SJQ,14968
+anndata/compat/__init__.py,sha256=fvdnMtf7mhkK5nPXvWvQI-H7mWb016sKqVJ4pEVKUL4,15959
 anndata/experimental/__init__.py,sha256=polIxriEkby0iEqw-IXkUzp8k0wp92BpYY4zl4BsHH0,1648
 anndata/experimental/_dispatch_io.py,sha256=gb9JUcgS1cIERjxM1PBpWDXfPkKgMevoLF0QInZfC-g,1858
-anndata/experimental/merge.py,sha256=gWBS4HSkG8E3seIs2AS7jqqFc0Zp6JW94KWtNXApafg,24882
+anndata/experimental/merge.py,sha256=b9rrAtE0t5UzcUulc9mXH9u7RW68p_SYIFPJOqUxSNY,25120
 anndata/experimental/backed/__init__.py,sha256=4dc9M_-_SlfUidDrbWt8PRyD_8bYjypHJ86IpdThHus,230
 anndata/experimental/backed/_compat.py,sha256=rM7CnSJEZCko5wPBFRfvZA9ZKUSpaOVcWFy5u09p1go,519
-anndata/experimental/backed/_io.py,sha256=YM5FL6sKdLyQTHUa43cF0pDNbyj2xD9X7lzUiQesV20,6681
-anndata/experimental/backed/_lazy_arrays.py,sha256=8vcu7eyoRRlzNXyAzuY0s9CqEZCOAYoZIo-iI5d71_g,7805
+anndata/experimental/backed/_io.py,sha256=fG_KkGVxnqK0VukiMGYHSKasSiurFLKeWqyKftJnblw,6861
+anndata/experimental/backed/_lazy_arrays.py,sha256=mwcovT31AoXdVfoeyoNzmqCXL1SSmKF33hYK8ftUxM0,7509
 anndata/experimental/multi_files/__init__.py,sha256=T7iNLlRbe-KnLT3o7Tb7_nE4Iy_hLkG66UjBOvj2Bj8,107
 anndata/experimental/multi_files/_anncollection.py,sha256=Ra8A4MzyFWlid5RJd0cc2d4SJeSZ2HXz3odKSqAbChw,35264
 anndata/experimental/pytorch/__init__.py,sha256=4CkgrahLO8Kc-s2bmv6lVQfDxbO3IUyV0v4ygBDkttY,95
 anndata/experimental/pytorch/_annloader.py,sha256=7mpsFV5vBfxKIje1cPjahtDZ5afkU-H663XB4FJhmok,8075
 anndata/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-anndata/tests/helpers.py,sha256=BORIeSbcD0R_PDzi1IeR252it-aq6bL8fGN-bDR-Q1I,37689
+anndata/tests/helpers.py,sha256=9Tpt8QMZig7ggMFQGI2hDZE2u6IxQtVOEJXDZB3j1Ao,37638
 testing/anndata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 testing/anndata/_doctest.py,sha256=Qew0N0zLLNiPKN1CLunqY5cTinFLaEhY5GagiYfm6KI,344
 testing/anndata/_pytest.py,sha256=C_R-N2x9NHKZ66YLkvMLWkXQG1WiouOkBnLQpYx_62Q,3994
 testing/anndata/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-anndata-0.12.7.dist-info/METADATA,sha256=LQgLMW_q9Q4V4k0yBNpYNCPnPSUCxzyubwSDxR_RqTE,9939
-anndata-0.12.7.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-anndata-0.12.7.dist-info/licenses/LICENSE,sha256=VcrXoEVMhtNuvMvKYGP-I5lMT8qZ_6dFf22fsL180qA,1575
-anndata-0.12.7.dist-info/RECORD,,
+anndata-0.12.8.dist-info/METADATA,sha256=rlyz7u-gJSRMTRJSDWO-wGdsBzt7L59gVK__C_BAqko,9931
+anndata-0.12.8.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+anndata-0.12.8.dist-info/licenses/LICENSE,sha256=VcrXoEVMhtNuvMvKYGP-I5lMT8qZ_6dFf22fsL180qA,1575
+anndata-0.12.8.dist-info/RECORD,,