accessors: allow resolving AdAcc's

Author: ilia-kats

docs/accessors.md

@@ -8,7 +8,7 @@
 See the corresponding [AnnData documentation](inv:anndata:*:doc#accessors).
 
 :::{important}
-This functionality requires AnnData 0.13 or newer.
+This functionality requires AnnData 0.13.2 or newer.
 :::
 
 The central [accessor](inv:anndata:*:term#accessor) is [](#A).

src/mudata/acc/__init__.py

@@ -21,6 +21,7 @@
     MultiMapAcc,
     RefAcc,
 )
+from anndata.acc._parse_str import _check_vec
 from anndata.compat import XVariable
 from anndata.typing import InMemoryArray
 
@@ -250,33 +251,56 @@ def __getitem__(self, k: str, /) -> ModAcc[R]:
     def __repr__(self) -> str:
         return "A"
 
-    def resolve(self, spec: str, *, strict: bool = True) -> R | None:
+    def resolve(
+        self, spec: str, *, strict: bool = True, vec: bool | None = None
+    ) -> (
+        R
+        | ModLayerAcc[R]
+        | ModMultiAcc[R]
+        | ModGraphAcc[R]
+        | MultiAcc[R]
+        | ModMapAcc[R]
+        | GraphAcc[R]
+        | ModAcc[R]
+        | None
+    ):
         """Create :class:`~anndata.acc.AdRef` from a simplified string."""
         if not strict:
             try:
-                self.resolve(spec)
+                self.resolve(spec, vec=vec)
             except ValueError:
                 return None
 
         firstdot = spec.find(".")
         if firstdot < 0:
-            raise ValueError(f"Cannot parse accessor {spec!r} that is not period-separated.")
+            firstdot = None
         firstattr = spec[:firstdot]
         match firstattr:
             case "mod":
+                do_vec = firstdot is not None
+                if not do_vec:
+                    _check_vec(spec, vec=vec, actual=do_vec)
+                    return self.mod
+
                 modend = spec.find(".", firstdot + 1)
+                do_vec = modend >= 0
+                if not do_vec:
+                    modend = None
+                    _check_vec(spec, vec=vec, actual=do_vec)
                 mod = spec[firstdot + 1 : modend]
                 if not mod:
                     raise ValueError(f"Cannot parse accessor{spec!r} that has an empty modality.")
                 acc = self.mod[mod]
-                return super().resolve.__func__(acc, spec[modend + 1 :], strict=strict)
+                return super().resolve.__func__(acc, spec[modend + 1 :], strict=strict, vec=vec) if do_vec else acc
             case "obsmap" | "varmap":
-                if firstdot == len(spec):
-                    raise ValueError(f"Cannot parse accessor{spec!r} that has an empty modality.")
+                do_vec = firstdot is not None and firstdot < len(spec)
+                _check_vec(spec, vec=vec, actual=do_vec)
+                if not do_vec:
+                    return getattr(self, firstattr)
                 mod = spec[firstdot + 1 :]
                 return getattr(self, firstattr)[mod]
             case _:
-                return super().resolve(spec, strict=strict)
+                return super().resolve(spec, strict=strict, vec=vec)
 
     def to_json(self, ref: R) -> list[str | int | None]:
         """Serialize :class:`~anndata.acc.AdRef` to a JSON-compatible list.

tests/test_accessors.py

@@ -1,5 +1,6 @@
 import json
 from collections.abc import Mapping
+from contextlib import nullcontext
 from dataclasses import fields
 from importlib import metadata, resources
 from urllib.request import urlopen
@@ -139,16 +140,27 @@ def test_no_data():
         assert field.name not in ("X", "layers")
 
 
-def test_resolve():
-    assert A.resolve("mod.rna.X[:, ACT1]") == A.mod["rna"].X[:, "ACT1"]
-    assert A.resolve("obsmap.rna") == A.obsmap["rna"]
+@pytest.mark.parametrize("vec", [None, True, False])
+def test_resolve_vec_true(vec: bool):
+    with pytest.raises(ValueError, match="refers to a vector/") if vec is False else nullcontext():
+        assert A.resolve("mod.rna.X[:, ACT1]", vec=vec) == A.mod["rna"].X[:, "ACT1"]
+        assert A.resolve("obsmap.rna", vec=vec) == A.obsmap["rna"]
 
+
+@pytest.mark.parametrize("vec", [None, True, False])
+def test_resolve_vec_false(vec: bool):
+    with pytest.raises(ValueError, match="refers to a whole container") if vec is True else nullcontext():
+        assert A.resolve("mod.rna.X", vec=vec) == A.mod["rna"].X
+        assert A.resolve("mod.rna", vec=vec) == A.mod["rna"]
+        assert A.resolve("mod", vec=vec) == A.mod
+        assert A.resolve("obsmap", vec=vec) == A.obsmap
+
+
+def test_resolve_raises():
     with pytest.raises(ValueError, match="Unknown accessor"):
         A.resolve("rna.X[:, :]")
-
     with pytest.raises(ValueError, match="empty modality"):
         A.resolve("mod..X[:, :]")
-
     with pytest.raises(ValueError, match="period-separated"):
         A.resolve("abcd")