add creation from other zarr

Author: brokkoli71

src/zarr/api/asynchronous.py

@@ -18,6 +18,8 @@
     ChunkCoords,
     MemoryOrder,
     ZarrFormat,
+    parse_dtype,
+    concurrent_map,
     _warn_order_kwarg,
     _warn_write_empty_chunks_kwarg,
     parse_dtype,
@@ -551,6 +553,21 @@ async def array(
         The new array.
     """
 
+    if isinstance(data, Array):
+        chunks = kwargs.pop("chunks", None) or data.chunks
+        new_array = await create(shape=data.shape, chunks=chunks, dtype=data.dtype, **kwargs)
+
+        async def _copy_chunk(chunk_coords: ChunkCoords) -> None:
+            await new_array.setitem(chunk_coords, await data._async_array.getitem(chunk_coords))
+
+        # Stream data from the source array to the new array
+        await concurrent_map(
+            [(region,) for region in data._iter_chunk_regions()],
+            _copy_chunk,
+            config.get("async.concurrency"),
+        )
+        return new_array
+
     # ensure data is array-like
     if not hasattr(data, "shape") or not hasattr(data, "dtype"):
         data = np.asanyarray(data)

src/zarr/api/synchronous.py

@@ -339,7 +339,7 @@ def tree(grp: Group, expand: bool | None = None, level: int | None = None) -> An
 
 
 # TODO: add type annotations for kwargs
-def array(data: npt.ArrayLike, **kwargs: Any) -> Array:
+def array(data: npt.ArrayLike | Array, **kwargs: Any) -> Array:
     """Create an array filled with `data`.
 
     Parameters

tests/test_array.py

@@ -2,6 +2,7 @@
 import json
 import math
 import pickle
+import time
 from itertools import accumulate
 from typing import Any, Literal
 
@@ -865,6 +866,52 @@ async def test_special_complex_fill_values_roundtrip(fill_value: Any, expected:
     assert actual["fill_value"] == expected
 
 
+async def test_creation_from_other_zarr(tmpdir):
+    src = zarr.zeros(
+        (2000, 20000), chunks=(1000, 1000), dtype="uint8", store=LocalStore(str(tmpdir))
+    )
+    src[:] = 1
+    for _i in range(10):
+        start_time = time.time()
+        c = zarr.array(src, store=MemoryStore())
+        end_time = time.time()
+        print(f"Time fast: {end_time - start_time} seconds")
+
+        start_time = time.time()
+        b = zarr.zeros(src.shape, chunks=src.chunks, store=MemoryStore())
+        b[:] = src[:]
+        end_time = time.time()
+        print(f"Time slow: {end_time - start_time} seconds")
+
+    assert b[123, 123] == 1
+    assert c[123, 123] == 1
+
+
+@pytest.mark.parametrize("shape", [(1,), (2, 3), (4, 5, 6)])
+@pytest.mark.parametrize("dtype", ["uint8", "float32"])
+@pytest.mark.parametrize("array_type", ["async", "sync"])
+async def test_nbytes(
+    shape: tuple[int, ...], dtype: str, array_type: Literal["async", "sync"]
+) -> None:
+    """
+    Test that the ``nbytes`` attribute of an Array or AsyncArray correctly reports the capacity of
+    the chunks of that array.
+    """
+    store = MemoryStore()
+    arr = Array.create(store=store, shape=shape, dtype=dtype, fill_value=0)
+    if array_type == "async":
+        assert arr._async_array.nbytes == np.prod(arr.shape) * arr.dtype.itemsize
+    else:
+        assert arr.nbytes == np.prod(arr.shape) * arr.dtype.itemsize
+
+
+async def test_scalar_array() -> None:
+    arr = zarr.array(1.5)
+    assert arr[...] == 1.5
+    assert arr[()] == 1.5
+    assert arr.shape == ()
+
+
 @pytest.mark.parametrize("shape", [(1,), (2, 3), (4, 5, 6)])
 @pytest.mark.parametrize("dtype", ["uint8", "float32"])
 @pytest.mark.parametrize("array_type", ["async", "sync"])