Merge branch 'main' into chore/benchmarks

Author: d-v-b

.github/ISSUE_TEMPLATE/config.yml

@@ -1,8 +1,8 @@
 blank_issues_enabled: true
 contact_links:
-  - name: Propose a new major feature
+  - name: Propose a new Zarr specification feature
     url: https://github.com/zarr-developers/zarr-specs
-    about: A new major feature should be discussed in the Zarr specifications repository.
+    about: A new feature for the Zarr storage specification should be opened on the zarr-specs repository.
   - name: Discuss something on ZulipChat
     url: https://ossci.zulipchat.com/
     about: For questions like "How do I do X with Zarr?", consider posting your question to our developer chat.

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,11 @@
+name: Feature Request
+description: Request a new feature for zarr-python
+# labels: []
+body:
+- type: textarea
+  attributes:
+    label: Describe the new feature you'd like
+    description: >
+      Please provide a description of what new feature or functionality you'd like to see in zarr-python.
+  validations:
+    required: true

changes/3526.feature.md

@@ -175,13 +175,18 @@ Coming soon.
 
 ## Parallel computing and synchronization
 
-Zarr is designed to support parallel computing and enables concurrent reads and writes to arrays. This section covers how to optimize Zarr's concurrency settings for different parallel computing scenarios.
+Zarr is designed to support parallel computing and enables concurrent reads and writes to arrays.
+This section covers how to optimize Zarr's concurrency settings for different parallel computing
+scenarios.
 
 ### Concurrent I/O operations
 
-Zarr uses asynchronous I/O internally to enable concurrent reads and writes across multiple chunks. The level of concurrency is controlled by the `async.concurrency` configuration setting, which determines the maximum number of concurrent I/O operations.
+Zarr uses asynchronous I/O internally to enable concurrent reads and writes across multiple chunks.
+The level of concurrency is controlled by the `async.concurrency` configuration setting, which
+determines the maximum number of concurrent I/O operations.
 
-The default value is 64, which provides good performance for most workloads. You can adjust this value based on your specific needs:
+The default value is 10, which is a conservative value. You may get improved performance by tuning
+the concurrency limit. You can adjust this value based on your specific needs:
 
 ```python
 import zarr
@@ -265,7 +270,7 @@ If an array or group is backed by a persistent store such as the a `zarr.storage
 **are not** pickled. The only thing that is pickled is the necessary parameters to allow the store
 to re-open any underlying files or databases upon being unpickled.
 
-E.g., pickle/unpickle an local store array:
+E.g., pickle/unpickle a local store array:
 
 ```python exec="true" session="performance" source="above" result="ansi"
 import pickle

docs/user-guide/performance.md

@@ -125,7 +125,7 @@ class Buffer(ABC):
 
     We use Buffer throughout Zarr to represent a contiguous block of memory.
 
-    A Buffer is backed by a underlying array-like instance that represents
+    A Buffer is backed by an 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
     array-like instance can be copied/converted to a regular Numpy array
@@ -315,7 +315,7 @@ class NDBuffer:
 
     We use NDBuffer throughout Zarr to represent a n-dimensional memory block.
 
-    A NDBuffer is backed by a underlying ndarray-like instance that represents
+    A NDBuffer is backed by an underlying ndarray-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

src/zarr/core/buffer/core.py

@@ -36,7 +36,7 @@ class Buffer(core.Buffer):
 
     We use Buffer throughout Zarr to represent a contiguous block of memory.
 
-    A Buffer is backed by a underlying array-like instance that represents
+    A Buffer is backed by an 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
     array-like instance can be copied/converted to a regular Numpy array
@@ -90,7 +90,7 @@ def create_zero_length(cls) -> Self:
 
     @classmethod
     def from_buffer(cls, buffer: core.Buffer) -> Self:
-        """Create an GPU Buffer given an arbitrary Buffer
+        """Create a GPU Buffer given an arbitrary Buffer
         This will try to be zero-copy if `buffer` is already on the
         GPU and will trigger a copy if not.
 
@@ -123,7 +123,7 @@ class NDBuffer(core.NDBuffer):
 
     We use NDBuffer throughout Zarr to represent a n-dimensional memory block.
 
-    A NDBuffer is backed by a underlying ndarray-like instance that represents
+    A NDBuffer is backed by an underlying ndarray-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

src/zarr/core/buffer/gpu.py

@@ -97,7 +97,7 @@ def enable_gpu(self) -> ConfigSet:
                 "order": "C",
                 "write_empty_chunks": False,
             },
-            "async": {"concurrency": 64, "timeout": None},
+            "async": {"concurrency": 10, "timeout": None},
             "threading": {"max_workers": None},
             "json_indent": 2,
             "codec_pipeline": {

src/zarr/core/config.py

@@ -98,7 +98,7 @@ def check_structured_dtype_name_v2(data: Sequence[object]) -> TypeGuard[Structur
 
 def check_dtype_name_v2(data: object) -> TypeGuard[DTypeName_V2]:
     """
-    Type guard for narrowing the type of a python object to an valid zarr v2 dtype name.
+    Type guard for narrowing the type of a python object to a valid zarr v2 dtype name.
     """
     if isinstance(data, str):
         return True

src/zarr/core/dtype/common.py

@@ -91,7 +91,7 @@ class MetadataValidationError(BaseZarrError):
 
 class UnknownCodecError(BaseZarrError):
     """
-    Raised when a unknown codec was used.
+    Raised when an unknown codec was used.
     """
 
 

src/zarr/errors.py

@@ -227,11 +227,11 @@ def _parse_array_bytes_codec(data: dict[str, JSON] | Codec) -> ArrayBytesCodec:
     if isinstance(data, dict):
         result = _resolve_codec(data)
         if not isinstance(result, ArrayBytesCodec):
-            msg = f"Expected a dict representation of a ArrayBytesCodec; got a dict representation of a {type(result)} instead."
+            msg = f"Expected a dict representation of an ArrayBytesCodec; got a dict representation of a {type(result)} instead."
             raise TypeError(msg)
     else:
         if not isinstance(data, ArrayBytesCodec):
-            raise TypeError(f"Expected a ArrayBytesCodec. Got {type(data)} instead.")
+            raise TypeError(f"Expected an ArrayBytesCodec. Got {type(data)} instead.")
         result = data
     return result
 
@@ -247,11 +247,11 @@ def _parse_array_array_codec(data: dict[str, JSON] | Codec) -> ArrayArrayCodec:
     if isinstance(data, dict):
         result = _resolve_codec(data)
         if not isinstance(result, ArrayArrayCodec):
-            msg = f"Expected a dict representation of a ArrayArrayCodec; got a dict representation of a {type(result)} instead."
+            msg = f"Expected a dict representation of an ArrayArrayCodec; got a dict representation of a {type(result)} instead."
             raise TypeError(msg)
     else:
         if not isinstance(data, ArrayArrayCodec):
-            raise TypeError(f"Expected a ArrayArrayCodec. Got {type(data)} instead.")
+            raise TypeError(f"Expected an ArrayArrayCodec. Got {type(data)} instead.")
         result = data
     return result