(fix): skip X writing when X is None

docs/release-notes/2054.bugfix.md

@@ -0,0 +1 @@
+Revert accidental change where {attr}`~anndata.AnnData.X` got written to disk when it was `None` {user}`flying-sheep`

src/anndata/_io/h5ad.py

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

src/anndata/_io/specs/methods.py

@@ -275,7 +275,8 @@ def write_anndata(
     dataset_kwargs: Mapping[str, Any] = MappingProxyType({}),
 ):
     g = f.require_group(k)
-    _writer.write_elem(g, "X", adata.X, dataset_kwargs=dataset_kwargs)
+    if adata.X is not None:
+        _writer.write_elem(g, "X", adata.X, dataset_kwargs=dataset_kwargs)
     _writer.write_elem(g, "obs", adata.obs, dataset_kwargs=dataset_kwargs)
     _writer.write_elem(g, "var", adata.var, dataset_kwargs=dataset_kwargs)
     _writer.write_elem(g, "obsm", dict(adata.obsm), dataset_kwargs=dataset_kwargs)

src/anndata/_io/zarr.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from pathlib import Path
 from typing import TYPE_CHECKING, TypeVar
 from warnings import warn
 
@@ -37,8 +36,6 @@ def write_zarr(
     **ds_kwargs,
 ) -> None:
     """See :meth:`~anndata.AnnData.write_zarr`."""
-    if isinstance(store, Path):
-        store = str(store)
     if convert_strings_to_categoricals:
         adata.strings_to_categoricals()
         if adata.raw is not None:
@@ -75,9 +72,6 @@ def read_zarr(store: PathLike[str] | str | MutableMapping | zarr.Group) -> AnnDa
     store
         The filename, a :class:`~typing.MutableMapping`, or a Zarr storage class.
     """
-    if isinstance(store, Path):
-        store = str(store)
-
     f = store if isinstance(store, zarr.Group) else zarr.open(store, mode="r")
 
     # Read with handling for backwards compat

tests/conftest.py

@@ -24,11 +24,12 @@
 
 if TYPE_CHECKING:
     from collections.abc import Generator
+    from pathlib import Path
     from types import EllipsisType
 
 
 @pytest.fixture
-def backing_h5ad(tmp_path):
+def backing_h5ad(tmp_path: Path) -> Path:
     return tmp_path / "test.h5ad"
 
 

tests/test_backed_hdf5.py

@@ -108,7 +108,7 @@ def test_read_write_X(tmp_path, mtx_format, backed_mode, as_dense):
 
 # this is very similar to the views test
 @pytest.mark.filterwarnings("ignore::anndata.ImplicitModificationWarning")
-def test_backing(adata, tmp_path, backing_h5ad):
+def test_backing(adata: ad.AnnData, tmp_path: Path, backing_h5ad: Path) -> None:
     assert not adata.isbacked
 
     adata.filename = backing_h5ad

tests/test_readwrite.py

@@ -2,7 +2,7 @@
 
 import re
 import warnings
-from contextlib import contextmanager
+from contextlib import contextmanager, nullcontext
 from functools import partial
 from importlib.util import find_spec
 from pathlib import Path
@@ -38,6 +38,7 @@
 )
 
 if TYPE_CHECKING:
+    from collections.abc import Generator
     from typing import Literal
 
 HERE = Path(__file__).parent
@@ -100,6 +101,15 @@ def rw(backing_h5ad):
     return curr, orig
 
 
+@contextmanager
+def open_store(
+    path: Path, diskfmt: Literal["h5ad", "zarr"]
+) -> Generator[h5py.File | zarr.Group, None, None]:
+    f = zarr.open_group(path) if diskfmt == "zarr" else h5py.File(path, "r")
+    with f if isinstance(f, h5py.File) else nullcontext():
+        yield f
+
+
 @pytest.fixture(params=[np.uint8, np.int32, np.int64, np.float32, np.float64])
 def dtype(request):
     return request.param
@@ -403,10 +413,10 @@ def check_compressed(value, key):
             not_compressed.append(key)
 
     if is_zarr_v2():
-        with zarr.open(str(pth), "r") as f:
+        with zarr.open(pth, "r") as f:
             f.visititems(check_compressed)
     else:
-        f = zarr.open(str(pth), mode="r")
+        f = zarr.open(pth, mode="r")
         for key, value in f.members(max_depth=None):
             check_compressed(value, key)
 
@@ -765,12 +775,24 @@ def test_zarr_chunk_X(tmp_path):
     adata = gen_adata((100, 100), X_type=np.array, **GEN_ADATA_NO_XARRAY_ARGS)
     adata.write_zarr(zarr_pth, chunks=(10, 10))
 
-    z = zarr.open(str(zarr_pth))  # As of v2.3.2 zarr won’t take a Path
+    z = zarr.open(zarr_pth)
     assert z["X"].chunks == (10, 10)
     from_zarr = ad.read_zarr(zarr_pth)
     assert_equal(from_zarr, adata)
 
 
+def test_write_x_none(tmp_path: Path, diskfmt: Literal["h5ad", "zarr"]) -> None:
+    adata = ad.AnnData(shape=(10, 10), obs={"a": np.ones(10)}, var={"b": np.ones(10)})
+    p = tmp_path / f"adata.{diskfmt}"
+    write = getattr(adata, f"write_{diskfmt}")
+
+    write(p)
+    with open_store(p, diskfmt) as f:
+        root_keys = list(f.keys())
+
+    assert "X" not in root_keys
+
+
 ################################
 # Round-tripping scanpy datasets
 ################################