anndata 0.12.4__tar.gz → 0.12.5__tar.gz

{anndata-0.12.4 → anndata-0.12.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anndata
-Version: 0.12.4
+Version: 0.12.5
 Summary: Annotated data.
 Project-URL: Documentation, https://anndata.readthedocs.io/
 Project-URL: Source, https://github.com/scverse/anndata

anndata-0.12.5/benchmarks/benchmarks/dataset2d.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import h5py
+import numpy as np
+import pandas as pd
+import zarr
+
+import anndata as ad
+
+if TYPE_CHECKING:
+    from typing import Literal
+
+
+class Dataset2D:
+    param_names = ("store_type", "chunks", "array_type")
+    params = (
+        ("zarr", "h5ad"),
+        ((-1,), None),
+        ("cat", "numeric", "string-array", "nullable-string-array"),
+    )
+
+    def setup_cache(self):
+        n_obs = 10000
+        array_types = {
+            "numeric": np.arange(n_obs),
+            "string-array": np.array(["a"] * n_obs),
+            "nullable-string-array": pd.array(
+                ["a", pd.NA] * (n_obs // 2), dtype="string"
+            ),
+            "cat": pd.Categorical(np.array(["a"] * n_obs)),
+        }
+        for k, v in array_types.items():
+            for store in [
+                h5py.File(f"data_{k}.h5ad", mode="w"),
+                zarr.open(f"data_{k}.zarr", mode="w", zarr_version=2),
+            ]:
+                df = pd.DataFrame({"a": v}, index=[f"cell{i}" for i in range(n_obs)])
+                if writing_string_array_on_disk := (
+                    isinstance(v, np.ndarray) and df["a"].dtype == "string"
+                ):
+                    df["a"] = df["a"].to_numpy()
+                with ad.settings.override(allow_write_nullable_strings=True):
+                    ad.io.write_elem(store, "df", df)
+                if writing_string_array_on_disk:
+                    assert store["df"]["a"].attrs["encoding-type"] == "string-array"
+
+    def setup(
+        self,
+        store_type: Literal["zarr", "h5ad"],
+        chunks: None | tuple[int],
+        array_type: Literal["cat", "numeric", "string-array", "nullable-string-array"],
+    ):
+        self.store = (
+            h5py.File(f"data_{array_type}.h5ad", mode="r")
+            if store_type == "h5ad"
+            else zarr.open(f"data_{array_type}.zarr")
+        )
+        self.ds = ad.experimental.read_elem_lazy(self.store["df"], chunks=chunks)
+        self.n_obs = self.ds.shape[0]
+
+    def time_read_lazy_default(self, *_):
+        ad.experimental.read_elem_lazy(self.store["df"])
+
+    def peakmem_read_lazy_default(self, *_):
+        ad.experimental.read_elem_lazy(self.store["df"])
+
+    def time_getitem_slice(self, *_):
+        self.ds.iloc[0 : (self.n_obs // 2)].to_memory()
+
+    def peakmem_getitem_slice(self, *_):
+        self.ds.iloc[0 : (self.n_obs // 2)].to_memory()
+
+    def time_full_to_memory(self, *_):
+        self.ds.to_memory()
+
+    def peakmem_full_to_memory(self, *_):
+        self.ds.to_memory()
+
+    def time_getitem_bool_mask(self, *_):
+        self.ds.iloc[np.random.randint(0, self.n_obs, self.n_obs // 2)].to_memory()
+
+    def peakmem_getitem_bool_mask(self, *_):
+        self.ds.iloc[np.random.randint(0, self.n_obs, self.n_obs // 2)].to_memory()
+
+    def time_concat(self, *_):
+        adatas = [ad.AnnData(obs=self.ds)] * 50
+        ad.concat(adatas, join="outer")

{anndata-0.12.4 → anndata-0.12.5}/benchmarks/benchmarks/sparse_dataset.py

@@ -7,7 +7,7 @@ import zarr
 from dask.array.core import Array as DaskArray
 from scipy import sparse
 
-from anndata import AnnData
+from anndata import AnnData, concat
 from anndata._core.sparse_dataset import sparse_dataset
 from anndata._io.specs import write_elem
 from anndata.experimental import read_elem_lazy
@@ -77,3 +77,34 @@ class SparseCSRContiguousSlice:
         res = self.adata[self.index]
         if isinstance(res, DaskArray):
             res.compute()
+
+
+class SparseCSRDask:
+    filepath = "data.zarr"
+
+    def setup_cache(self):
+        X = sparse.random(
+            10_000,
+            10_000,
+            density=0.01,
+            format="csr",
+            random_state=np.random.default_rng(42),
+        )
+        g = zarr.group(self.filepath)
+        write_elem(g, "X", X)
+
+    def setup(self):
+        self.group = zarr.group(self.filepath)
+        self.adata = AnnData(X=read_elem_lazy(self.group["X"]))
+
+    def time_concat(self):
+        concat([self.adata for i in range(100)])
+
+    def peakmem_concat(self):
+        concat([self.adata for i in range(100)])
+
+    def time_read(self):
+        AnnData(X=read_elem_lazy(self.group["X"]))
+
+    def peakmem_read(self):
+        AnnData(X=read_elem_lazy(self.group["X"]))

anndata-0.12.5/docs/release-notes/0.12.5.md

@@ -0,0 +1,12 @@
+(v0.12.5)=
+### 0.12.5 {small}`2025-11-03`
+
+#### Bug fixes
+
+- Remove use of private `read_dataset` internally inside {func}`anndata.experimental.read_elem_lazy` {user}`ilan-gold` ({pr}`2158`)
+- Unblock version restriction on `dask` distributed writing by using threading scheduler always (see {pr}`2172`) {user}`ilan-gold` ({pr}`2183`)
+
+#### Performance
+
+- Use `name` on {func}`dask.array.map_blocks` internally when concatenating {class}`anndata.experimental.backed.Dataset2D` objects whose categoricals/nullable types must be converted to dask arrays {user}`ilan-gold` ({pr}`2121`)
+- Enable automatic sharding in zarr v3 via {attr}`anndata.settings.auto_shard_zarr_v3` (via {mod}`zarr`'s own auto sharding mechanism i.e., `shards="auto"`) for all types except {class}`numpy.recarray` {user}`ilan-gold` ({pr}`2167`)

{anndata-0.12.4 → anndata-0.12.5}/docs/tutorials/zarr-v3.md

@@ -38,7 +38,8 @@ There are two ways of opening remote `zarr` stores from the `zarr-python` packag
 Local data generally poses a different set of challenges.
 First, write speeds can be somewhat slow and second, the creation of many small files on a file system can slow down a filesystem.
 For the "many small files" problem, `zarr` has introduced {ref}`sharding <zarr:user-guide-sharding>` in the v3 file format.
-Sharding requires knowledge of the array element you are writing (such as shape or data type), though, and therefore you will need to use {func}`anndata.experimental.write_dispatched` to use sharding.
+We offer {attr}`anndata.settings.auto_shard_zarr_v3` to hook into zarr's ability to automatically compute shards, which is experimental at the moment.
+Manual sharding requires knowledge of the array element you are writing (such as shape or data type), though, and therefore you will need to use {func}`anndata.experimental.write_dispatched` to use custom sharding.
 For example, you cannot shard a 1D array with `shard` sizes `(256, 256)`.
 Here is a short example, although you should tune the sizes to your own use-case and also use the compression that makes the most sense for you:
 

{anndata-0.12.4 → anndata-0.12.5}/pyproject.toml

@@ -164,6 +164,7 @@ filterwarnings_when_strict = [
     "default:Consolidated metadata is:UserWarning",
     "default:.*Structured:zarr.core.dtype.common.UnstableSpecificationWarning",
     "default:.*FixedLengthUTF32:zarr.core.dtype.common.UnstableSpecificationWarning",
+    "default:Automatic shard shape inference is experimental",
 ]
 python_files = "test_*.py"
 testpaths = [

{anndata-0.12.4 → anndata-0.12.5}/src/anndata/_core/merge.py

@@ -4,6 +4,7 @@ Code for merging/ concatenating AnnData objects.
 
 from __future__ import annotations
 
+import uuid
 from collections import OrderedDict
 from collections.abc import Callable, Mapping, MutableSet
 from functools import partial, reduce, singledispatch
@@ -1251,6 +1252,7 @@ def make_dask_col_from_extension_dtype(
             chunks=chunk_size,
             meta=np.array([], dtype=dtype),
             dtype=dtype,
+            name=f"{uuid.uuid4()}/{base_path_or_zarr_group}/{elem_name}-{dtype}",
         )
 
     return da.from_array(col.values, chunks=-1)  # in-memory

{anndata-0.12.4 → anndata-0.12.5}/src/anndata/_io/specs/lazy_methods.py

@@ -25,7 +25,7 @@ from anndata.compat import (
     ZarrGroup,
 )
 
-from .registry import _LAZY_REGISTRY, IOSpec
+from .registry import _LAZY_REGISTRY, IOSpec, read_elem
 
 if TYPE_CHECKING:
     from collections.abc import Generator, Mapping, Sequence
@@ -195,6 +195,9 @@ def resolve_chunks(
     return elem.chunks
 
 
+# TODO: `map_blocks` of a string array in h5py is so insanely slow on benchmarking that in the case someone has
+# a pure string annotation (not categoricals! or nullables strings!), it's probably better to pay the memory penalty.
+# In the long run, it might be good to figure out what exactly is going on here but for now, this will do.
 @_LAZY_REGISTRY.register_read(H5Array, IOSpec("string-array", "0.2.0"))
 def read_h5_string_array(
     elem: H5Array,
@@ -204,10 +207,8 @@ def read_h5_string_array(
 ) -> DaskArray:
     import dask.array as da
 
-    from anndata._io.h5ad import read_dataset
-
     chunks = resolve_chunks(elem, chunks, tuple(elem.shape))
-    return da.from_array(read_dataset(elem), chunks=chunks)
+    return da.from_array(read_elem(elem), chunks=chunks)
 
 
 @_LAZY_REGISTRY.register_read(H5Array, IOSpec("array", "0.2.0"))
@@ -303,7 +304,7 @@ def read_dataframe(
     # which is used below as well.
     if not use_range_index:
         dim_name = elem.attrs["_index"]
-        # no sense in reading this in multiple times
+        # no sense in reading this in multiple times since xarray requires an in-memory index
         index = elem_dict[dim_name].compute()
     else:
         dim_name = DUMMY_RANGE_INDEX_KEY

{anndata-0.12.4 → anndata-0.12.5}/src/anndata/_io/specs/methods.py

@@ -102,6 +102,12 @@ def zarr_v3_compressor_compat(dataset_kwargs) -> dict:
     return dataset_kwargs
 
 
+def zarr_v3_sharding(dataset_kwargs) -> dict:
+    if "shards" not in dataset_kwargs and ad.settings.auto_shard_zarr_v3:
+        dataset_kwargs = {**dataset_kwargs, "shards": "auto"}
+    return dataset_kwargs
+
+
 def _to_cpu_mem_wrapper(write_func):
     """
     Wrapper to bring cupy types into cpu memory before writing.
@@ -432,6 +438,7 @@ def write_basic(
         f.create_dataset(k, data=elem, shape=elem.shape, dtype=dtype, **dataset_kwargs)
     else:
         dataset_kwargs = zarr_v3_compressor_compat(dataset_kwargs)
+        dataset_kwargs = zarr_v3_sharding(dataset_kwargs)
         f.create_array(k, shape=elem.shape, dtype=dtype, **dataset_kwargs)
         # see https://github.com/zarr-developers/zarr-python/discussions/2712
         if isinstance(elem, ZarrArray | H5Array):
@@ -506,26 +513,17 @@ def write_basic_dask_dask_dense(
     dataset_kwargs: Mapping[str, Any] = MappingProxyType({}),
 ):
     import dask.array as da
-    import dask.config as dc
-
-    is_distributed = dc.get("scheduler", None) == "dask.distributed"
-    is_h5 = isinstance(f, H5Group)
-    if is_distributed and is_h5:
-        msg = "Cannot write dask arrays to hdf5 when using distributed scheduler"
-        raise ValueError(msg)
 
     dataset_kwargs = dataset_kwargs.copy()
+    is_h5 = isinstance(f, H5Group)
     if not is_h5:
         dataset_kwargs = zarr_v3_compressor_compat(dataset_kwargs)
-        # See https://github.com/dask/dask/issues/12109
-        if Version(version("dask")) < Version("2025.4.0") and is_distributed:
-            msg = "Writing dense data with a distributed scheduler to zarr could produce corrupted data with a Lock and will error without one when dask is older than 2025.4.0: https://github.com/dask/dask/issues/12109"
-            raise RuntimeError(msg)
+        dataset_kwargs = zarr_v3_sharding(dataset_kwargs)
     if is_zarr_v2() or is_h5:
         g = f.require_dataset(k, shape=elem.shape, dtype=elem.dtype, **dataset_kwargs)
     else:
         g = f.require_array(k, shape=elem.shape, dtype=elem.dtype, **dataset_kwargs)
-    da.store(elem, g)
+    da.store(elem, g, scheduler="threads")
 
 
 @_REGISTRY.register_read(H5Array, IOSpec("array", "0.2.0"))
@@ -626,6 +624,7 @@ def write_vlen_string_array_zarr(
         filters, fill_value = None, None
         if f.metadata.zarr_format == 2:
             filters, fill_value = [VLenUTF8()], ""
+        dataset_kwargs = zarr_v3_sharding(dataset_kwargs)
         f.create_array(
             k,
             shape=elem.shape,
@@ -694,6 +693,9 @@ def write_recarray_zarr(
     else:
         dataset_kwargs = dataset_kwargs.copy()
         dataset_kwargs = zarr_v3_compressor_compat(dataset_kwargs)
+        # https://github.com/zarr-developers/zarr-python/issues/3546
+        # if "shards" not in dataset_kwargs and ad.settings.auto_shard_zarr_v3:
+        #     dataset_kwargs = {**dataset_kwargs, "shards": "auto"}
         f.create_array(k, shape=elem.shape, dtype=elem.dtype, **dataset_kwargs)
         f[k][...] = elem
 
@@ -730,6 +732,7 @@ def write_sparse_compressed(
                 attr_name, data=attr, shape=attr.shape, dtype=dtype, **dataset_kwargs
             )
         else:
+            dataset_kwargs = zarr_v3_sharding(dataset_kwargs)
             arr = g.create_array(
                 attr_name, shape=attr.shape, dtype=dtype, **dataset_kwargs
             )

{anndata-0.12.4 → anndata-0.12.5}/src/anndata/_settings.py

@@ -17,7 +17,7 @@ from .compat import is_zarr_v2, old_positionals
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Sequence
-    from typing import Any, TypeGuard
+    from typing import Any, Self, TypeGuard
 
 T = TypeVar("T")
 
@@ -55,7 +55,7 @@ class RegisteredOption(NamedTuple, Generic[T]):
     option: str
     default_value: T
     description: str
-    validate: Callable[[T], None]
+    validate: Callable[[T, SettingsManager], None]
     type: object
 
     describe = describe
@@ -206,7 +206,7 @@ class SettingsManager:
         *,
         default_value: T,
         description: str,
-        validate: Callable[[T], None],
+        validate: Callable[[T, Self], None],
         option_type: object | None = None,
         get_from_env: Callable[[str, T], T] = lambda x, y: y,
     ) -> None:
@@ -229,7 +229,7 @@ class SettingsManager:
             Default behavior is to return `default_value` without checking the environment.
         """
         try:
-            validate(default_value)
+            validate(default_value, self)
         except (ValueError, TypeError) as e:
             e.add_note(f"for option {option!r}")
             raise e
@@ -307,7 +307,7 @@ class SettingsManager:
             )
             raise AttributeError(msg)
         registered_option = self._registered_options[option]
-        registered_option.validate(val)
+        registered_option.validate(val, self)
         self._config[option] = val
 
     def __getattr__(self, option: str) -> object:
@@ -364,10 +364,13 @@ class SettingsManager:
         """
         restore = {a: getattr(self, a) for a in overrides}
         try:
-            for attr, value in overrides.items():
-                setattr(self, attr, value)
+            # Preserve order so that settings that depend on each other can be overridden together i.e., always override zarr version before sharding
+            for k in self._config:
+                if k in overrides:
+                    setattr(self, k, overrides.get(k))
             yield None
         finally:
+            # TODO: does the order need to be preserved when restoring?
             for attr, value in restore.items():
                 setattr(self, attr, value)
 
@@ -395,7 +398,7 @@ V = TypeVar("V")
 
 
 def gen_validator(_type: type[V]) -> Callable[[V], None]:
-    def validate_type(val: V) -> None:
+    def validate_type(val: V, settings: SettingsManager) -> None:
         if not isinstance(val, _type):
             msg = f"{val} not valid {_type}"
             raise TypeError(msg)
@@ -434,14 +437,28 @@ settings.register(
 )
 
 
-def validate_zarr_write_format(format: int):
-    validate_int(format)
+def validate_zarr_write_format(format: int, settings: SettingsManager):
+    validate_int(format, settings)
     if format not in {2, 3}:
         msg = "non-v2 zarr on-disk format not supported"
         raise ValueError(msg)
     if format == 3 and is_zarr_v2():
         msg = "Cannot write v3 format against v2 package"
         raise ValueError(msg)
+    if format == 2 and getattr(settings, "auto_shard_zarr_v3", False):
+        msg = "Cannot set `zarr_write_format` to 2 with autosharding on.  Please set to `False` `anndata.settings.auto_shard_zarr_v3`"
+        raise ValueError(msg)
+
+
+def validate_zarr_sharding(auto_shard: bool, settings: SettingsManager):  # noqa: FBT001
+    validate_bool(auto_shard, settings)
+    if auto_shard:
+        if is_zarr_v2():
+            msg = "Cannot use sharding with `zarr-python<3`. Please upgrade package and set `anndata.settings.zarr_write_format` to 3."
+            raise ValueError(msg)
+        if settings.zarr_write_format == 2:
+            msg = "Cannot shard v2 format data. Please set `anndata.settings.zarr_write_format` to 3."
+            raise ValueError(msg)
 
 
 settings.register(
@@ -458,8 +475,8 @@ settings.register(
 )
 
 
-def validate_sparse_settings(val: Any) -> None:
-    validate_bool(val)
+def validate_sparse_settings(val: Any, settings: SettingsManager) -> None:
+    validate_bool(val, settings)
 
 
 settings.register(
@@ -486,6 +503,14 @@ settings.register(
     get_from_env=check_and_get_bool,
 )
 
+settings.register(
+    "auto_shard_zarr_v3",
+    default_value=False,
+    description="Whether or not to use zarr's auto computation of sharding for v3.  For v2 this setting will be ignored. The setting will apply to all calls to anndata's writing mechanism (write_zarr / write_elem) and will **not** override any user-defined kwargs for shards.",
+    validate=validate_zarr_sharding,
+    get_from_env=check_and_get_bool,
+)
+
 
 ##################################################################################
 ##################################################################################

{anndata-0.12.4 → anndata-0.12.5}/src/anndata/_settings.pyi

@@ -2,7 +2,7 @@ from collections.abc import Callable as Callable
 from collections.abc import Generator, Iterable
 from contextlib import contextmanager
 from dataclasses import dataclass
-from typing import Literal, TypeVar
+from typing import Literal, Self, TypeVar
 
 _T = TypeVar("_T")
 
@@ -25,7 +25,7 @@ class SettingsManager:
         *,
         default_value: _T,
         description: str,
-        validate: Callable[[_T], None],
+        validate: Callable[[_T, Self], None],
         option_type: object | None = None,
         get_from_env: Callable[[str, _T], _T] = ...,
     ) -> None: ...
@@ -46,5 +46,6 @@ class _AnnDataSettingsManager(SettingsManager):
     use_sparse_array_on_read: bool = False
     min_rows_for_chunked_h5_copy: int = 1000
     disallow_forward_slash_in_h5ad: bool = False
+    auto_shard_zarr_v3: bool = False
 
 settings: _AnnDataSettingsManager

{anndata-0.12.4 → anndata-0.12.5}/src/anndata/experimental/backed/_lazy_arrays.py

@@ -111,9 +111,9 @@ class CategoricalArray(XBackendArray, Generic[K]):
     def categories(self) -> np.ndarray:
         if isinstance(self._categories, ZarrArray):
             return self._categories[...]
-        from ..._io.h5ad import read_dataset
+        from anndata.io import read_elem
 
-        return read_dataset(self._categories)
+        return read_elem(self._categories)
 
     def __getitem__(
         self, key: xr.core.indexing.ExplicitIndexer

{anndata-0.12.4 → anndata-0.12.5}/src/anndata/tests/helpers.py

@@ -14,6 +14,7 @@ import h5py
 import numpy as np
 import pandas as pd
 import pytest
+import zarr
 from pandas.api.types import is_numeric_dtype
 from scipy import sparse
 
@@ -34,6 +35,7 @@ from anndata.compat import (
     XDataArray,
     XDataset,
     ZarrArray,
+    ZarrGroup,
     is_zarr_v2,
 )
 from anndata.utils import asarray
@@ -1187,3 +1189,23 @@ def get_multiindex_columns_df(shape: tuple[int, int]) -> pd.DataFrame:
             + list(itertools.product(["b"], range(shape[1] // 2)))
         ),
     )
+
+
+def visititems_zarr(
+    z: ZarrGroup, visitor: Callable[[str, ZarrGroup | zarr.Array], None]
+) -> None:
+    for key in z:
+        maybe_group = z[key]
+        if isinstance(maybe_group, ZarrGroup):
+            visititems_zarr(maybe_group, visitor)
+        else:
+            visitor(key, maybe_group)
+
+
+def check_all_sharded(g: ZarrGroup):
+    def visit(key: str, arr: zarr.Array | zarr.Group):
+        # Check for recarray via https://numpy.org/doc/stable/user/basics.rec.html#manipulating-and-displaying-structured-datatypes
+        if isinstance(arr, zarr.Array) and arr.shape != () and arr.dtype.names is None:
+            assert arr.shards is not None
+
+    visititems_zarr(g, visitor=visit)

{anndata-0.12.4 → anndata-0.12.5}/tests/test_concatenate_disk.py

@@ -8,12 +8,13 @@ import pandas as pd
 import pytest
 from scipy import sparse
 
-from anndata import AnnData, concat
+from anndata import AnnData, concat, settings
 from anndata._core import merge
 from anndata._core.merge import _resolve_axis
+from anndata.compat import is_zarr_v2
 from anndata.experimental.merge import as_group, concat_on_disk
 from anndata.io import read_elem, write_elem
-from anndata.tests.helpers import assert_equal, gen_adata
+from anndata.tests.helpers import assert_equal, check_all_sharded, gen_adata
 from anndata.utils import asarray
 
 if TYPE_CHECKING:
@@ -230,7 +231,7 @@ def xxxm_adatas():
             X=sparse.csr_matrix((2, 100)),
             obs=pd.DataFrame(index=gen_index(2)),
             obsm={
-                "sparse": np.arange(8).reshape(2, 4),
+                "sparse": sparse.csr_matrix(np.arange(8).reshape(2, 4)),
                 "dense": np.arange(4, 8).reshape(2, 2),
                 "df": pd.DataFrame(
                     {
@@ -253,6 +254,22 @@ def test_concatenate_xxxm(xxxm_adatas, tmp_path, file_format, join_type):
     assert_eq_concat_on_disk(xxxm_adatas, tmp_path, file_format, join=join_type)
 
 
+@pytest.mark.skipif(is_zarr_v2(), reason="auto sharding is allowed only for zarr v3.")
+def test_concatenate_zarr_v3_shard(xxxm_adatas, tmp_path):
+    import zarr
+
+    with settings.override(auto_shard_zarr_v3=True, zarr_write_format=3):
+        assert_eq_concat_on_disk(xxxm_adatas, tmp_path, file_format="zarr")
+    g = zarr.open(tmp_path)
+    assert g.metadata.zarr_format == 3
+
+    def visit(key: str, arr: zarr.Array | zarr.Group):
+        if isinstance(arr, zarr.Array) and arr.shape != ():
+            assert arr.shards is not None
+
+    check_all_sharded(g)
+
+
 def test_output_dir_exists(tmp_path):
     in_pth = tmp_path / "in.h5ad"
     out_pth = tmp_path / "does_not_exist" / "out.h5ad"

{anndata-0.12.4 → anndata-0.12.5}/tests/test_dask.py

@@ -4,14 +4,12 @@ For tests using dask
 
 from __future__ import annotations
 
-from importlib.metadata import version
 from pathlib import Path
 from typing import TYPE_CHECKING
 
 import numpy as np
 import pandas as pd
 import pytest
-from packaging.version import Version
 from scipy import sparse
 
 import anndata as ad
@@ -25,6 +23,7 @@ from anndata.tests.helpers import (
     as_dense_dask_array,
     as_sparse_dask_array,
     assert_equal,
+    check_all_sharded,
     gen_adata,
 )
 
@@ -111,12 +110,20 @@ def test_dask_write(adata, tmp_path, diskfmt):
 
 @pytest.mark.xdist_group("dask")
 @pytest.mark.dask_distributed
+@pytest.mark.parametrize(
+    "auto_shard_zarr_v3",
+    [pytest.param(True, id="shard"), pytest.param(False, id="no-shard")],
+)
 def test_dask_distributed_write(
     adata: AnnData,
     tmp_path: Path,
     diskfmt: Literal["h5ad", "zarr"],
     local_cluster_addr: str,
+    *,
+    auto_shard_zarr_v3: bool,
 ) -> None:
+    if auto_shard_zarr_v3 and ad.settings.zarr_write_format == 2:
+        pytest.skip(reason="Cannot shard v2 data")
     import dask.array as da
     import dask.distributed as dd
     import numpy as np
@@ -130,20 +137,12 @@ def test_dask_distributed_write(
         adata.obsm["b"] = da.random.random((M, 10))
         adata.varm["a"] = da.random.random((N, 10))
         orig = adata
-        is_h5 = diskfmt == "h5ad"
-        is_corrupted_dask = Version(version("dask")) < Version("2025.4.0")
-        if is_corrupted_dask or is_h5:
-            with pytest.raises(
-                ValueError if is_h5 else RuntimeError,
-                match=r"Cannot write dask arrays to hdf5"
-                if is_h5
-                else r"Writing dense data with a distributed scheduler to zarr",
-            ):
-                ad.io.write_elem(g, "", orig)
-            return
-        ad.io.write_elem(g, "", orig)
+        with ad.settings.override(auto_shard_zarr_v3=auto_shard_zarr_v3):
+            ad.io.write_elem(g, "", orig)
         # TODO: See https://github.com/zarr-developers/zarr-python/issues/2716
         g = as_group(pth, mode="r")
+        if auto_shard_zarr_v3:
+            check_all_sharded(g)
         curr = ad.io.read_elem(g)
 
     with pytest.raises(AssertionError):

{anndata-0.12.4 → anndata-0.12.5}/tests/test_dask_view_mem.py

@@ -72,7 +72,7 @@ def _alloc_cache():
 # As of 2025.09.* dask, this needs a bit more than the previous 1.5mb.
 # TODO: Why?
 @pytest.mark.usefixtures("_alloc_cache")
-@pytest.mark.limit_memory("1.7 MB")
+@pytest.mark.limit_memory("2.2 MB")
 def test_size_of_view(mapping_name, give_chunks):
     import dask.array as da
 

{anndata-0.12.4 → anndata-0.12.5}/tests/test_io_dispatched.py

@@ -12,10 +12,14 @@ import anndata as ad
 from anndata._io.zarr import open_write_group
 from anndata.compat import CSArray, CSMatrix, ZarrGroup, is_zarr_v2
 from anndata.experimental import read_dispatched, write_dispatched
-from anndata.tests.helpers import GEN_ADATA_NO_XARRAY_ARGS, assert_equal, gen_adata
+from anndata.tests.helpers import (
+    GEN_ADATA_NO_XARRAY_ARGS,
+    assert_equal,
+    gen_adata,
+    visititems_zarr,
+)
 
 if TYPE_CHECKING:
-    from collections.abc import Callable
     from pathlib import Path
     from typing import Literal
 
@@ -180,18 +184,7 @@ def test_write_dispatched_chunks(tmp_path: Path):
     if is_zarr_v2():
         z.visititems(check_chunking)
     else:
-
-        def visititems(
-            z: ZarrGroup, visitor: Callable[[str, ZarrGroup | zarr.Array], None]
-        ) -> None:
-            for key in z:
-                maybe_group = z[key]
-                if isinstance(maybe_group, ZarrGroup):
-                    visititems(maybe_group, visitor)
-                else:
-                    visitor(key, maybe_group)
-
-        visititems(z, check_chunking)
+        visititems_zarr(z, check_chunking)
 
 
 @pytest.mark.zarr_io