Adding copy_store convenience method for Group

src/zarr/core/group.py

@@ -697,6 +697,69 @@ def from_dict(
             store_path=store_path,
         )
 
+    async def copy_to(
+        self,
+        store: StoreLike,
+        *,
+        overwrite: bool = False,
+    ) -> AsyncGroup:
+        target_zarr_format = self.metadata.zarr_format
+
+        new_group = await AsyncGroup.from_store(
+            store,
+            overwrite=overwrite,
+            attributes=self.metadata.attributes,
+            zarr_format=target_zarr_format,
+        )
+
+        async for _, member in self.members(max_depth=None):
+            child_path = member.store_path.path
+            target_path = StorePath(store=new_group.store, path=child_path)
+
+            if isinstance(member, AsyncGroup):
+                await async_api.group(
+                    store=target_path,
+                    overwrite=overwrite,
+                    attributes=member.metadata.attributes,
+                    zarr_format=target_zarr_format,
+                )
+            else:
+                kwargs = {}
+                if target_zarr_format == 3:
+                    kwargs["chunk_key_encoding"] = member.metadata.chunk_key_encoding
+                    kwargs["dimension_names"] = member.metadata.dimension_names
+                else:
+                    kwargs["chunk_key_encoding"] = {
+                        "name": "v2",
+                        "separator": member.metadata.dimension_separator,
+                    }
+                    # Serializer done this way in case of having zarr_format 2, otherwise mypy complains.
+                new_array = await new_group.create_array(
+                    name=child_path,
+                    shape=member.shape,
+                    dtype=member.dtype,
+                    chunks=member.chunks,
+                    shards=member.shards,
+                    filters=member.filters,
+                    compressors=member.compressors,
+                    serializer=member.serializer if member.serializer is not None else "auto",
+                    fill_value=member.metadata.fill_value,
+                    attributes=member.attrs,
+                    overwrite=overwrite,
+                    config={"order": member.order},
+                    **kwargs,
+                )
+
+                for region in member._iter_shard_regions():
+                    data = await member.getitem(selection=region)
+                    await new_array.setitem(selection=region, value=data)
+
+        group = await self.open(self.store, zarr_format=target_zarr_format)
+        if group.metadata.consolidated_metadata:
+            await async_api.consolidate_metadata(new_group.store)
+
+        return new_group
+
     async def setitem(self, key: str, value: Any) -> None:
         """
         Fastpath for creating a new array
@@ -1874,6 +1937,14 @@ def open(
         obj = sync(AsyncGroup.open(store, zarr_format=zarr_format))
         return cls(obj)
 
+    def copy_to(
+        self,
+        store: StoreLike,
+        *,
+        overwrite: bool = False,
+    ) -> Group:
+        return Group(sync(self._async_group.copy_to(store=store, overwrite=overwrite)))
+
     def __getitem__(self, path: str) -> AnyArray | Group:
         """Obtain a group member.
 

tests/test_group.py

@@ -250,6 +250,59 @@ def test_group_members(store: Store, zarr_format: ZarrFormat, consolidated_metad
         members_observed = group.members(max_depth=-1)
 
 
+@pytest.mark.parametrize(
+    ("zarr_format", "shards", "consolidate_metadata"),
+    [
+        (2, None, False),
+        (2, None, True),
+        (3, (50,), False),
+        (3, (50,), True),
+    ],
+)
+def test_copy_to(zarr_format: int, shards: tuple[int, ...], consolidate_metadata: bool) -> None:
+    src_store = MemoryStore()
+    src = Group.from_store(src_store, attributes={"root": True}, zarr_format=zarr_format)
+
+    src.create_group("subgroup")
+
+    arr_data = np.arange(100)
+    src.create_array(
+        "dataset",
+        shape=(100,),
+        chunks=(10,),
+        shards=shards,
+        dtype=arr_data.dtype,
+    )
+    src["dataset"] = arr_data
+    if consolidate_metadata:
+        if zarr_format == 3:
+            with pytest.warns(ZarrUserWarning, match="Consolidated metadata is currently"):
+                zarr.consolidate_metadata(src_store)
+        else:
+            zarr.consolidate_metadata(src_store)
+
+    dst_store = MemoryStore()
+    if zarr_format == 3 and consolidate_metadata:
+        with pytest.warns(ZarrUserWarning, match="Consolidated metadata is currently"):
+            dst = src.copy_to(dst_store, overwrite=True)
+    else:
+        dst = src.copy_to(dst_store, overwrite=True)
+
+    assert dst.attrs.get("root") is True
+
+    subgroup = dst["subgroup"]
+    assert isinstance(subgroup, Group)
+
+    copied_arr = dst["dataset"]
+    copied_data = copied_arr[:]
+    assert np.array_equal(copied_data, arr_data)
+
+    if consolidate_metadata:
+        assert zarr.open_group(dst_store).metadata.consolidated_metadata
+    else:
+        assert not zarr.open_group(dst_store).metadata.consolidated_metadata
+
+
 def test_group(store: Store, zarr_format: ZarrFormat) -> None:
     """
     Test basic Group routines.