Fix garbage collection

src/anndata/_core/aligned_mapping.py

@@ -3,19 +3,17 @@
 import warnings
 from abc import ABC, abstractmethod
 from collections import abc as cabc
-from collections.abc import Iterator, Mapping, MutableMapping, Sequence
 from copy import copy
 from typing import (
     TYPE_CHECKING,
     ClassVar,
+    Generic,
     Literal,
     TypeVar,
     Union,
 )
 
-import numpy as np
 import pandas as pd
-from scipy.sparse import spmatrix
 
 from anndata._warnings import ExperimentalFeatureWarning, ImplicitModificationWarning
 from anndata.compat import AwkArray
@@ -32,16 +30,23 @@
 from .views import as_view, view_update
 
 if TYPE_CHECKING:
+    from collections.abc import Iterable, Iterator, Mapping, MutableMapping, Sequence
+
+    import numpy as np
+    from scipy.sparse import spmatrix
+
     from .anndata import AnnData
     from .raw import Raw
 
+    OneDIdx = Union[Sequence[int], Sequence[bool], slice]
+    TwoDIdx = tuple[OneDIdx, OneDIdx]
 
-OneDIdx = Union[Sequence[int], Sequence[bool], slice]
-TwoDIdx = tuple[OneDIdx, OneDIdx]
+    I = TypeVar("I", OneDIdx, TwoDIdx, covariant=True)
+    # TODO: pd.DataFrame only allowed in AxisArrays?
+    V = Union[pd.DataFrame, spmatrix, np.ndarray]
 
-I = TypeVar("I", OneDIdx, TwoDIdx, covariant=True)
-# TODO: pd.DataFrame only allowed in AxisArrays?
-V = Union[pd.DataFrame, spmatrix, np.ndarray]
+# Used in `Generic[T]`
+T = TypeVar("T")
 
 
 class AlignedMapping(cabc.MutableMapping, ABC):
@@ -335,7 +340,7 @@
         self,
         parent: AnnData,
         *,
-        axis: tuple[int, int] = (0, 1),
+        axis: tuple[Literal[0], Literal[1]] = (0, 1),
         store: MutableMapping[str, V],
     ):
         assert axis == (0, 1), axis
@@ -419,15 +424,17 @@
 PairwiseArraysBase._actual_class = PairwiseArrays
 
 
-class AlignedMappingProperty(property):
-    def __init__(self, name, cls, axis):
+class AlignedMappingProperty(property, Generic[T]):
+    def __init__(
+        self, name: str, cls: T, axis: Literal[0, 1] | tuple[Literal[0], Literal[1]]
+    ):
         self.name = name
         self.axis = axis
         self.cls = cls
 
-    def __get__(self, obj, objtype=None):
+    def __get__(self, obj: None | AnnData, objtype: type | None = None) -> T:
         if obj is None:  # needs to return a `property`, e.g. for Sphinx
-            return self
+            return self  # type: ignore
         if obj.is_view:
             parent_anndata = obj._adata_ref
             idxs = (obj._oidx, obj._vidx)
@@ -438,12 +445,14 @@
         else:
             return self.cls(obj, axis=self.axis, store=getattr(obj, "_" + self.name))
 
-    def __set__(self, obj, value):
+    def __set__(
+        self, obj: AnnData, value: Mapping[str, V] | Iterable[tuple[str, V]]
+    ) -> None:
         value = convert_to_dict(value)
         _ = self.cls(obj, axis=self.axis, store=value)  # Validate
         if obj.is_view:
             obj._init_as_actual(obj.copy())
         setattr(obj, "_" + self.name, value)
 
-    def __delete__(self, obj):
+    def __delete__(self, obj) -> None:
         setattr(obj, self.name, dict())

src/anndata/_core/anndata.py

@@ -662,26 +662,6 @@ def X(self, value: np.ndarray | sparse.spmatrix | SpArray | None):
     def X(self):
         self.X = None
 
-    obsm = AlignedMappingProperty("obsm", AxisArrays, 0)
-    """\
-    Multi-dimensional annotation of observations
-    (mutable structured :class:`~numpy.ndarray`).
-
-    Stores for each key a two or higher-dimensional :class:`~numpy.ndarray`
-    of length `n_obs`.
-    Is sliced with `data` and `obs` but behaves otherwise like a :term:`mapping`.
-    """
-
-    varm = AlignedMappingProperty("varm", AxisArrays, 1)
-    """\
-    Multi-dimensional annotation of variables/features
-    (mutable structured :class:`~numpy.ndarray`).
-
-    Stores for each key a two or higher-dimensional :class:`~numpy.ndarray`
-    of length `n_vars`.
-    Is sliced with `data` and `var` but behaves otherwise like a :term:`mapping`.
-    """
-
     layers = AlignedMappingProperty("layers", Layers, (0, 1))
     """\
     Dictionary-like object with values of the same dimensions as :attr:`X`.
@@ -709,26 +689,6 @@ def X(self):
         adata.layers.keys()
     """
 
-    obsp = AlignedMappingProperty("obsp", PairwiseArrays, 0)
-    """\
-    Pairwise annotation of observations,
-    a mutable mapping with array-like values.
-
-    Stores for each key a two or higher-dimensional :class:`~numpy.ndarray`
-    whose first two dimensions are of length `n_obs`.
-    Is sliced with `data` and `obs` but behaves otherwise like a :term:`mapping`.
-    """
-
-    varp = AlignedMappingProperty("varp", PairwiseArrays, 1)
-    """\
-    Pairwise annotation of variables/features,
-    a mutable mapping with array-like values.
-
-    Stores for each key a two or higher-dimensional :class:`~numpy.ndarray`
-    whose first two dimensions are of length `n_var`.
-    Is sliced with `data` and `var` but behaves otherwise like a :term:`mapping`.
-    """
-
     @property
     def raw(self) -> Raw:
         """\
@@ -910,6 +870,46 @@ def uns(self, value: MutableMapping):
     def uns(self):
         self.uns = OrderedDict()
 
+    obsm = AlignedMappingProperty("obsm", AxisArrays, 0)
+    """\
+    Multi-dimensional annotation of observations
+    (mutable structured :class:`~numpy.ndarray`).
+
+    Stores for each key a two or higher-dimensional :class:`~numpy.ndarray`
+    of length `n_obs`.
+    Is sliced with `data` and `obs` but behaves otherwise like a :term:`mapping`.
+    """
+
+    varm = AlignedMappingProperty("varm", AxisArrays, 1)
+    """\
+    Multi-dimensional annotation of variables/features
+    (mutable structured :class:`~numpy.ndarray`).
+
+    Stores for each key a two or higher-dimensional :class:`~numpy.ndarray`
+    of length `n_vars`.
+    Is sliced with `data` and `var` but behaves otherwise like a :term:`mapping`.
+    """
+
+    obsp = AlignedMappingProperty("obsp", PairwiseArrays, 0)
+    """\
+    Pairwise annotation of observations,
+    a mutable mapping with array-like values.
+
+    Stores for each key a two or higher-dimensional :class:`~numpy.ndarray`
+    whose first two dimensions are of length `n_obs`.
+    Is sliced with `data` and `obs` but behaves otherwise like a :term:`mapping`.
+    """
+
+    varp = AlignedMappingProperty("varp", PairwiseArrays, 1)
+    """\
+    Pairwise annotation of variables/features,
+    a mutable mapping with array-like values.
+
+    Stores for each key a two or higher-dimensional :class:`~numpy.ndarray`
+    whose first two dimensions are of length `n_var`.
+    Is sliced with `data` and `var` but behaves otherwise like a :term:`mapping`.
+    """
+
     def obs_keys(self) -> list[str]:
         """List keys of observation annotation :attr:`obs`."""
         return self._obs.keys().tolist()
@@ -920,11 +920,11 @@ def var_keys(self) -> list[str]:
 
     def obsm_keys(self) -> list[str]:
         """List keys of observation annotation :attr:`obsm`."""
-        return list(self._obsm.keys())
+        return list(self.obsm.keys())
 
     def varm_keys(self) -> list[str]:
         """List keys of variable annotation :attr:`varm`."""
-        return list(self._varm.keys())
+        return list(self.varm.keys())
 
     def uns_keys(self) -> list[str]:
         """List keys of unstructured annotation."""
@@ -1203,10 +1203,10 @@ def transpose(self) -> AnnData:
             obs=self.var,
             var=self.obs,
             uns=self._uns,
-            obsm=self._varm,
-            varm=self._obsm,
-            obsp=self._varp,
-            varp=self._obsp,
+            obsm=self.varm,
+            varm=self.obsm,
+            obsp=self.varp,
+            varp=self.obsp,
             filename=self.filename,
         )
 
@@ -1763,24 +1763,22 @@ def _check_dimensions(self, key=None):
         else:
             key = {key}
         if "obsm" in key:
-            obsm = self._obsm
             if (
-                not all([axis_len(o, 0) == self.n_obs for o in obsm.values()])
-                and len(obsm.dim_names) != self.n_obs
+                not all([axis_len(o, 0) == self.n_obs for o in self.obsm.values()])
+                and len(self.obsm.dim_names) != self.n_obs
             ):
                 raise ValueError(
                     "Observations annot. `obsm` must have number of rows of `X`"
-                    f" ({self.n_obs}), but has {len(obsm)} rows."
+                    f" ({self.n_obs}), but has {len(self.obsm)} rows."
                 )
         if "varm" in key:
-            varm = self._varm
             if (
-                not all([axis_len(v, 0) == self.n_vars for v in varm.values()])
-                and len(varm.dim_names) != self.n_vars
+                not all([axis_len(v, 0) == self.n_vars for v in self.varm.values()])
+                and len(self.varm.dim_names) != self.n_vars
             ):
                 raise ValueError(
                     "Variables annot. `varm` must have number of columns of `X`"
-                    f" ({self.n_vars}), but has {len(varm)} rows."
+                    f" ({self.n_vars}), but has {len(self.varm)} rows."
                 )
 
     def write_h5ad(