v2 writer

Author: TomAugspurger

src/zarr/core/group.py

@@ -331,14 +331,44 @@ def to_buffer_dict(self, prototype: BufferPrototype) -> dict[str, Buffer]:
                 )
             }
         else:
-            return {
+            items = {
                 ZGROUP_JSON: prototype.buffer.from_bytes(
                     json.dumps({"zarr_format": self.zarr_format}, indent=json_indent).encode()
                 ),
                 ZATTRS_JSON: prototype.buffer.from_bytes(
                     json.dumps(self.attributes, indent=json_indent).encode()
                 ),
             }
+            if self.consolidated_metadata:
+                d = {
+                    ZGROUP_JSON: {"zarr_format": self.zarr_format},
+                    ZATTRS_JSON: self.attributes,
+                }
+                consolidated_metadata = self.consolidated_metadata.to_dict()["metadata"]
+                assert isinstance(consolidated_metadata, dict)
+                for k, v in consolidated_metadata.items():
+                    attrs = v.pop("attributes", None)
+                    d[f"{k}/{ZATTRS_JSON}"] = attrs
+                    if "shape" in v:
+                        # it's an array
+                        d[f"{k}/{ZARRAY_JSON}"] = v
+                    else:
+                        d[f"{k}/{ZGROUP_JSON}"] = {
+                            "zarr_format": self.zarr_format,
+                            "consolidated_metadata": {
+                                "metadata": {},
+                                "must_understand": False,
+                                "kind": "inline",
+                            },
+                        }
+
+                items[ZMETADATA_V2_JSON] = prototype.buffer.from_bytes(
+                    json.dumps(
+                        {"metadata": d, "zarr_consolidated_format": 1}, indent=json_indent
+                    ).encode()
+                )
+
+            return items
 
     def __init__(
         self,

tests/v3/test_metadata/test_consolidated.py

@@ -19,6 +19,7 @@
 from zarr.core.buffer.core import default_buffer_prototype
 from zarr.core.group import ConsolidatedMetadata, GroupMetadata
 from zarr.core.metadata import ArrayV3Metadata
+from zarr.core.metadata.v2 import ArrayV2Metadata
 from zarr.store.common import StorePath
 
 if TYPE_CHECKING:
@@ -479,3 +480,44 @@ async def test_open_consolidated_raises_async(self, zarr_format: ZarrFormat):
 
         with pytest.raises(ValueError):
             await zarr.api.asynchronous.open_consolidated(store, zarr_format=None)
+
+    async def test_consolidated_metadata_v2(self):
+        store = zarr.store.MemoryStore(mode="w")
+        g = await AsyncGroup.from_store(store, attributes={"key": "root"}, zarr_format=2)
+        await g.create_array(name="a", shape=(1,), attributes={"key": "a"})
+        g1 = await g.create_group(name="g1", attributes={"key": "g1"})
+        await g1.create_group(name="g2", attributes={"key": "g2"})
+
+        await zarr.api.asynchronous.consolidate_metadata(store)
+        result = await zarr.api.asynchronous.open_consolidated(store, zarr_format=2)
+
+        expected = GroupMetadata(
+            attributes={"key": "root"},
+            zarr_format=2,
+            consolidated_metadata=ConsolidatedMetadata(
+                metadata={
+                    "a": ArrayV2Metadata(
+                        shape=(1,),
+                        dtype="float64",
+                        attributes={"key": "a"},
+                        chunks=(1,),
+                        fill_value=0.0,
+                        order="C",
+                    ),
+                    "g1": GroupMetadata(
+                        attributes={"key": "g1"},
+                        zarr_format=2,
+                        consolidated_metadata=ConsolidatedMetadata(
+                            metadata={
+                                "g2": GroupMetadata(
+                                    attributes={"key": "g2"},
+                                    zarr_format=2,
+                                    consolidated_metadata=ConsolidatedMetadata(metadata={}),
+                                )
+                            }
+                        ),
+                    ),
+                }
+            ),
+        )
+        assert result.metadata == expected