anndata 0.12.2__py3-none-any.whl → 0.12.4__py3-none-any.whl

anndata/_io/specs/lazy_methods.py

@@ -37,7 +37,7 @@ if TYPE_CHECKING:
     from .registry import LazyDataStructures, LazyReader
 
     BlockInfo = Mapping[
-        Literal[None],
+        None,
         dict[str, Sequence[tuple[int, int]]],
     ]
 

anndata/_io/specs/methods.py

@@ -4,6 +4,7 @@ import warnings
 from collections.abc import Mapping
 from copy import copy
 from functools import partial
+from importlib.metadata import version
 from itertools import product
 from types import MappingProxyType
 from typing import TYPE_CHECKING
@@ -21,7 +22,7 @@ from anndata._core import views
 from anndata._core.index import _normalize_indices
 from anndata._core.merge import intersect_keys
 from anndata._core.sparse_dataset import _CSCDataset, _CSRDataset, sparse_dataset
-from anndata._io.utils import H5PY_V3, check_key, zero_dim_array_as_scalar
+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,
@@ -492,31 +493,12 @@ _REGISTRY.register_write(ZarrGroup, CupyArray, IOSpec("array", "0.2.0"))(
 )
 
 
+@_REGISTRY.register_write(ZarrGroup, views.DaskArrayView, IOSpec("array", "0.2.0"))
 @_REGISTRY.register_write(ZarrGroup, DaskArray, IOSpec("array", "0.2.0"))
-def write_basic_dask_zarr(
-    f: ZarrGroup,
-    k: str,
-    elem: DaskArray,
-    *,
-    _writer: Writer,
-    dataset_kwargs: Mapping[str, Any] = MappingProxyType({}),
-):
-    import dask.array as da
-
-    dataset_kwargs = dataset_kwargs.copy()
-    dataset_kwargs = zarr_v3_compressor_compat(dataset_kwargs)
-    if is_zarr_v2():
-        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, lock=GLOBAL_LOCK)
-
-
-# Adding this separately because h5py isn't serializable
-# https://github.com/pydata/xarray/issues/4242
+@_REGISTRY.register_write(H5Group, views.DaskArrayView, IOSpec("array", "0.2.0"))
 @_REGISTRY.register_write(H5Group, DaskArray, IOSpec("array", "0.2.0"))
-def write_basic_dask_h5(
-    f: H5Group,
+def write_basic_dask_dask_dense(
+    f: ZarrGroup | H5Group,
     k: str,
     elem: DaskArray,
     *,
@@ -526,11 +508,23 @@ def write_basic_dask_h5(
     import dask.array as da
     import dask.config as dc
 
-    if dc.get("scheduler", None) == "dask.distributed":
+    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)
 
-    g = f.require_dataset(k, shape=elem.shape, dtype=elem.dtype, **dataset_kwargs)
+    dataset_kwargs = dataset_kwargs.copy()
+    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)
+    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)
 
 
@@ -607,7 +601,7 @@ def write_vlen_string_array_zarr(
     if is_zarr_v2():
         import numcodecs
 
-        if Version(numcodecs.__version__) < Version("0.13"):
+        if Version(version("numcodecs")) < Version("0.13"):
             msg = "Old numcodecs version detected. Please update for improved performance and stability."
             warnings.warn(msg, UserWarning, stacklevel=2)
             # Workaround for https://github.com/zarr-developers/numcodecs/issues/514
@@ -663,10 +657,9 @@ def _to_hdf5_vlen_strings(value: np.ndarray) -> np.ndarray:
 @_REGISTRY.register_read(ZarrArray, IOSpec("rec-array", "0.2.0"))
 def read_recarray(d: ArrayStorageType, *, _reader: Reader) -> np.recarray | npt.NDArray:
     value = d[()]
-    dtype = value.dtype
-    value = _from_fixed_length_strings(value)
-    if H5PY_V3:
-        value = _decode_structured_array(value, dtype=dtype)
+    value = _decode_structured_array(
+        _from_fixed_length_strings(value), dtype=value.dtype
+    )
     return value
 
 
@@ -778,10 +771,10 @@ for store_type, (cls, spec, func) in product(
     _REGISTRY.register_write(store_type, cls, spec)(func)
 
 
-@_REGISTRY.register_write(H5Group, _CSRDataset, IOSpec("", "0.1.0"))
-@_REGISTRY.register_write(H5Group, _CSCDataset, IOSpec("", "0.1.0"))
-@_REGISTRY.register_write(ZarrGroup, _CSRDataset, IOSpec("", "0.1.0"))
-@_REGISTRY.register_write(ZarrGroup, _CSCDataset, IOSpec("", "0.1.0"))
+@_REGISTRY.register_write(H5Group, _CSRDataset, IOSpec("csr_matrix", "0.1.0"))
+@_REGISTRY.register_write(H5Group, _CSCDataset, IOSpec("csc_matrix", "0.1.0"))
+@_REGISTRY.register_write(ZarrGroup, _CSRDataset, IOSpec("csr_matrix", "0.1.0"))
+@_REGISTRY.register_write(ZarrGroup, _CSCDataset, IOSpec("csc_matrix", "0.1.0"))
 def write_sparse_dataset(
     f: GroupStorageType,
     k: str,
@@ -798,26 +791,9 @@ def write_sparse_dataset(
         fmt=elem.format,
         dataset_kwargs=dataset_kwargs,
     )
-    # TODO: Cleaner way to do this
-    f[k].attrs["encoding-type"] = f"{elem.format}_matrix"
-    f[k].attrs["encoding-version"] = "0.1.0"
 
 
-@_REGISTRY.register_write(H5Group, (DaskArray, CupyArray), IOSpec("array", "0.2.0"))
-@_REGISTRY.register_write(ZarrGroup, (DaskArray, CupyArray), IOSpec("array", "0.2.0"))
-@_REGISTRY.register_write(
-    H5Group, (DaskArray, CupyCSRMatrix), IOSpec("csr_matrix", "0.1.0")
-)
-@_REGISTRY.register_write(
-    H5Group, (DaskArray, CupyCSCMatrix), IOSpec("csc_matrix", "0.1.0")
-)
-@_REGISTRY.register_write(
-    ZarrGroup, (DaskArray, CupyCSRMatrix), IOSpec("csr_matrix", "0.1.0")
-)
-@_REGISTRY.register_write(
-    ZarrGroup, (DaskArray, CupyCSCMatrix), IOSpec("csc_matrix", "0.1.0")
-)
-def write_cupy_dask_sparse(f, k, elem, _writer, dataset_kwargs=MappingProxyType({})):
+def write_cupy_dask(f, k, elem, _writer, dataset_kwargs=MappingProxyType({})):
     _writer.write_elem(
         f,
         k,
@@ -826,18 +802,6 @@ def write_cupy_dask_sparse(f, k, elem, _writer, dataset_kwargs=MappingProxyType(
     )
 
 
-@_REGISTRY.register_write(
-    H5Group, (DaskArray, sparse.csr_matrix), IOSpec("csr_matrix", "0.1.0")
-)
-@_REGISTRY.register_write(
-    H5Group, (DaskArray, sparse.csc_matrix), IOSpec("csc_matrix", "0.1.0")
-)
-@_REGISTRY.register_write(
-    ZarrGroup, (DaskArray, sparse.csr_matrix), IOSpec("csr_matrix", "0.1.0")
-)
-@_REGISTRY.register_write(
-    ZarrGroup, (DaskArray, sparse.csc_matrix), IOSpec("csc_matrix", "0.1.0")
-)
 def write_dask_sparse(
     f: GroupStorageType,
     k: str,
@@ -886,6 +850,26 @@ def write_dask_sparse(
         disk_mtx.append(elem[chunk_slice(chunk_start, chunk_stop)].compute())
 
 
+for array_type, group_type in product(
+    [DaskArray, views.DaskArrayView], [H5Group, ZarrGroup]
+):
+    for cupy_array_type, spec in [
+        (CupyArray, IOSpec("array", "0.2.0")),
+        (CupyCSCMatrix, IOSpec("csc_matrix", "0.1.0")),
+        (CupyCSRMatrix, IOSpec("csr_matrix", "0.1.0")),
+    ]:
+        _REGISTRY.register_write(group_type, (array_type, cupy_array_type), spec)(
+            write_cupy_dask
+        )
+    for scipy_sparse_type, spec in [
+        (sparse.csr_matrix, IOSpec("csr_matrix", "0.1.0")),
+        (sparse.csc_matrix, IOSpec("csc_matrix", "0.1.0")),
+    ]:
+        _REGISTRY.register_write(group_type, (array_type, scipy_sparse_type), spec)(
+            write_dask_sparse
+        )
+
+
 @_REGISTRY.register_read(H5Group, IOSpec("csc_matrix", "0.1.0"))
 @_REGISTRY.register_read(H5Group, IOSpec("csr_matrix", "0.1.0"))
 @_REGISTRY.register_read(ZarrGroup, IOSpec("csc_matrix", "0.1.0"))

anndata/_io/specs/registry.py

@@ -9,6 +9,7 @@ from types import MappingProxyType
 from typing import TYPE_CHECKING, Generic, TypeVar
 
 from anndata._io.utils import report_read_key_on_error, report_write_key_on_error
+from anndata._settings import settings
 from anndata._types import Read, ReadLazy, _ReadInternal, _ReadLazyInternal
 from anndata.compat import DaskArray, ZarrGroup, _read_attr, is_zarr_v2
 
@@ -240,12 +241,9 @@ def proc_spec_mapping(spec: Mapping[str, str]) -> IOSpec:
 def get_spec(
     elem: StorageType,
 ) -> IOSpec:
-    return proc_spec(
-        {
-            k: _read_attr(elem.attrs, k, "")
-            for k in ["encoding-type", "encoding-version"]
-        }
-    )
+    return proc_spec({
+        k: _read_attr(elem.attrs, k, "") for k in ["encoding-type", "encoding-version"]
+    })
 
 
 def _iter_patterns(
@@ -349,10 +347,17 @@ class Writer:
 
         import h5py
 
+        from anndata._io.zarr import is_group_consolidated
+
         # we allow stores to have a prefix like /uns which are then written to with keys like /uns/foo
+        is_zarr_group = isinstance(store, ZarrGroup)
         if "/" in k.split(store.name)[-1][1:]:
-            msg = "Forward slashes are not allowed in keys."
-            raise ValueError(msg)
+            if is_zarr_group or settings.disallow_forward_slash_in_h5ad:
+                msg = f"Forward slashes are not allowed in keys in {type(store)}"
+                raise ValueError(msg)
+            else:
+                msg = "Forward slashes will be disallowed in h5 stores in the next minor release"
+                warnings.warn(msg, FutureWarning, stacklevel=2)
 
         if isinstance(store, h5py.File):
             store = store["/"]
@@ -360,19 +365,11 @@ class Writer:
         dest_type = type(store)
 
         # Normalize k to absolute path
-        if (
-            is_zarr_v2_store := (
-                (is_zarr_store := isinstance(store, ZarrGroup)) and is_zarr_v2()
-            )
-        ) or (isinstance(store, h5py.Group) and not PurePosixPath(k).is_absolute()):
+        if (is_zarr_group and is_zarr_v2()) or (
+            isinstance(store, h5py.Group) and not PurePosixPath(k).is_absolute()
+        ):
             k = str(PurePosixPath(store.name) / k)
-        is_consolidated = False
-        if is_zarr_v2_store:
-            from zarr.storage import ConsolidatedMetadataStore
-
-            is_consolidated = isinstance(store.store, ConsolidatedMetadataStore)
-        elif is_zarr_store:
-            is_consolidated = store.metadata.consolidated_metadata is not None
+        is_consolidated = is_group_consolidated(store) if is_zarr_group else False
         if is_consolidated:
             msg = "Cannot overwrite/edit a store with consolidated metadata"
             raise ValueError(msg)

anndata/_io/utils.py

@@ -1,13 +1,11 @@
 from __future__ import annotations
 
+from collections.abc import Callable
 from functools import WRAPPER_ASSIGNMENTS, wraps
 from itertools import pairwise
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING, Literal, cast
 from warnings import warn
 
-import h5py
-from packaging.version import Version
-
 from .._core.sparse_dataset import BaseCompressedSparseDataset
 
 if TYPE_CHECKING:
@@ -21,9 +19,6 @@ if TYPE_CHECKING:
 
     Storage = StorageType | BaseCompressedSparseDataset
 
-# For allowing h5py v3
-# https://github.com/scverse/anndata/issues/442
-H5PY_V3 = Version(h5py.__version__).major >= 3
 
 # -------------------------------------------------------------------------------
 # Type conversion

anndata/_io/zarr.py

@@ -77,13 +77,11 @@ def read_zarr(store: PathLike[str] | str | MutableMapping | zarr.Group) -> AnnDa
     # Read with handling for backwards compat
     def callback(func, elem_name: str, elem, iospec):
         if iospec.encoding_type == "anndata" or elem_name.endswith("/"):
-            return AnnData(
-                **{
-                    k: read_dispatched(v, callback)
-                    for k, v in dict(elem).items()
-                    if not k.startswith("raw.")
-                }
-            )
+            return AnnData(**{
+                k: read_dispatched(v, callback)
+                for k, v in dict(elem).items()
+                if not k.startswith("raw.")
+            })
         elif elem_name.startswith("/raw."):
             return None
         elif elem_name in {"/obs", "/var"}:
@@ -155,3 +153,14 @@ def open_write_group(
     if not is_zarr_v2() and "zarr_format" not in kwargs:
         kwargs["zarr_format"] = settings.zarr_write_format
     return zarr.open_group(store, mode=mode, **kwargs)
+
+
+def is_group_consolidated(group: zarr.Group) -> bool:
+    if not isinstance(group, zarr.Group):
+        msg = f"Expected zarr.Group, got {type(group)}"
+        raise TypeError(msg)
+    if is_zarr_v2():
+        from zarr.storage import ConsolidatedMetadataStore
+
+        return isinstance(group.store, ConsolidatedMetadataStore)
+    return group.metadata.consolidated_metadata is not None

anndata/_settings.py

@@ -478,6 +478,14 @@ settings.register(
     get_from_env=check_and_get_int,
 )
 
+settings.register(
+    "disallow_forward_slash_in_h5ad",
+    default_value=False,
+    description="Whether or not to disallow the `/` character in keys for h5ad files",
+    validate=validate_bool,
+    get_from_env=check_and_get_bool,
+)
+
 
 ##################################################################################
 ##################################################################################

anndata/_settings.pyi

@@ -45,5 +45,6 @@ class _AnnDataSettingsManager(SettingsManager):
     zarr_write_format: Literal[2, 3] = 2
     use_sparse_array_on_read: bool = False
     min_rows_for_chunked_h5_copy: int = 1000
+    disallow_forward_slash_in_h5ad: bool = False
 
 settings: _AnnDataSettingsManager

anndata/compat/__init__.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from codecs import decode
 from collections.abc import Mapping, Sequence
 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
@@ -75,10 +76,9 @@ H5File = h5py.File
 #############################
 @cache
 def is_zarr_v2() -> bool:
-    import zarr
     from packaging.version import Version
 
-    return Version(zarr.__version__) < Version("3.0.0")
+    return Version(version("zarr")) < Version("3.0.0")
 
 
 if is_zarr_v2():
@@ -213,7 +213,7 @@ else:
 
 NULLABLE_NUMPY_STRING_TYPE = (
     np.dtype("O")
-    if Version(np.__version__) < Version("2")
+    if Version(version("numpy")) < Version("2")
     else np.dtypes.StringDType(na_object=pd.NA)
 )
 
@@ -428,11 +428,3 @@ def _safe_transpose(x):
         return _transpose_by_block(x)
     else:
         return x.T
-
-
-def _map_cat_to_str(cat: pd.Categorical) -> pd.Categorical:
-    if Version(pd.__version__) >= Version("2.1"):
-        # Argument added in pandas 2.1
-        return cat.map(str, na_action="ignore")
-    else:
-        return cat.map(str)

anndata/experimental/backed/_lazy_arrays.py

@@ -25,9 +25,10 @@ if TYPE_CHECKING:
     from pathlib import Path
     from typing import Literal
 
-    from anndata._core.index import Index
     from anndata.compat import ZarrGroup
 
+    from ...compat import Index1DNorm
+
 
 K = TypeVar("K", H5Array, ZarrArray)
 
@@ -199,7 +200,9 @@ class MaskedArray(XBackendArray, Generic[K]):
 
 
 @_subset.register(XDataArray)
-def _subset_masked(a: XDataArray, subset_idx: Index):
+def _subset_masked(
+    a: XDataArray, subset_idx: tuple[Index1DNorm] | tuple[Index1DNorm, Index1DNorm]
+):
     return a[subset_idx]
 
 

anndata/experimental/merge.py

@@ -26,8 +26,8 @@ from .._core.merge import (
 )
 from .._core.sparse_dataset import BaseCompressedSparseDataset, sparse_dataset
 from .._io.specs import read_elem, write_elem
-from ..compat import H5Array, H5Group, ZarrArray, ZarrGroup, _map_cat_to_str
-from . import read_dispatched
+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
@@ -173,7 +173,7 @@ def write_concat_dense(  # noqa: PLR0917
     output_path: ZarrGroup | H5Group,
     axis: Literal[0, 1] = 0,
     reindexers: Reindexer | None = None,
-    fill_value=None,
+    fill_value: Any = None,
 ):
     """
     Writes the concatenation of given dense arrays to disk using dask.
@@ -193,9 +193,10 @@ def write_concat_dense(  # noqa: PLR0917
         axis=axis,
     )
     write_elem(output_group, output_path, res)
-    output_group[output_path].attrs.update(
-        {"encoding-type": "array", "encoding-version": "0.2.0"}
-    )
+    output_group[output_path].attrs.update({
+        "encoding-type": "array",
+        "encoding-version": "0.2.0",
+    })
 
 
 def write_concat_sparse(  # noqa: PLR0917
@@ -205,7 +206,7 @@ def write_concat_sparse(  # noqa: PLR0917
     max_loaded_elems: int,
     axis: Literal[0, 1] = 0,
     reindexers: Reindexer | None = None,
-    fill_value=None,
+    fill_value: Any = None,
 ):
     """
     Writes and concatenates sparse datasets into a single output dataset.
@@ -245,26 +246,24 @@ def write_concat_sparse(  # noqa: PLR0917
 
 
 def _write_concat_mappings(  # noqa: PLR0913, PLR0917
-    mappings,
+    mappings: Collection[dict],
     output_group: ZarrGroup | H5Group,
-    keys,
-    path,
-    max_loaded_elems,
-    axis=0,
-    index=None,
-    reindexers=None,
-    fill_value=None,
+    keys: Collection[str],
+    output_path: str | Path,
+    max_loaded_elems: int,
+    axis: Literal[0, 1] = 0,
+    index: pd.Index = None,
+    reindexers: list[Reindexer] | None = None,
+    fill_value: Any = None,
 ):
     """
     Write a list of mappings to a zarr/h5 group.
     """
-    mapping_group = output_group.create_group(path)
-    mapping_group.attrs.update(
-        {
-            "encoding-type": "dict",
-            "encoding-version": "0.1.0",
-        }
-    )
+    mapping_group = output_group.create_group(output_path)
+    mapping_group.attrs.update({
+        "encoding-type": "dict",
+        "encoding-version": "0.1.0",
+    })
     for k in keys:
         elems = [m[k] for m in mappings]
         _write_concat_sequence(
@@ -281,13 +280,13 @@ def _write_concat_mappings(  # noqa: PLR0913, PLR0917
 
 def _write_concat_arrays(  # noqa: PLR0913, PLR0917
     arrays: Sequence[ZarrArray | H5Array | BaseCompressedSparseDataset],
-    output_group,
-    output_path,
-    max_loaded_elems,
-    axis=0,
-    reindexers=None,
-    fill_value=None,
-    join="inner",
+    output_group: ZarrGroup | H5Group,
+    output_path: str | Path,
+    max_loaded_elems: int,
+    axis: Literal[0, 1] = 0,
+    reindexers: list[Reindexer] | None = None,
+    fill_value: Any = None,
+    join: Literal["inner", "outer"] = "inner",
 ):
     init_elem = arrays[0]
     init_type = type(init_elem)
@@ -325,14 +324,14 @@ def _write_concat_arrays(  # noqa: PLR0913, PLR0917
 
 def _write_concat_sequence(  # noqa: PLR0913, PLR0917
     arrays: Sequence[pd.DataFrame | BaseCompressedSparseDataset | H5Array | ZarrArray],
-    output_group,
-    output_path,
-    max_loaded_elems,
-    axis=0,
-    index=None,
-    reindexers=None,
-    fill_value=None,
-    join="inner",
+    output_group: ZarrGroup | H5Group,
+    output_path: str | Path,
+    max_loaded_elems: int,
+    axis: Literal[0, 1] = 0,
+    index: pd.Index = None,
+    reindexers: list[Reindexer] | None = None,
+    fill_value: Any = None,
+    join: Literal["inner", "outer"] = "inner",
 ):
     """
     array, dataframe, csc_matrix, csc_matrix
@@ -377,17 +376,27 @@ def _write_concat_sequence(  # noqa: PLR0913, PLR0917
         raise NotImplementedError(msg)
 
 
-def _write_alt_mapping(groups, output_group, alt_axis_name, alt_indices, merge):
-    alt_mapping = merge([read_as_backed(g[alt_axis_name]) for g in groups])
-    # If its empty, we need to write an empty dataframe with the correct index
-    if not alt_mapping:
-        alt_df = pd.DataFrame(index=alt_indices)
-        write_elem(output_group, alt_axis_name, alt_df)
-    else:
-        write_elem(output_group, alt_axis_name, alt_mapping)
+def _write_alt_mapping(
+    groups: Collection[H5Group, ZarrGroup],
+    output_group: ZarrGroup | H5Group,
+    alt_axis_name: Literal["obs", "var"],
+    merge: Callable,
+    reindexers: list[Reindexer],
+):
+    alt_mapping = merge([
+        {k: r(read_elem(v), axis=0) for k, v in dict(g[f"{alt_axis_name}m"]).items()}
+        for r, g in zip(reindexers, groups, strict=True)
+    ])
+    write_elem(output_group, f"{alt_axis_name}m", alt_mapping)
 
 
-def _write_alt_annot(groups, output_group, alt_axis_name, alt_indices, merge):
+def _write_alt_annot(
+    groups: Collection[H5Group, ZarrGroup],
+    output_group: ZarrGroup | H5Group,
+    alt_axis_name: Literal["obs", "var"],
+    alt_indices: pd.Index,
+    merge: Callable,
+):
     # Annotation for other axis
     alt_annot = merge_dataframes(
         [read_elem(g[alt_axis_name]) for g in groups], alt_indices, merge
@@ -396,7 +405,13 @@ def _write_alt_annot(groups, output_group, alt_axis_name, alt_indices, merge):
 
 
 def _write_axis_annot(  # noqa: PLR0917
-    groups, output_group, axis_name, concat_indices, label, label_col, join
+    groups: Collection[H5Group, ZarrGroup],
+    output_group: ZarrGroup | H5Group,
+    axis_name: Literal["obs", "var"],
+    concat_indices: pd.Index,
+    label: str,
+    label_col: str,
+    join: Literal["inner", "outer"],
 ):
     concat_annot = pd.concat(
         unify_dtypes(read_elem(g[axis_name]) for g in groups),
@@ -409,6 +424,23 @@ def _write_axis_annot(  # noqa: PLR0917
     write_elem(output_group, axis_name, concat_annot)
 
 
+def _write_alt_pairwise(
+    groups: Collection[H5Group, ZarrGroup],
+    output_group: ZarrGroup | H5Group,
+    alt_axis_name: Literal["obs", "var"],
+    merge: Callable,
+    reindexers: list[Reindexer],
+):
+    alt_pairwise = merge([
+        {
+            k: r(r(read_elem_lazy(v), axis=0), axis=1)
+            for k, v in dict(g[f"{alt_axis_name}p"]).items()
+        }
+        for r, g in zip(reindexers, groups, strict=True)
+    ])
+    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,
@@ -491,7 +523,8 @@ def concat_on_disk(  # noqa: PLR0912, PLR0913, PLR0915
         DataFrames are padded with missing values.
     pairwise
         Whether pairwise elements along the concatenated dimension should be included.
-        This is False by default, since the resulting arrays are often not meaningful.
+        This is False by default, since the resulting arrays are often not meaningful, and raises {class}`NotImplementedError` when True.
+        If you are interested in this feature, please open an issue.
 
     Notes
     -----
@@ -610,7 +643,7 @@ def concat_on_disk(  # noqa: PLR0912, PLR0913, PLR0915
     )
     if index_unique is not None:
         concat_indices = concat_indices.str.cat(
-            _map_cat_to_str(label_col), sep=index_unique
+            label_col.map(str, na_action="ignore"), sep=index_unique
         )
 
     # Resulting indices for {axis_name} and {alt_axis_name}
@@ -635,7 +668,10 @@ def concat_on_disk(  # noqa: PLR0912, PLR0913, PLR0915
     _write_alt_annot(groups, output_group, alt_axis_name, alt_index, merge)
 
     # Write {alt_axis_name}m
-    _write_alt_mapping(groups, output_group, alt_axis_name, alt_index, merge)
+    _write_alt_mapping(groups, output_group, alt_axis_name, merge, reindexers)
+
+    # Write {alt_axis_name}p
+    _write_alt_pairwise(groups, output_group, alt_axis_name, merge, reindexers)
 
     # Write X
 

anndata/experimental/multi_files/_anncollection.py

@@ -16,7 +16,7 @@ from ..._core.index import _normalize_index, _normalize_indices
 from ..._core.merge import concat_arrays, inner_concat_aligned_mapping
 from ..._core.sparse_dataset import BaseCompressedSparseDataset
 from ..._core.views import _resolve_idx
-from ...compat import _map_cat_to_str, old_positionals
+from ...compat import old_positionals
 
 if TYPE_CHECKING:
     from collections.abc import Iterable, Sequence
@@ -731,7 +731,7 @@ class AnnCollection(_ConcatViewMixin, _IterateViewMixin):
         )
         if index_unique is not None:
             concat_indices = concat_indices.str.cat(
-                _map_cat_to_str(label_col), sep=index_unique
+                label_col.map(str, na_action="ignore"), sep=index_unique
             )
         self.obs_names = pd.Index(concat_indices)