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

anndata/_core/aligned_df.py

@@ -9,7 +9,7 @@ import pandas as pd
 from pandas.api.types import is_string_dtype
 
 from .._warnings import ImplicitModificationWarning
-from ..compat import XDataset
+from ..compat import XDataset, pandas_as_str
 from .xarray import Dataset2D
 
 if TYPE_CHECKING:
@@ -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 anno else [],
+            columns=None if anno else pd.array([], dtype="str"),
         )
 
     if length is None:
@@ -88,12 +88,12 @@ def _gen_dataframe_df(
     if length is not None and length != len(anno):
         raise _mk_df_error(source, attr, length, len(anno))
     anno = anno.copy(deep=False)
-    if not is_string_dtype(anno.index):
+    if not is_string_dtype(anno.index[~anno.index.isna()]):
         msg = "Transforming to str index."
         warnings.warn(msg, ImplicitModificationWarning, stacklevel=2)
-        anno.index = anno.index.astype(str)
+        anno.index = pandas_as_str(anno.index)
     if not len(anno.columns):
-        anno.columns = anno.columns.astype(str)
+        anno.columns = pandas_as_str(anno.columns)
     return anno
 
 

anndata/_core/anndata.py

@@ -26,7 +26,14 @@ from anndata._warnings import ImplicitModificationWarning
 
 from .. import utils
 from .._settings import settings
-from ..compat import CSArray, DaskArray, ZarrArray, _move_adj_mtx, old_positionals
+from ..compat import (
+    CSArray,
+    DaskArray,
+    ZarrArray,
+    _move_adj_mtx,
+    old_positionals,
+    pandas_as_str,
+)
 from ..logging import anndata_logger as logger
 from ..utils import (
     axis_len,
@@ -48,7 +55,7 @@ from .xarray import Dataset2D
 if TYPE_CHECKING:
     from collections.abc import Iterable
     from os import PathLike
-    from typing import Any, ClassVar, Literal
+    from typing import Any, ClassVar, Literal, NoReturn
 
     from zarr.storage import StoreLike
 
@@ -383,11 +390,11 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):  # noqa: PLW1641
                 if obs is None:
                     obs = pd.DataFrame(index=X.index)
                 elif not isinstance(X.index, pd.RangeIndex):
-                    x_indices.append(("obs", "index", X.index.astype(str)))
+                    x_indices.append(("obs", "index", pandas_as_str(X.index)))
                 if var is None:
                     var = pd.DataFrame(index=X.columns)
                 elif not isinstance(X.columns, pd.RangeIndex):
-                    x_indices.append(("var", "columns", X.columns.astype(str)))
+                    x_indices.append(("var", "columns", pandas_as_str(X.columns)))
                 X = ensure_df_homogeneous(X, "X")
 
         # ----------------------------------------------------------------------
@@ -790,7 +797,9 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):  # noqa: PLW1641
             )
             raise ValueError(msg)
         else:
-            value = pd.Index(value)
+            value = (
+                value if isinstance(value, pd.Index) else pandas_as_str(pd.Index(value))
+            )
             if not isinstance(value.name, str | type(None)):
                 value.name = None
         if (
@@ -1058,6 +1067,7 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):  # noqa: PLW1641
             if not isinstance(df_full[k].dtype, pd.CategoricalDtype):
                 continue
             all_categories = df_full[k].cat.categories
+            # TODO: this mode is going away
             with pd.option_context("mode.chained_assignment", None):
                 df_sub[k] = df_sub[k].cat.remove_unused_categories()
             # also correct the colors...
@@ -1627,8 +1637,8 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):  # noqa: PLW1641
         annoA-1  NaN  2.0  1.0  0.0
         annoA-2  NaN  3.0  2.0  0.0
         annoB-2  NaN  2.0  1.0  0.0
-        >>> outer.var_names
-        Index(['a', 'b', 'c', 'd'], dtype='object')
+        >>> outer.var_names.astype("string")
+        Index(['a', 'b', 'c', 'd'], dtype='string')
         >>> outer.X
         array([[ 1.,  2.,  3., nan],
                [ 4.,  5.,  6., nan],
@@ -1710,8 +1720,8 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):  # noqa: PLW1641
         ...     dict(var_names=['d', 'c', 'b']),
         ... )
         >>> adata = adata1.concatenate(adata2, adata3, join='outer')
-        >>> adata.var_names
-        Index(['a', 'b', 'c', 'd'], dtype='object')
+        >>> adata.var_names.astype("string")
+        Index(['a', 'b', 'c', 'd'], dtype='string')
         >>> adata.X.toarray()
         array([[0., 2., 3., 0.],
                [0., 5., 6., 0.],
@@ -1779,25 +1789,25 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):  # noqa: PLW1641
 
         return out
 
-    def var_names_make_unique(self, join: str = "-"):
+    def var_names_make_unique(self, join: str = "-") -> None:
         # Important to go through the setter so obsm dataframes are updated too
         self.var_names = utils.make_index_unique(self.var.index, join)
 
     var_names_make_unique.__doc__ = utils.make_index_unique.__doc__
 
-    def obs_names_make_unique(self, join: str = "-"):
+    def obs_names_make_unique(self, join: str = "-") -> None:
         # Important to go through the setter so obsm dataframes are updated too
         self.obs_names = utils.make_index_unique(self.obs.index, join)
 
     obs_names_make_unique.__doc__ = utils.make_index_unique.__doc__
 
-    def _check_uniqueness(self):
-        if not self.obs.index.is_unique:
+    def _check_uniqueness(self) -> None:
+        if self.obs.index[~self.obs.index.isna()].has_duplicates:
             utils.warn_names_duplicates("obs")
-        if not self.var.index.is_unique:
+        if self.var.index[~self.var.index.isna()].has_duplicates:
             utils.warn_names_duplicates("var")
 
-    def __contains__(self, key: Any):
+    def __contains__(self, key: Any) -> NoReturn:
         msg = "AnnData has no attribute __contains__, don’t check `in adata`."
         raise AttributeError(msg)
 

anndata/_core/merge.py

@@ -334,7 +334,11 @@ def try_unifying_dtype(  # noqa PLR0911, PLR0912
                         if not pd.isnull(dtype) and len(dtype.categories) > 0
                     )
                     if same_orders:
-                        return next(iter(dtypes))
+                        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):
@@ -958,8 +962,13 @@ def gen_inner_reindexers(els, new_index, axis: Literal[0, 1] = 0) -> list[Reinde
             msg = "Cannot concatenate an AwkwardArray with other array types."
             raise NotImplementedError(msg)
         common_keys = intersect_keys(el.fields for el in els)
+        # TODO: replace dtype=object once this is fixed: https://github.com/scikit-hep/awkward/issues/3730
         reindexers = [
-            Reindexer(pd.Index(el.fields), pd.Index(list(common_keys))) for el in els
+            Reindexer(
+                pd.Index(el.fields, dtype=object),
+                pd.Index(list(common_keys), dtype=object),
+            )
+            for el in els
         ]
     else:
         min_ind = min(el.shape[alt_axis] for el in els)
@@ -1198,6 +1207,8 @@ 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,
@@ -1205,7 +1216,6 @@ def make_dask_col_from_extension_dtype(
         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")
@@ -1228,9 +1238,7 @@ 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=xr.core.indexing.LazilyIndexedArray(v), dims=dims
-                )
+                variable = xr.Variable(data=LazilyIndexedArray(v), dims=dims)
                 data_array = XDataArray(
                     variable,
                     coords=coords,
@@ -1323,9 +1331,10 @@ def concat_dataset2d_on_annot_axis(
     -------
     Concatenated :class:`~anndata.experimental.backed.Dataset2D`
     """
+    import xarray as xr
+
     from anndata._core.xarray import Dataset2D
     from anndata._io.specs.lazy_methods import DUMMY_RANGE_INDEX_KEY
-    from anndata.compat import xarray as xr
 
     annotations_re_indexed = []
     have_backed = any(a.is_backed for a in annotations)
@@ -1525,15 +1534,18 @@ def concat(  # noqa: PLR0912, PLR0913, PLR0915
     >>> inner
     AnnData object with n_obs × n_vars = 4 × 2
         obs: 'group'
-    >>> (inner.obs_names, inner.var_names)  # doctest: +NORMALIZE_WHITESPACE
-    (Index(['s1', 's2', 's3', 's4'], dtype='object'),
-    Index(['var1', 'var2'], dtype='object'))
+    >>> (
+    ...     inner.obs_names.astype("string"),
+    ...     inner.var_names.astype("string"),
+    ... )  # doctest: +NORMALIZE_WHITESPACE
+    (Index(['s1', 's2', 's3', 's4'], dtype='string'),
+    Index(['var1', 'var2'], dtype='string'))
     >>> outer = ad.concat([a, b], join="outer")  # Joining on union of variables
     >>> outer
     AnnData object with n_obs × n_vars = 4 × 3
         obs: 'group', 'measure'
-    >>> outer.var_names
-    Index(['var1', 'var2', 'var3'], dtype='object')
+    >>> outer.var_names.astype("string")
+    Index(['var1', 'var2', 'var3'], dtype='string')
     >>> outer.to_df()  # Sparse arrays are padded with zeroes by default
         var1  var2  var3
     s1     0     1     0
@@ -1638,7 +1650,7 @@ def concat(  # noqa: PLR0912, PLR0913, PLR0915
 
     # Combining indexes
     concat_indices = pd.concat(
-        [pd.Series(axis_indices(a, axis=axis)) for a in adatas], ignore_index=True
+        [axis_indices(a, axis=axis).to_series() for a in adatas], ignore_index=True
     )
     if index_unique is not None:
         concat_indices = concat_indices.str.cat(

anndata/_core/sparse_dataset.py

@@ -392,8 +392,17 @@ def is_sparse_indexing_overridden(
 def validate_indices(
     mtx: BackedSparseMatrix, indices: tuple[Index1D, Index1D]
 ) -> tuple[Index1D, Index1D]:
-    res = mtx._validate_indices(indices)
-    return res[0] if SCIPY_1_15 else res
+    if hasattr(mtx, "_validate_indices"):
+        res = mtx._validate_indices(indices)
+        return res[0] if SCIPY_1_15 else res
+    # https://github.com/scipy/scipy/pull/23267
+    elif Version(version("scipy")) >= Version("1.17.0rc0"):
+        from scipy.sparse._index import _validate_indices  # type: ignore
+
+        return _validate_indices(indices, mtx.shape, mtx.format)[0]
+    else:  # pragma: no cover
+        msg = "Cannot validate indices"
+        raise RuntimeError(msg)
 
 
 class BaseCompressedSparseDataset(abc._AbstractCSDataset, ABC):

anndata/_core/views.py

@@ -315,6 +315,7 @@ def as_view_df(df, view_args):
     if settings.remove_unused_categories:
         for col in df.columns:
             if isinstance(df[col].dtype, pd.CategoricalDtype):
+                # TODO: this mode is going away
                 with pd.option_context("mode.chained_assignment", None):
                     df[col] = df[col].cat.remove_unused_categories()
     return DataFrameView(df, view_args=view_args)

anndata/_core/xarray.py

@@ -3,23 +3,33 @@ from __future__ import annotations
 import warnings
 from dataclasses import dataclass
 from functools import wraps
-from typing import TYPE_CHECKING, overload
+from typing import TYPE_CHECKING, TypeVar, overload
 
 import numpy as np
 import pandas as pd
 
-from ..compat import XDataArray, XDataset, XVariable
+from ..compat import XDataArray, XDataset, XVariable, pandas_as_str
 
 if TYPE_CHECKING:
-    from collections.abc import Hashable, Iterable, Iterator, Mapping
+    from collections.abc import (
+        Callable,
+        Collection,
+        Hashable,
+        Iterable,
+        Iterator,
+        Mapping,
+    )
     from typing import Any, Literal
 
     from .._types import Dataset2DIlocIndexer
 
+P = TypeVar("P")
+R = TypeVar("R")
 
-def requires_xarray(func):
+
+def requires_xarray(func: Callable[P, R]) -> Callable[P, R]:
     @wraps(func)
-    def wrapper(*args, **kwargs):
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
         try:
             import xarray  # noqa: F401
         except ImportError as e:
@@ -91,7 +101,7 @@ class Dataset2D:
         return self.ds.attrs.get("is_backed", False)
 
     @is_backed.setter
-    def is_backed(self, isbacked: bool) -> bool:
+    def is_backed(self, isbacked: bool) -> None:
         if not isbacked and "is_backed" in self.ds.attrs:
             del self.ds.attrs["is_backed"]
         else:
@@ -191,18 +201,21 @@ class Dataset2D:
     @overload
     def __getitem__(self, key: Hashable) -> XDataArray: ...
     @overload
-    def __getitem__(self, key: Iterable[Hashable]) -> Dataset2D: ...
+    def __getitem__(self, key: Collection[Hashable]) -> Dataset2D: ...
     def __getitem__(
         self, key: Mapping[Any, Any] | Hashable | Iterable[Hashable]
     ) -> Dataset2D | XDataArray:
         ret = self.ds.__getitem__(key)
-        if len(key) == 0 and not isinstance(key, tuple):  # empty XDataset
+        if is_empty := (len(key) == 0 and not isinstance(key, tuple)):  # empty Dataset
             ret.coords[self.index_dim] = self.xr_index
         if isinstance(ret, XDataset):
             # If we get an xarray Dataset, we return a Dataset2D
             as_2d = Dataset2D(ret)
-
-            as_2d.true_index_dim = self.true_index_dim
+            if not is_empty and self.true_index_dim not in [
+                *as_2d.columns,
+                as_2d.index_dim,
+            ]:
+                as_2d[self.true_index_dim] = self.true_index
             as_2d.is_backed = self.is_backed
             return as_2d
         return ret
@@ -222,18 +235,21 @@ class Dataset2D:
         -------
             :class:`pandas.DataFrame` with index set accordingly.
         """
+        index_key = self.ds.attrs.get("indexing_key", None)
+        all_columns = {*self.columns, *([] if index_key is None else [index_key])}
         # https://github.com/pydata/xarray/issues/10419
         non_nullable_string_cols = {
             col
-            for col in self.columns
+            for col in all_columns
             if not self[col].attrs.get("is_nullable_string", False)
         }
         df = self.ds.to_dataframe()
-        index_key = self.ds.attrs.get("indexing_key", None)
+        for col in all_columns - non_nullable_string_cols:
+            df[col] = (
+                pandas_as_str(df[col]) if col == index_key else df[col].astype("string")
+            )
         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] = df[col].astype(dtype="string")
         df.index.name = None  # matches old AnnData object
         return df
 
@@ -263,7 +279,7 @@ class Dataset2D:
         For supported setter values see :meth:`xarray.Dataset.__setitem__`.
         """
         if key == self.index_dim:
-            msg = f"Cannot set {self.index_dim} as a variable. Use `index` instead."
+            msg = f"Cannot set the index dimension {self.index_dim} as if it were a variable. Use `ds.index = ...` instead."
             raise KeyError(msg)
         if isinstance(value, tuple):
             if isinstance(value[0], tuple):

anndata/_io/h5ad.py

@@ -41,6 +41,7 @@ if TYPE_CHECKING:
 
     from .._core.file_backing import AnnDataFileManager
     from .._core.raw import Raw
+    from .._types import StorageType
 
 T = TypeVar("T")
 
@@ -261,7 +262,7 @@ def read_h5ad(
 
     with h5py.File(filename, "r") as f:
 
-        def callback(func, elem_name: str, elem, iospec):
+        def callback(read_func, elem_name: str, elem: StorageType, iospec: IOSpec):
             if iospec.encoding_type == "anndata" or elem_name.endswith("/"):
                 return AnnData(**{
                     # This is covering up backwards compat in the anndata initializer
@@ -279,7 +280,7 @@ def read_h5ad(
             elif elem_name in {"/obs", "/var"}:
                 # Backwards compat
                 return read_dataframe(elem)
-            return func(elem)
+            return read_func(elem)
 
         adata = read_dispatched(f, callback=callback)
 

anndata/_io/read.py

@@ -15,7 +15,7 @@ import pandas as pd
 from scipy import sparse
 
 from .. import AnnData
-from ..compat import old_positionals
+from ..compat import old_positionals, pandas_as_str
 from .utils import is_float
 
 if TYPE_CHECKING:
@@ -74,8 +74,8 @@ def read_excel(
 
     df = read_excel(fspath(filename), sheet)
     X = df.values[:, 1:]
-    row = dict(row_names=df.iloc[:, 0].values.astype(str))
-    col = dict(col_names=np.array(df.columns[1:], dtype=str))
+    row = dict(row_names=pandas_as_str(df.iloc[:, 0]).array)
+    col = dict(col_names=pandas_as_str(df.columns[1:]).array)
     return AnnData(X, row, col)
 
 

anndata/_io/specs/lazy_methods.py

@@ -270,7 +270,10 @@ def _gen_xarray_dict_iterator_from_elems(
                     "base_path_or_zarr_group": v.base_path_or_zarr_group,
                     "elem_name": v.elem_name,
                     "is_nullable_string": isinstance(v, MaskedArray)
-                    and v.dtype == NULLABLE_NUMPY_STRING_TYPE,
+                    and (
+                        v.dtype == NULLABLE_NUMPY_STRING_TYPE
+                        or isinstance(v.dtype, pd.StringDtype | np.dtypes.StringDType)
+                    ),
                 },
             )
         elif k == dim_name:
@@ -296,6 +299,10 @@ def read_dataframe(
     use_range_index: bool = False,
     chunks: tuple[int] | None = None,
 ) -> Dataset2D:
+    from xarray.core.indexing import BasicIndexer
+
+    from ...experimental.backed._lazy_arrays import MaskedArray
+
     elem_dict = {
         k: _reader.read_elem(elem[k], chunks=chunks)
         for k in [*elem.attrs["column-order"], elem.attrs["_index"]]
@@ -305,7 +312,12 @@ def read_dataframe(
     if not use_range_index:
         dim_name = elem.attrs["_index"]
         # no sense in reading this in multiple times since xarray requires an in-memory index
-        index = elem_dict[dim_name].compute()
+        if isinstance(elem_dict[dim_name], DaskArray):
+            index = elem_dict[dim_name].compute()
+        elif isinstance(elem_dict[dim_name], MaskedArray):
+            index = elem_dict[dim_name][BasicIndexer((slice(None),))]
+        else:
+            raise NotImplementedError()
     else:
         dim_name = DUMMY_RANGE_INDEX_KEY
         index = pd.RangeIndex(len(elem_dict[elem.attrs["_index"]])).astype("str")

anndata/_io/specs/methods.py

@@ -25,7 +25,6 @@ from anndata._core.sparse_dataset import _CSCDataset, _CSRDataset, sparse_datase
 from anndata._io.utils import check_key, zero_dim_array_as_scalar
 from anndata._warnings import OldFormatWarning
 from anndata.compat import (
-    NULLABLE_NUMPY_STRING_TYPE,
     AwkArray,
     CupyArray,
     CupyCSCMatrix,
@@ -43,7 +42,7 @@ from anndata.compat import (
 )
 
 from ..._settings import settings
-from ...compat import is_zarr_v2
+from ...compat import NULLABLE_NUMPY_STRING_TYPE, PANDAS_STRING_ARRAY_TYPES, is_zarr_v2
 from .registry import _REGISTRY, IOSpec, read_elem, read_elem_partial
 
 if TYPE_CHECKING:
@@ -1140,27 +1139,24 @@ def read_partial_categorical(elem, *, items=None, indices=(slice(None),)):
 @_REGISTRY.register_write(
     ZarrGroup, pd.arrays.BooleanArray, IOSpec("nullable-boolean", "0.1.0")
 )
-@_REGISTRY.register_write(
-    H5Group, pd.arrays.StringArray, IOSpec("nullable-string-array", "0.1.0")
-)
-@_REGISTRY.register_write(
-    ZarrGroup, pd.arrays.StringArray, IOSpec("nullable-string-array", "0.1.0")
-)
 def write_nullable(
     f: GroupStorageType,
     k: str,
-    v: pd.arrays.IntegerArray | pd.arrays.BooleanArray | pd.arrays.StringArray,
+    v: pd.arrays.IntegerArray
+    | pd.arrays.BooleanArray
+    | pd.arrays.StringArray
+    | pd.arrays.ArrowStringArray,
     *,
     _writer: Writer,
     dataset_kwargs: Mapping[str, Any] = MappingProxyType({}),
-):
+) -> None:
     if (
-        isinstance(v, pd.arrays.StringArray)
+        isinstance(v, pd.arrays.StringArray | pd.arrays.ArrowStringArray)
         and not settings.allow_write_nullable_strings
     ):
         msg = (
             "`anndata.settings.allow_write_nullable_strings` is False, "
-            "because writing of `pd.arrays.StringArray` is new "
+            "because writing of `pd.arrays.{StringArray,ArrowStringArray}` is new "
             "and not supported in anndata < 0.11, still use by many people. "
             "Opt-in to writing these arrays by toggling the setting to True."
         )
@@ -1168,13 +1164,19 @@ def write_nullable(
     g = f.require_group(k)
     values = (
         v.to_numpy(na_value="")
-        if isinstance(v, pd.arrays.StringArray)
+        if isinstance(v, pd.arrays.StringArray | pd.arrays.ArrowStringArray)
         else v.to_numpy(na_value=0, dtype=v.dtype.numpy_dtype)
     )
     _writer.write_elem(g, "values", values, dataset_kwargs=dataset_kwargs)
     _writer.write_elem(g, "mask", v.isna(), dataset_kwargs=dataset_kwargs)
 
 
+for store_type, array_type in product([H5Group, ZarrGroup], PANDAS_STRING_ARRAY_TYPES):
+    _REGISTRY.register_write(
+        store_type, array_type, IOSpec("nullable-string-array", "0.1.0")
+    )(write_nullable)
+
+
 def _read_nullable(
     elem: GroupStorageType,
     *,
@@ -1190,18 +1192,6 @@ def _read_nullable(
     )
 
 
-def _string_array(
-    values: np.ndarray, mask: np.ndarray
-) -> pd.api.extensions.ExtensionArray:
-    """Construct a string array from values and mask."""
-    arr = pd.array(
-        values.astype(NULLABLE_NUMPY_STRING_TYPE),
-        dtype=pd.StringDtype(),
-    )
-    arr[mask] = pd.NA
-    return arr
-
-
 _REGISTRY.register_read(H5Group, IOSpec("nullable-integer", "0.1.0"))(
     read_nullable_integer := partial(_read_nullable, array_type=pd.arrays.IntegerArray)
 )
@@ -1216,12 +1206,22 @@ _REGISTRY.register_read(ZarrGroup, IOSpec("nullable-boolean", "0.1.0"))(
     read_nullable_boolean
 )
 
-_REGISTRY.register_read(H5Group, IOSpec("nullable-string-array", "0.1.0"))(
-    read_nullable_string := partial(_read_nullable, array_type=_string_array)
-)
-_REGISTRY.register_read(ZarrGroup, IOSpec("nullable-string-array", "0.1.0"))(
-    read_nullable_string
-)
+
+@_REGISTRY.register_read(H5Group, IOSpec("nullable-string-array", "0.1.0"))
+@_REGISTRY.register_read(ZarrGroup, IOSpec("nullable-string-array", "0.1.0"))
+def _read_nullable_string(
+    elem: GroupStorageType, *, _reader: Reader
+) -> pd.api.extensions.ExtensionArray:
+    values = _reader.read_elem(elem["values"])
+    mask = _reader.read_elem(elem["mask"])
+    dtype = pd.StringDtype()
+
+    arr = pd.array(
+        values.astype(NULLABLE_NUMPY_STRING_TYPE),
+        dtype=dtype,
+    )
+    arr[mask] = pd.NA
+    return arr
 
 
 ###########

anndata/_settings.py

@@ -102,7 +102,7 @@ def check_and_get_environ_var(
     )
 
 
-def check_and_get_bool(option, default_value):
+def check_and_get_bool(option: str, default_value: bool) -> bool:  # noqa: FBT001
     return check_and_get_environ_var(
         f"ANNDATA_{option.upper()}",
         str(int(default_value)),
@@ -111,7 +111,7 @@ def check_and_get_bool(option, default_value):
     )
 
 
-def check_and_get_int(option, default_value):
+def check_and_get_int(option: str, default_value: int) -> int:
     return check_and_get_environ_var(
         f"ANNDATA_{option.upper()}",
         str(int(default_value)),
@@ -431,7 +431,7 @@ settings.register(
 settings.register(
     "allow_write_nullable_strings",
     default_value=False,
-    description="Whether or not to allow writing of `pd.arrays.StringArray`.",
+    description="Whether or not to allow writing of `pd.arrays.{StringArray,ArrowStringArray}`.",
     validate=validate_bool,
     get_from_env=check_and_get_bool,
 )

anndata/_types.py

@@ -130,7 +130,7 @@ class Write(Protocol[RWAble_contra]):
         v
             The element to write out.
         dataset_kwargs
-            Keyword arguments to be passed to a library-level io function, like `chunks` for :doc:`zarr:index`.
+            Keyword arguments to be passed to a library-level io function, like `chunks` for :mod:`zarr`.
         """
         ...
 
@@ -194,7 +194,7 @@ class WriteCallback(Protocol[RWAble]):
         iospec
             Internal AnnData encoding specification for the element.
         dataset_kwargs
-            Keyword arguments to be passed to a library-level io function, like `chunks` for :doc:`zarr:index`.
+            Keyword arguments to be passed to a library-level io function, like `chunks` for :mod:`zarr`.
         """
         ...
 

anndata/compat/__init__.py

@@ -2,11 +2,12 @@ from __future__ import annotations
 
 from codecs import decode
 from collections.abc import Mapping, Sequence
+from enum import Enum, auto
 from functools import cache, partial, singledispatch
 from importlib.metadata import version
 from importlib.util import find_spec
 from types import EllipsisType
-from typing import TYPE_CHECKING, TypeVar
+from typing import TYPE_CHECKING, TypeVar, overload
 from warnings import warn
 
 import h5py
@@ -31,8 +32,8 @@ CSMatrix = scipy.sparse.csr_matrix | scipy.sparse.csc_matrix
 CSArray = scipy.sparse.csr_array | scipy.sparse.csc_array
 
 
-class Empty:
-    pass
+class Empty(Enum):
+    TOKEN = auto()
 
 
 Index1DNorm = slice | NDArray[np.bool_] | NDArray[np.integer]
@@ -76,8 +77,6 @@ H5File = h5py.File
 #############################
 @cache
 def is_zarr_v2() -> bool:
-    from packaging.version import Version
-
     return Version(version("zarr")) < Version("3.0.0")
 
 
@@ -217,10 +216,79 @@ NULLABLE_NUMPY_STRING_TYPE = (
     else np.dtypes.StringDType(na_object=pd.NA)
 )
 
+PANDAS_SUPPORTS_NA_VALUE = Version(version("pandas")) >= Version("2.3")
+
+
+PANDAS_STRING_ARRAY_TYPES: list[type[pd.api.extensions.ExtensionArray]] = [
+    pd.arrays.StringArray,
+    pd.arrays.ArrowStringArray,
+]
+# these are removed in favor of the above classes: https://github.com/pandas-dev/pandas/pull/62149
+try:
+    from pandas.core.arrays.string_ import StringArrayNumpySemantics
+except ImportError:
+    pass
+else:
+    PANDAS_STRING_ARRAY_TYPES += [StringArrayNumpySemantics]
+try:
+    from pandas.core.arrays.string_arrow import ArrowStringArrayNumpySemantics
+except ImportError:
+    pass
+else:
+    PANDAS_STRING_ARRAY_TYPES += [ArrowStringArrayNumpySemantics]
+
+
+@overload
+def pandas_as_str(a: pd.Index[Any]) -> pd.Index[str]: ...
+@overload
+def pandas_as_str(a: pd.Series[Any]) -> pd.Series[str]: ...
+
+
+def pandas_as_str(a: pd.Index | pd.Series) -> pd.Index[str] | pd.Series[str]:
+    """Convert to fitting dtype, maintaining NA semantics if possible.
+
+    This is `"str"` when `pd.options.future.infer_string` is `True` (e.g. in Pandas 3+), and `"object"` otherwise.
+    """
+    if not pd.options.future.infer_string:
+        return a.astype(str)
+    if a.array.dtype == "string":  # any `pd.StringDtype`
+        return a
+    if PANDAS_SUPPORTS_NA_VALUE:
+        dtype = pd.StringDtype(na_value=a.array.dtype.na_value)
+    elif a.array.dtype.na_value is pd.NA:
+        dtype = pd.StringDtype()  # NA semantics
+    elif a.array.dtype.na_value is np.nan and find_spec("pyarrow"):  # noqa: PLW0177
+        # on pandas 2.2, this is the only way to get `np.nan` semantics
+        dtype = pd.StringDtype("pyarrow_numpy")
+    else:
+        msg = (
+            f"Converting an array with `dtype.na_value={a.array.dtype.na_value}` to a string array requires pyarrow or pandas>=2.3. "
+            "Converting to `pd.NA` semantics instead."
+        )
+        warn(msg, UserWarning, stacklevel=2)
+        dtype = pd.StringDtype()  # NA semantics
+    return a.astype(dtype)
+
+
+V = TypeVar("V")
+T = TypeVar("T")
+
+
+@overload
+def _read_attr(
+    attrs: Mapping[str, V], name: str, default: Empty = Empty.TOKEN
+) -> V: ...
+
+
+@overload
+def _read_attr(attrs: Mapping[str, V], name: str, default: T) -> V | T: ...
+
 
 @singledispatch
-def _read_attr(attrs: Mapping, name: str, default: Any | None = Empty):
-    if default is Empty:
+def _read_attr(
+    attrs: Mapping[str, V], name: str, default: T | Empty = Empty.TOKEN
+) -> V | T:
+    if default is Empty.TOKEN:
         return attrs[name]
     else:
         return attrs.get(name, default=default)
@@ -228,8 +296,8 @@ def _read_attr(attrs: Mapping, name: str, default: Any | None = Empty):
 
 @_read_attr.register(h5py.AttributeManager)
 def _read_attr_hdf5(
-    attrs: h5py.AttributeManager, name: str, default: Any | None = Empty
-):
+    attrs: h5py.AttributeManager, name: str, default: T | Empty = Empty.TOKEN
+) -> str | T:
     """
     Read an HDF5 attribute and perform all necessary conversions.
 
@@ -238,7 +306,7 @@ def _read_attr_hdf5(
     For example Julia's HDF5.jl writes string attributes as fixed-size strings, which
     are read as bytes by h5py.
     """
-    if name not in attrs and default is not Empty:
+    if name not in attrs and default is not Empty.TOKEN:
         return default
     attr = attrs[name]
     attr_id = attrs.get_id(name)

anndata/experimental/_dispatch_io.py

@@ -16,10 +16,7 @@ if TYPE_CHECKING:
     from anndata.typing import RWAble
 
 
-def read_dispatched(
-    elem: StorageType,
-    callback: ReadCallback,
-) -> RWAble:
+def read_dispatched(elem: StorageType, callback: ReadCallback) -> RWAble:
     """
     Read elem, calling the callback at each sub-element.
 

anndata/experimental/backed/_lazy_arrays.py

@@ -19,16 +19,22 @@ from ...compat import (
     XZarrArrayWrapper,
     ZarrArray,
 )
-from ...compat import xarray as xr
 
 if TYPE_CHECKING:
     from pathlib import Path
     from typing import Literal
 
+    from pandas._libs.missing import NAType
+    from pandas.core.dtypes.base import ExtensionDtype
+
     from anndata.compat import ZarrGroup
 
     from ...compat import Index1DNorm
 
+    if TYPE_CHECKING:  # Double nesting so Sphinx can import the parent block
+        from xarray.core.extension_array import PandasExtensionArray
+        from xarray.core.indexing import ExplicitIndexer
+
 
 K = TypeVar("K", H5Array, ZarrArray)
 
@@ -43,14 +49,13 @@ class ZarrOrHDF5Wrapper(XZarrArrayWrapper, Generic[K]):
         self.shape = self._array.shape
         self.dtype = self._array.dtype
 
-    def __getitem__(self, key: xr.core.indexing.ExplicitIndexer):
+    def __getitem__(self, key: ExplicitIndexer):
+        from xarray.core.indexing import IndexingSupport, explicit_indexing_adapter
+
         if isinstance(self._array, ZarrArray):
             return super().__getitem__(key)
-        res = xr.core.indexing.explicit_indexing_adapter(
-            key,
-            self.shape,
-            xr.core.indexing.IndexingSupport.OUTER_1VECTOR,
-            self._getitem,
+        res = explicit_indexing_adapter(
+            key, self.shape, IndexingSupport.OUTER_1VECTOR, self._getitem
         )
         return res
 
@@ -109,22 +114,23 @@ class CategoricalArray(XBackendArray, Generic[K]):
 
     @cached_property
     def categories(self) -> np.ndarray:
-        if isinstance(self._categories, ZarrArray):
-            return self._categories[...]
         from anndata.io import read_elem
 
         return read_elem(self._categories)
 
-    def __getitem__(
-        self, key: xr.core.indexing.ExplicitIndexer
-    ) -> xr.core.extension_array.PandasExtensionArray:
+    def __getitem__(self, key: ExplicitIndexer) -> PandasExtensionArray:
+        from xarray.core.extension_array import PandasExtensionArray
+
         codes = self._codes[key]
         categorical_array = pd.Categorical.from_codes(
-            codes=codes, categories=self.categories, ordered=self._ordered
+            codes=codes,
+            # casting to numpy (string) maintains our old behavior, this will be relaxed in 0.13
+            categories=np.array(self.categories),
+            ordered=self._ordered,
         )
         if settings.remove_unused_categories:
             categorical_array = categorical_array.remove_unused_categories()
-        return xr.core.extension_array.PandasExtensionArray(categorical_array)
+        return PandasExtensionArray(categorical_array)
 
     @cached_property
     def dtype(self):
@@ -163,9 +169,9 @@ class MaskedArray(XBackendArray, Generic[K]):
         self.file_format = "zarr" if isinstance(mask, ZarrArray) else "h5"
         self.elem_name = elem_name
 
-    def __getitem__(
-        self, key: xr.core.indexing.ExplicitIndexer
-    ) -> xr.core.extension_array.PandasExtensionArray | np.ndarray:
+    def __getitem__(self, key: ExplicitIndexer) -> PandasExtensionArray | np.ndarray:
+        from xarray.core.extension_array import PandasExtensionArray
+
         values = self._values[key]
         mask = self._mask[key]
         if self._dtype_str == "nullable-integer":
@@ -181,10 +187,10 @@ class MaskedArray(XBackendArray, Generic[K]):
         else:
             msg = f"Invalid dtype_str {self._dtype_str}"
             raise RuntimeError(msg)
-        return xr.core.extension_array.PandasExtensionArray(extension_array)
+        return PandasExtensionArray(extension_array)
 
     @cached_property
-    def dtype(self):
+    def dtype(self) -> np.dtypes.StringDType[NAType] | ExtensionDtype:
         if self._dtype_str == "nullable-integer":
             return pd.array(
                 [],

anndata/experimental/merge.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import shutil
 from collections.abc import Mapping
+from contextlib import ExitStack, contextmanager
 from functools import singledispatch
 from os import PathLike
 from pathlib import Path
@@ -30,10 +31,11 @@ from ..compat import H5Array, H5Group, ZarrArray, ZarrGroup
 from . import read_dispatched, read_elem_lazy
 
 if TYPE_CHECKING:
-    from collections.abc import Callable, Collection, Iterable, Sequence
+    from collections.abc import Callable, Collection, Generator, Iterable, Sequence
     from typing import Any, Literal
 
     from .._core.merge import Reindexer, StrategiesLiteral
+    from .._types import Join_T
 
 SPARSE_MATRIX = {"csc_matrix", "csr_matrix"}
 
@@ -100,35 +102,42 @@ def _gen_slice_to_append(
 
 
 @singledispatch
-def as_group(store, *, mode: str) -> ZarrGroup | H5Group:
+@contextmanager
+def as_group(store, *, mode: str) -> Generator[ZarrGroup | H5Group]:
     msg = "This is not yet implemented."
     raise NotImplementedError(msg)
 
 
 @as_group.register(PathLike)
 @as_group.register(str)
-def _(store: PathLike[str] | str, *, mode: str) -> ZarrGroup | H5Group:
+@contextmanager
+def _(store: PathLike[str] | str, *, mode: str) -> Generator[ZarrGroup | H5Group]:
     store = Path(store)
     if store.suffix == ".h5ad":
         import h5py
 
-        return h5py.File(store, mode=mode)
+        f = h5py.File(store, mode=mode)
+        try:
+            yield f
+        finally:
+            f.close()
 
-    if mode == "r":  # others all write: r+, a, w, w-
+    elif mode == "r":  # others all write: r+, a, w, w-
         import zarr
 
-        return zarr.open_group(store, mode=mode)
-
-    from anndata._io.zarr import open_write_group
+        yield zarr.open_group(store, mode=mode)
+    else:
+        from anndata._io.zarr import open_write_group
 
-    return open_write_group(store, mode=mode)
+        yield open_write_group(store, mode=mode)
 
 
 @as_group.register(ZarrGroup)
 @as_group.register(H5Group)
-def _(store, *, mode: str) -> ZarrGroup | H5Group:
+@contextmanager
+def _(store: ZarrGroup | H5Group, *, mode: str) -> Generator[ZarrGroup | H5Group]:
     del mode
-    return store
+    yield store
 
 
 ###################
@@ -441,9 +450,10 @@ def _write_alt_pairwise(
     write_elem(output_group, f"{alt_axis_name}p", alt_pairwise)
 
 
-def concat_on_disk(  # noqa: PLR0912, PLR0913, PLR0915
-    in_files: Collection[PathLike[str] | str] | Mapping[str, PathLike[str] | str],
-    out_file: PathLike[str] | str,
+def concat_on_disk(  # noqa: PLR0913
+    in_files: Collection[PathLike[str] | str | H5Group | ZarrGroup]
+    | Mapping[str, PathLike[str] | str | H5Group | ZarrGroup],
+    out_file: PathLike[str] | str | H5Group | ZarrGroup,
     *,
     max_loaded_elems: int = 100_000_000,
     axis: Literal["obs", 0, "var", 1] = 0,
@@ -584,10 +594,11 @@ def concat_on_disk(  # noqa: PLR0912, PLR0913, PLR0915
     merge = resolve_merge_strategy(merge)
     uns_merge = resolve_merge_strategy(uns_merge)
 
-    out_file = Path(out_file)
-    if not out_file.parent.exists():
-        msg = f"Parent directory of {out_file} does not exist."
-        raise FileNotFoundError(msg)
+    if is_out_path_like := isinstance(out_file, str | PathLike):
+        out_file = Path(out_file)
+        if not out_file.parent.exists():
+            msg = f"Parent directory of {out_file} does not exist."
+            raise FileNotFoundError(msg)
 
     if isinstance(in_files, Mapping):
         if keys is not None:
@@ -600,7 +611,11 @@ def concat_on_disk(  # noqa: PLR0912, PLR0913, PLR0915
     else:
         in_files = list(in_files)
 
-    if len(in_files) == 1:
+    if (
+        len(in_files) == 1
+        and isinstance(in_files[0], str | PathLike)
+        and is_out_path_like
+    ):
         shutil.copy2(in_files[0], out_file)
         return
 
@@ -610,9 +625,40 @@ def concat_on_disk(  # noqa: PLR0912, PLR0913, PLR0915
     axis, axis_name = _resolve_axis(axis)
     _, alt_axis_name = _resolve_axis(1 - axis)
 
-    output_group = as_group(out_file, mode="w")
-    groups = [as_group(f, mode="r") for f in in_files]
+    with ExitStack() as stack, as_group(out_file, mode="w") as output_group:
+        groups = [stack.enter_context(as_group(f, mode="r")) for f in in_files]
+        _concat_on_disk_inner(
+            groups=groups,
+            output_group=output_group,
+            axis=axis,
+            axis_name=axis_name,
+            alt_axis_name=alt_axis_name,
+            keys=keys,
+            max_loaded_elems=max_loaded_elems,
+            join=join,
+            label=label,
+            index_unique=index_unique,
+            fill_value=fill_value,
+            merge=merge,
+        )
 
+
+def _concat_on_disk_inner(  # noqa: PLR0913
+    *,
+    groups: list[H5Group | ZarrGroup],
+    output_group: H5Group | ZarrGroup,
+    axis: Literal[0, 1],
+    axis_name: Literal["obs", "var"],
+    alt_axis_name: Literal["obs", "var"],
+    keys: np.ndarray[tuple[int], np.dtype[Any]] | Collection[str],
+    max_loaded_elems: int,
+    join: Join_T = "inner",
+    label: str | None,
+    index_unique: str | None,
+    fill_value: Any | None,
+    merge: Callable[[Collection[Mapping]], Mapping],
+) -> None:
+    """Internal helper to minimize the amount of indented code within the context manager"""
     use_reindexing = False
 
     alt_idxs = [_df_index(g[alt_axis_name]) for g in groups]

anndata/experimental/multi_files/_anncollection.py

@@ -489,7 +489,7 @@ class AnnCollectionView(_ConcatViewMixin, _IterateViewMixin):
                 # change dtype for all keys of .obsm
                 "obsm": lambda a: np.asarray(a, dtype="float32"),
                 # change type only for one key of .obs
-                "obs": dict(key1=lambda c: c.astype(str)),
+                "obs": dict(key1=lambda c: c.astype("string")),
             }
         """
         return self._convert
@@ -834,7 +834,7 @@ class AnnCollection(_ConcatViewMixin, _IterateViewMixin):
                 # change dtype for all keys of .obsm
                 "obsm": lambda a: np.asarray(a, dtype="float32"),
                 # change type only for one key of .obs
-                "obs": dict(key1=lambda c: c.astype(str)),
+                "obs": dict(key1=lambda c: c.astype("string")),
             }
         """
         return self._convert

anndata/tests/helpers.py

@@ -322,8 +322,8 @@ def gen_adata(  # noqa: PLR0913
         random_state = np.random.default_rng()
 
     M, N = shape
-    obs_names = pd.Index(f"cell{i}" for i in range(shape[0]))
-    var_names = pd.Index(f"gene{i}" for i in range(shape[1]))
+    obs_names = pd.Index([f"cell{i}" for i in range(shape[0])], dtype="str")
+    var_names = pd.Index([f"gene{i}" for i in range(shape[1])], dtype="str")
     obs = gen_typed_df(M, obs_names, dtypes=obs_dtypes)
     var = gen_typed_df(N, var_names, dtypes=var_dtypes)
     # For #147
@@ -1166,7 +1166,8 @@ class AccessTrackingStoreBase(LocalStore):
     def reset_key_trackers(self) -> None:
         self.initialize_key_trackers(self._access_count.keys())
 
-    def assert_access_count(self, key: str, count: int):
+    def assert_access_count(self, key: str, count: int) -> None:
+        __tracebackhide__ = True
         keys_accessed = self.get_subkeys_accessed(key)
         access_count = self.get_access_count(key)
         assert self.get_access_count(key) == count, (

anndata/utils.py

@@ -216,7 +216,7 @@ except ImportError:
     pass
 
 
-def make_index_unique(index: pd.Index, join: str = "-"):
+def make_index_unique(index: pd.Index[str], join: str = "-") -> pd.Index[str]:
     """
     Makes the index unique by appending a number string to each duplicate index element:
     '1', '2', etc.
@@ -235,18 +235,18 @@ def make_index_unique(index: pd.Index, join: str = "-"):
     --------
     >>> from anndata import AnnData
     >>> adata = AnnData(np.ones((2, 3)), var=pd.DataFrame(index=["a", "a", "b"]))
-    >>> adata.var_names
-    Index(['a', 'a', 'b'], dtype='object')
+    >>> adata.var_names.astype("string")
+    Index(['a', 'a', 'b'], dtype='string')
     >>> adata.var_names_make_unique()
-    >>> adata.var_names
-    Index(['a', 'a-1', 'b'], dtype='object')
+    >>> adata.var_names.astype("string")
+    Index(['a', 'a-1', 'b'], dtype='string')
     """
     if index.is_unique:
         return index
     from collections import Counter
 
-    values = index.values.copy()
-    indices_dup = index.duplicated(keep="first")
+    values = index.array.copy()
+    indices_dup = index.duplicated(keep="first") & ~index.isna()
     values_dup = values[indices_dup]
     values_set = set(values)
     counter = Counter()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anndata
-Version: 0.12.6
+Version: 0.12.7
 Summary: Annotated data.
 Project-URL: Documentation, https://anndata.readthedocs.io/
 Project-URL: Source, https://github.com/scverse/anndata
@@ -31,7 +31,7 @@ Requires-Dist: legacy-api-wrap
 Requires-Dist: natsort
 Requires-Dist: numpy>=1.26
 Requires-Dist: packaging>=24.2
-Requires-Dist: pandas!=2.1.2,>=2.1.0
+Requires-Dist: pandas!=2.1.2,<3,>=2.1.0
 Requires-Dist: scipy>=1.12
 Requires-Dist: zarr!=3.0.*,>=2.18.7
 Provides-Extra: cu11
@@ -57,7 +57,7 @@ Requires-Dist: sphinx-copybutton; extra == 'doc'
 Requires-Dist: sphinx-design>=0.5.0; extra == 'doc'
 Requires-Dist: sphinx-issues>=5.0.1; extra == 'doc'
 Requires-Dist: sphinx-toolbox>=3.8.0; extra == 'doc'
-Requires-Dist: sphinx>=8.2.1; extra == 'doc'
+Requires-Dist: sphinx<9,>=8.2.1; extra == 'doc'
 Requires-Dist: sphinxext-opengraph; extra == 'doc'
 Requires-Dist: towncrier>=24.8.0; extra == 'doc'
 Provides-Extra: gpu
@@ -80,12 +80,12 @@ Requires-Dist: loompy>=3.0.5; extra == 'test'
 Requires-Dist: matplotlib; extra == 'test'
 Requires-Dist: openpyxl; extra == 'test'
 Requires-Dist: pyarrow; extra == 'test'
+Requires-Dist: pytest; extra == 'test'
 Requires-Dist: pytest-cov; extra == 'test'
 Requires-Dist: pytest-memray; extra == 'test'
 Requires-Dist: pytest-mock; extra == 'test'
 Requires-Dist: pytest-randomly; extra == 'test'
 Requires-Dist: pytest-xdist[psutil]; extra == 'test'
-Requires-Dist: pytest<8.3.4,>=8.2; extra == 'test'
 Requires-Dist: requests; extra == 'test'
 Requires-Dist: scanpy>=1.10; extra == 'test'
 Requires-Dist: scikit-learn; extra == 'test'
@@ -102,12 +102,12 @@ Requires-Dist: loompy>=3.0.5; extra == 'test-min'
 Requires-Dist: matplotlib; extra == 'test-min'
 Requires-Dist: openpyxl; extra == 'test-min'
 Requires-Dist: pyarrow; extra == 'test-min'
+Requires-Dist: pytest; extra == 'test-min'
 Requires-Dist: pytest-cov; extra == 'test-min'
 Requires-Dist: pytest-memray; extra == 'test-min'
 Requires-Dist: pytest-mock; extra == 'test-min'
 Requires-Dist: pytest-randomly; extra == 'test-min'
 Requires-Dist: pytest-xdist[psutil]; extra == 'test-min'
-Requires-Dist: pytest<8.3.4,>=8.2; extra == 'test-min'
 Requires-Dist: scanpy>=1.10; extra == 'test-min'
 Requires-Dist: scikit-learn; extra == 'test-min'
 Description-Content-Type: text/markdown

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

@@ -1,57 +1,57 @@
 anndata/__init__.py,sha256=daAzY8GGouJxCe30Lcr2pl9Jwo2dcGXHPi7WxnHpuOE,1710
-anndata/_settings.py,sha256=AvCdIKCynrP6xUjVtYpvN8dFTefsGPu6anGp4c8M58I,17532
+anndata/_settings.py,sha256=A5duA5C2-S2vt2O53kWpBpa6PyQi4qfGm24ndudU6fs,17603
 anndata/_settings.pyi,sha256=mJQQ3I66Y3sng8K-_aGjYuo5UoNgC5syw0yuNc1FADU,1643
-anndata/_types.py,sha256=c71REP9wS7Vz2cYrNxuNjPYdnq8MJ5g04MNrSi85ATA,5427
+anndata/_types.py,sha256=RbSN6dc46J2qDTZ9y9JXrzqfwhoCX5zL1ZPH7wTQyrM,5415
 anndata/_warnings.py,sha256=iFXa9EzPyuPbzRAzoG04oTXAyjnXhQa5zxAMZdsGLwM,702
 anndata/abc.py,sha256=jG64k59ZZ9Hfn-QWt_btZLuF7eGv_YNYwH91WdbR240,1645
 anndata/io.py,sha256=DrIo-FU6qbrdk5aVKoUIBoMttZaO5QWP4bowS9xaebI,698
 anndata/logging.py,sha256=E6nlPl-Em0yBjL5p-EcQFmhHTIUirhnZbfXbQtSVSek,1662
 anndata/types.py,sha256=FF3wDkntl6Jq35l0r_kEET33ljj9L7pmIrUr5-MLAvE,698
 anndata/typing.py,sha256=sRiAg16asjnKyXk1L4BtKWggyHMPLoxXzxTDmX3i7MY,1555
-anndata/utils.py,sha256=D4t_iQdTPeHukN4H7no0QZTIzWzclMYsWAHSBpubvCg,14758
+anndata/utils.py,sha256=25M9B1rv3ZqHv0ZSIWpWjBLZSg4Bn_kv1ZnfRZghSaU,14829
 anndata/_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 anndata/_core/access.py,sha256=pts7fGUKgGZANSsu_qAA7L10qHM-jT1zIehbl3441OY,873
-anndata/_core/aligned_df.py,sha256=EC01OveJ0tS5bQQHc_OprYSPprl-YtJQK-kIOY_4SX0,4214
+anndata/_core/aligned_df.py,sha256=bM9kkEFURRLeUOUMk90WxVnRC-ZsXGEDx36kDj5gC9I,4278
 anndata/_core/aligned_mapping.py,sha256=BYU1jslMWIhtFTtUMaXY8ZCyt0J4_ZsJTmj6J2yAXTQ,14257
-anndata/_core/anndata.py,sha256=PmR6vKglxX8G837lOah6OhPANALbTWYNlUWHf1A-SPw,78963
+anndata/_core/anndata.py,sha256=e_IgHjIpXPQPJqakeH83bl8Quu9T0N--Mb_QHINayv4,79276
 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=vRW9z_PbobmRGDzQIVxAoFc7G9Rq-y6ry57k_XMmsLc,60460
+anndata/_core/merge.py,sha256=wFsUotHnQsnFp84UoCp78XMw3zVfvUH5eIi-8hkb7zo,60880
 anndata/_core/raw.py,sha256=x_PwwaDQscVQOFJ38kF7sNQ47LxowpS38h2RQfU5Zwo,7925
-anndata/_core/sparse_dataset.py,sha256=mE-PRX4znkDyuum3BBBv7MJwyn4XL9C3nIQNRjZJ94w,26877
+anndata/_core/sparse_dataset.py,sha256=R2BeSLiREiwk9FNjdLCR3VfbYatz-7BK0l2F9XqCiTk,27280
 anndata/_core/storage.py,sha256=mHzqp7YBJ-rGQFulMAx__D-Z7y4omHPyb1cP7YxfbFE,2555
-anndata/_core/views.py,sha256=DIJgnqPvh07wbLousjZbGBsMC55oyBsMbSeybQC5sIY,15019
-anndata/_core/xarray.py,sha256=JeQjTuSQEiZF8cryKDYf9d7yt-ufQEVo9x94YaczuPQ,16078
+anndata/_core/views.py,sha256=-tiUwugw0bRYXzewruhU0xXT7nnDLdYf4CiFByLl34w,15067
+anndata/_core/xarray.py,sha256=0de8K7YjG9mnT-dFSRoxVxgwQktjrGI9n5Yy-1YJSHg,16624
 anndata/_io/__init__.py,sha256=GTNeUZ8d8aA3sK4P33tyljIc60KapLbkqBC6J1y3l9U,346
-anndata/_io/h5ad.py,sha256=BwBEYU_SZWn3KDD3RuxltDSkyqHxE3xXUfkiPh8OG-Y,13908
-anndata/_io/read.py,sha256=MuTR6dR2WItV2y0sKYvxSO2fu7OlDjaCRYJuT5UbuBo,15933
+anndata/_io/h5ad.py,sha256=JT5DxTXXibz2jh1mjaQB3_0QYdhJ3gv4IcWLPjKD-dw,13976
+anndata/_io/read.py,sha256=Z0QdFkaaXmGo5a25O9N9Ej2v8U7b9oV9Umw98YtB5uA,15950
 anndata/_io/utils.py,sha256=3Lg27Q0Uo3HYlz980bG2Y02_VFIt0PiXMNIj_o-mgC4,9490
 anndata/_io/write.py,sha256=r55w6yPIIuUSLW9wyYL8GnkzHHQdAxy6xiCEw9cAC38,4811
 anndata/_io/zarr.py,sha256=Z996SZ8LV1Fpa_q8o70vHnBzNLOLlVjhf_Rs5EM_Slo,5461
 anndata/_io/specs/__init__.py,sha256=Z6l8xqa7B480U3pqrNIg4-fhUvpBW85w4xA3i3maAUM,427
-anndata/_io/specs/lazy_methods.py,sha256=hnZ3ggrVCXR_rCMVH2Of9YE3s4saWg2WODcCtj0WaIQ,12600
-anndata/_io/specs/methods.py,sha256=nn9DFcUEWvCeAPPifiFxpuYW3AmtFhNDUbxo7i0toow,46314
+anndata/_io/specs/lazy_methods.py,sha256=aCdmmYLrOHlMyT18t3sLE2I51YGT-jDna2F3m7b_kv0,13093
+anndata/_io/specs/methods.py,sha256=awmdbUMAP9Xjkid56LAbyWNQfKcCOrkx0BeQ6CDKek4,46422
 anndata/_io/specs/registry.py,sha256=6Z_ffk3uOIagzRPcDCvEoszcgD-U3n8wYnGiPA71ZeI,17539
-anndata/compat/__init__.py,sha256=lsLHB7je0SHSePi9noY3p7kRbOAHhZzmMT1hs_ZSXys,12702
+anndata/compat/__init__.py,sha256=9696gHdOUz2yKih9epmT8WGSr6UX0pI8dJYTrqn0SJQ,14968
 anndata/experimental/__init__.py,sha256=polIxriEkby0iEqw-IXkUzp8k0wp92BpYY4zl4BsHH0,1648
-anndata/experimental/_dispatch_io.py,sha256=JzH8Uvewabc1gIF3L16RZnM9m2NAG28bQIQ57uP097k,1869
-anndata/experimental/merge.py,sha256=pl4MtDs_M76cTEqrJ_YJ8zyB6ID7QGzjntlAL7vp_qk,23303
+anndata/experimental/_dispatch_io.py,sha256=gb9JUcgS1cIERjxM1PBpWDXfPkKgMevoLF0QInZfC-g,1858
+anndata/experimental/merge.py,sha256=gWBS4HSkG8E3seIs2AS7jqqFc0Zp6JW94KWtNXApafg,24882
 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=WgTYQ88w7rTAP719nGjvyNkIz8cBT2bbkKJhPIxG4_g,7467
+anndata/experimental/backed/_lazy_arrays.py,sha256=8vcu7eyoRRlzNXyAzuY0s9CqEZCOAYoZIo-iI5d71_g,7805
 anndata/experimental/multi_files/__init__.py,sha256=T7iNLlRbe-KnLT3o7Tb7_nE4Iy_hLkG66UjBOvj2Bj8,107
-anndata/experimental/multi_files/_anncollection.py,sha256=d_d-v8X2WJTGNjAJoo2Mdykd-woSTM_oXEf2PUIqS6A,35254
+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=hvcLsWY-fMR4EUrwPd6laiS8kwUlIxvlVq3oeH3jf9g,37618
+anndata/tests/helpers.py,sha256=BORIeSbcD0R_PDzi1IeR252it-aq6bL8fGN-bDR-Q1I,37689
 testing/anndata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 testing/anndata/_doctest.py,sha256=Qew0N0zLLNiPKN1CLunqY5cTinFLaEhY5GagiYfm6KI,344
-testing/anndata/_pytest.py,sha256=cg4oWbtH9J1sRNul0n2oOraU1h7cprugr27EUPGDaN0,3997
+testing/anndata/_pytest.py,sha256=C_R-N2x9NHKZ66YLkvMLWkXQG1WiouOkBnLQpYx_62Q,3994
 testing/anndata/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-anndata-0.12.6.dist-info/METADATA,sha256=nWoP_t6iBExzxOziJ_t0KVJ_lDa6lxsNV4rPXf1EobM,9957
-anndata-0.12.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-anndata-0.12.6.dist-info/licenses/LICENSE,sha256=VcrXoEVMhtNuvMvKYGP-I5lMT8qZ_6dFf22fsL180qA,1575
-anndata-0.12.6.dist-info/RECORD,,
+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.6.dist-info → anndata-0.12.7.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

testing/anndata/_pytest.py

@@ -16,6 +16,8 @@ from typing import TYPE_CHECKING, cast
 
 import pytest
 
+import anndata
+
 if TYPE_CHECKING:
     from collections.abc import Generator, Iterable
     from pathlib import Path
@@ -23,7 +25,6 @@ if TYPE_CHECKING:
 
 @pytest.fixture(autouse=True)
 def _anndata_test_env(request: pytest.FixtureRequest) -> None:
-    import anndata
 
     if isinstance(request.node, pytest.DoctestItem):
         request.getfixturevalue("_doctest_env")