Buffer is now backed by ArrayLike

Author: madsbk

src/zarr/buffer.py

@@ -20,7 +20,9 @@
     from zarr.codecs.bytes import Endian
     from zarr.common import BytesLike
 
-# TODO: create a protocol for the attributes we need, for now we just aliasing numpy
+# TODO: create a protocol for the attributes we need, for now we alias Numpy's ndarray
+#       both for the array-like and ndarray-like
+ArrayLike: TypeAlias = np.ndarray
 NDArrayLike: TypeAlias = np.ndarray
 
 
@@ -89,10 +91,10 @@ class Buffer:
 
     We use Buffer throughout Zarr to represent a contiguous block of memory.
 
-    A Buffer is backed by a underlying ndarray-like instance that represents
+    A Buffer is backed by a underlying array-like instance that represents
     the memory. The memory type is unspecified; can be regular host memory,
     CUDA device memory, or something else. The only requirement is that the
-    ndarray-like instance can be copied/converted to a regular Numpy array
+    array-like instance can be copied/converted to a regular Numpy array
     (host memory).
 
     Note
@@ -101,16 +103,16 @@ class Buffer:
 
     Parameters
     ----------
-    ndarray_like
-        ndarray-like object that must be 1-dim, contiguous, and byte dtype.
+    array_like
+        array-like object that must be 1-dim, contiguous, and byte dtype.
     """
 
-    def __init__(self, ndarray_like: NDArrayLike):
-        if ndarray_like.ndim != 1:
-            raise ValueError("ndarray_like: only 1-dim allowed")
-        if ndarray_like.dtype != np.dtype("b"):
-            raise ValueError("ndarray_like: only byte dtype allowed")
-        self._data = ndarray_like
+    def __init__(self, array_like: ArrayLike):
+        if array_like.ndim != 1:
+            raise ValueError("array_like: only 1-dim allowed")
+        if array_like.dtype != np.dtype("b"):
+            raise ValueError("array_like: only byte dtype allowed")
+        self._data = array_like
 
     @classmethod
     def create_zero_length(cls) -> Self:
@@ -123,19 +125,19 @@ def create_zero_length(cls) -> Self:
         return cls(np.array([], dtype="b"))
 
     @classmethod
-    def from_ndarray_like(cls, ndarray_like: NDArrayLike) -> Self:
-        """Create a new buffer of a ndarray-like object
+    def from_array_like(cls, array_like: NDArrayLike) -> Self:
+        """Create a new buffer of a array-like object
 
         Parameters
         ----------
-        ndarray_like
-            ndarray-like object that must be 1-dim, contiguous, and byte dtype.
+        array_like
+            array-like object that must be 1-dim, contiguous, and byte dtype.
 
         Return
         ------
-            New buffer representing `ndarray_like`
+            New buffer representing `array_like`
         """
-        return cls(ndarray_like)
+        return cls(array_like)
 
     @classmethod
     def from_bytes(cls, bytes_like: BytesLike) -> Self:
@@ -150,9 +152,9 @@ def from_bytes(cls, bytes_like: BytesLike) -> Self:
         ------
             New buffer representing `bytes_like`
         """
-        return cls.from_ndarray_like(np.frombuffer(bytes_like, dtype="b"))
+        return cls.from_array_like(np.frombuffer(bytes_like, dtype="b"))
 
-    def as_ndarray_like(self) -> NDArrayLike:
+    def as_array_like(self) -> NDArrayLike:
         """Return the underlying array (host or device memory) of this buffer
 
         This will never copy data.
@@ -175,7 +177,7 @@ def as_nd_buffer(self, *, dtype: np.DTypeLike) -> NDBuffer:
 
         Return
         ------
-            New NDbuffer representing `self.as_ndarray_like()`
+            New NDbuffer representing `self.as_array_like()`
         """
         return NDBuffer.from_ndarray_like(self._data.view(dtype=dtype))
 
@@ -184,7 +186,7 @@ def as_numpy_array(self) -> np.ndarray:
 
         Warning
         -------
-        Might have to copy data, consider using `.as_ndarray_like()` instead.
+        Might have to copy data, consider using `.as_array_like()` instead.
 
         Return
         ------
@@ -198,7 +200,7 @@ def to_bytes(self) -> bytes:
         Warning
         -------
         Will always copy data, only use this method for small buffers such as metadata
-        buffers. If possible, use `.as_numpy_array()` or `.as_ndarray_like()` instead.
+        buffers. If possible, use `.as_numpy_array()` or `.as_array_like()` instead.
 
         Return
         ------
@@ -220,7 +222,7 @@ def __len__(self) -> int:
     def __add__(self, other: Buffer) -> Self:
         """Concatenate two buffers"""
 
-        other_array = other.as_ndarray_like()
+        other_array = other.as_array_like()
         assert other_array.dtype == np.dtype("b")
         return self.__class__(np.concatenate((self._data, other_array)))
 
@@ -230,7 +232,7 @@ def __eq__(self, other: Any) -> bool:
             # convert the bytes to a Buffer and try again
             return self == self.from_bytes(other)
         if isinstance(other, Buffer):
-            return (self._data == other.as_ndarray_like()).all()
+            return (self._data == other.as_array_like()).all()
         raise ValueError(
             f"equal operator not supported between {self.__class__} and {other.__class__}"
         )

src/zarr/codecs/blosc.py

@@ -173,7 +173,7 @@ async def encode(
         # Since blosc only takes bytes, we convert the input and output of the encoding
         # between bytes and Buffer
         return await to_thread(
-            lambda chunk: Buffer.from_bytes(self._blosc_codec.encode(chunk.as_ndarray_like())),
+            lambda chunk: Buffer.from_bytes(self._blosc_codec.encode(chunk.as_array_like())),
             chunk_bytes,
         )
 

src/zarr/codecs/crc32c_.py

@@ -46,7 +46,7 @@ async def decode(
                 "Stored and computed checksum do not match. "
                 + f"Stored: {stored_checksum!r}. Computed: {computed_checksum!r}."
             )
-        return Buffer.from_ndarray_like(inner_bytes)
+        return Buffer.from_array_like(inner_bytes)
 
     async def encode(
         self,
@@ -57,7 +57,7 @@ async def encode(
         # Calculate the checksum and "cast" it to a numpy array
         checksum = np.array([crc32c(data)], dtype=np.uint32)
         # Append the checksum (as bytes) to the data
-        return Buffer.from_ndarray_like(np.append(data, checksum.view("b")))
+        return Buffer.from_array_like(np.append(data, checksum.view("b")))
 
     def compute_encoded_size(self, input_byte_length: int, _chunk_spec: ArraySpec) -> int:
         return input_byte_length + 4