More consistent naming

Author: FrancescAlted

src/blosc2/batch_store.py

@@ -27,14 +27,14 @@ def _check_serialized_size(buffer: bytes) -> None:
 
 
 class Batch(Sequence[Any]):
-    """A lazy sequence of Python objects stored in one BatchStore chunk."""
+    """A lazy sequence of Python objects stored in one BatchStore batch."""
 
-    def __init__(self, parent: BatchStore, nchunk: int, lazychunk: bytes) -> None:
+    def __init__(self, parent: BatchStore, nbatch: int, lazybatch: bytes) -> None:
         self._parent = parent
-        self._nchunk = nchunk
-        self._lazychunk = lazychunk
+        self._nbatch = nbatch
+        self._lazybatch = lazybatch
         self._blocks: list[list[Any]] | None = None
-        self._nbytes, self._cbytes, self._nblocks = blosc2.get_cbuffer_sizes(lazychunk)
+        self._nbytes, self._cbytes, self._nblocks = blosc2.get_cbuffer_sizes(lazybatch)
 
     def _normalize_index(self, index: int) -> int:
         if not isinstance(index, int):
@@ -47,7 +47,7 @@ def _normalize_index(self, index: int) -> int:
 
     def _decode_blocks(self) -> list[list[Any]]:
         if self._blocks is None:
-            self._blocks = self._parent._decode_blocks(self._nchunk)
+            self._blocks = self._parent._decode_blocks(self._nbatch)
         return self._blocks
 
     def __getitem__(self, index: int | slice) -> Any | list[Any]:
@@ -73,8 +73,8 @@ def __iter__(self) -> Iterator[Any]:
             yield self[i]
 
     @property
-    def lazychunk(self) -> bytes:
-        return self._lazychunk
+    def lazybatch(self) -> bytes:
+        return self._lazybatch
 
     @property
     def nbytes(self) -> int:
@@ -338,9 +338,9 @@ def _compress_batch(self, batch: list[Any]) -> bytes:
         ]
         return blosc2.blosc2_ext.vlcompress(blocks, **self._vl_cparams_kwargs())
 
-    def _decode_blocks(self, nchunk: int) -> list[list[Any]]:
+    def _decode_blocks(self, nbatch: int) -> list[list[Any]]:
         block_payloads = blosc2.blosc2_ext.vldecompress(
-            self.schunk.get_chunk(nchunk), **self._vl_dparams_kwargs()
+            self.schunk.get_chunk(nbatch), **self._vl_dparams_kwargs()
         )
         return [msgpack_unpackb(payload) for payload in block_payloads]
 
@@ -351,16 +351,16 @@ def append(self, value: object) -> int:
         """Append one batch and return the new number of entries."""
         self._check_writable()
         batch = self._serialize_batch(value)
-        chunk = self._compress_batch(batch)
-        return self.schunk.append_chunk(chunk)
+        batch_payload = self._compress_batch(batch)
+        return self.schunk.append_chunk(batch_payload)
 
     def insert(self, index: int, value: object) -> int:
         """Insert one batch at ``index`` and return the new number of entries."""
         self._check_writable()
         index = self._normalize_insert_index(index)
         batch = self._serialize_batch(value)
-        chunk = self._compress_batch(batch)
-        return self.schunk.insert_chunk(index, chunk)
+        batch_payload = self._compress_batch(batch)
+        return self.schunk.insert_chunk(index, batch_payload)
 
     def delete(self, index: int | slice) -> int:
         """Delete the batch at ``index`` and return the new number of entries."""
@@ -387,8 +387,8 @@ def extend(self, values: object) -> None:
         self._check_writable()
         for value in values:
             batch = self._serialize_batch(value)
-            chunk = self._compress_batch(batch)
-            self.schunk.append_chunk(chunk)
+            batch_payload = self._compress_batch(batch)
+            self.schunk.append_chunk(batch_payload)
 
     def clear(self) -> None:
         """Remove all entries from the container."""
@@ -424,23 +424,23 @@ def __setitem__(self, index: int | slice, value: object) -> None:
                     self.schunk.delete_chunk(idx)
                 for offset, item in enumerate(values):
                     batch = self._serialize_batch(item)
-                    chunk = self._compress_batch(batch)
-                    self.schunk.insert_chunk(start + offset, chunk)
+                    batch_payload = self._compress_batch(batch)
+                    self.schunk.insert_chunk(start + offset, batch_payload)
                 return
             if len(values) != len(indices):
                 raise ValueError(
                     f"attempt to assign sequence of size {len(values)} to extended slice of size {len(indices)}"
                 )
             for idx, item in zip(indices, values, strict=True):
                 batch = self._serialize_batch(item)
-                chunk = self._compress_batch(batch)
-                self.schunk.update_chunk(idx, chunk)
+                batch_payload = self._compress_batch(batch)
+                self.schunk.update_chunk(idx, batch_payload)
             return
         self._check_writable()
         index = self._normalize_index(index)
         batch = self._serialize_batch(value)
-        chunk = self._compress_batch(batch)
-        self.schunk.update_chunk(index, chunk)
+        batch_payload = self._compress_batch(batch)
+        self.schunk.update_chunk(index, batch_payload)
 
     def __delitem__(self, index: int | slice) -> None:
         self.delete(index)

tests/test_batch_store.py

@@ -58,7 +58,7 @@ def test_batchstore_roundtrip(contiguous, urlpath):
     assert len(batch0) == len(BATCHES[0])
     assert batch0[1] == BATCHES[0][1]
     assert batch0[:] == BATCHES[0]
-    assert isinstance(batch0.lazychunk, bytes)
+    assert isinstance(batch0.lazybatch, bytes)
     assert batch0.nbytes > 0
     assert batch0.cbytes > 0
     assert batch0.cratio > 0
@@ -216,14 +216,14 @@ def test_vlcompress_small_blocks_roundtrip():
     ]
     payloads = [msgpack_packb(value) for value in values]
 
-    chunk = blosc2.blosc2_ext.vlcompress(
+    batch_payload = blosc2.blosc2_ext.vlcompress(
         payloads,
         codec=blosc2.Codec.ZSTD,
         clevel=5,
         typesize=1,
         nthreads=1,
     )
-    out = blosc2.blosc2_ext.vldecompress(chunk, nthreads=1)
+    out = blosc2.blosc2_ext.vldecompress(batch_payload, nthreads=1)
 
     assert out == payloads