Zarr-Python

https://zarr.readthedocs.io/en/stable/
Admin
Zarr-Python is a Python library for reading and writing Zarr groups and arrays, offering flexible...
Tokens:434,993
Snippets:3,057
Trust Score:9.6
Update:1 month ago
Show doc for...
Tokens:
Raw
### Configure CacheStore Parameters

Source: https://zarr.readthedocs.io/en/stable/user-guide/experimental

Examples of configuring max_size, max_age_seconds, and cache_set_data.

```python
# Unlimited cache size (use with caution)
cache = CacheStore(
    store=source_store,
    cache_store=cache_store,
    max_size=None
)
```

```python
# Cache expires after 1 hour
cache = CacheStore(
    store=source_store,
    cache_store=cache_store,
    max_age_seconds=3600
)

# Cache never expires
cache = CacheStore(
    store=source_store,
    cache_store=cache_store,
    max_age_seconds="infinity"
)
```

```python
# Cache data when writing (default)
cache = CacheStore(
    store=source_store,
    cache_store=cache_store,
    cache_set_data=True
)

# Don't cache written data (read-only cache)
cache = CacheStore(
    store=source_store,
    cache_store=cache_store,
    cache_set_data=False
)
```

--------------------------------

### Initialize development environment

Source: https://zarr.readthedocs.io/en/stable/contributing

Commands to install hatch and list available development environments.

```bash
pip install hatch
hatch env show  # list all available environments
```

--------------------------------

### Run the custom dtype example

Source: https://zarr.readthedocs.io/en/stable/user-guide/examples/custom_dtype

Commands to execute the custom dtype example script using either uv or standard Python.

```bash
uv run examples/custom_dtype/custom_dtype.py
```

```bash
python examples/custom_dtype/custom_dtype.py
```

--------------------------------

### Install Zarr via pip

Source: https://zarr.readthedocs.io/en/stable/user-guide/installation

Standard installation command for the Zarr package from PyPI.

```bash
pip install zarr
```

--------------------------------

### Install Zarr with GPU support

Source: https://zarr.readthedocs.io/en/stable/user-guide/gpu

Install the necessary dependencies for GPU acceleration using the gpu extra.

```bash
pip install "zarr[gpu]"
```

--------------------------------

### Install Nightly Development Wheels

Source: https://zarr.readthedocs.io/en/stable/user-guide/installation

Command to install the latest unstable nightly build for testing purposes.

```bash
pip install --pre --extra-index-url https://pypi.anaconda.org/scientific-python-nightly-wheels/simple zarr
```

--------------------------------

### Set and get configuration values

Source: https://zarr.readthedocs.io/en/stable/user-guide/config

Demonstrates setting a configuration key and retrieving its current value.

```python
import zarr

zarr.config.set({'array.order': 'F'})

print(zarr.config.get('array.order'))
```

--------------------------------

### Clone and configure repository

Source: https://zarr.readthedocs.io/en/stable/contributing

Initial setup commands to clone a fork and link it to the upstream repository.

```bash
git clone git@github.com:your-user-name/zarr-python.git
cd zarr-python
git remote add upstream git@github.com:zarr-developers/zarr-python.git
```

--------------------------------

### Setup 2D Zarr Array

Source: https://zarr.readthedocs.io/en/stable/api/zarr/array

Initialize a 2-dimensional Zarr array.

```python
>>> z = zarr.zeros(
...     shape=(5, 5),
...     store={},
...     chunk_shape=(5, 5),
...     dtype="i4",
... )
```

--------------------------------

### Run Sharding Coalescing Example

Source: https://zarr.readthedocs.io/en/stable/user-guide/examples/sharding_coalescing

Execute the sharding coalescing demonstration script using uv.

```bash
uv run sharding_coalescing.py
```

--------------------------------

### TimeDelta64JSON_V2 Example

Source: https://zarr.readthedocs.io/en/stable/api/zarr/dtype

Example of the JSON structure for TimeDelta64 in Zarr V2.

```python
{
    "name": "<m8[1s]",
    "object_codec_id": None
}
```

```python
class TimeDelta64JSON_V2(DTypeConfig_V2[str, None]):
    """
    A wrapper around the JSON representation of the ``TimeDelta64`` data type in Zarr V2.

    The ``name`` field of this class contains the value that would appear under the
    ``dtype`` field in Zarr V2 array metadata.

    References
    ----------
    The structure of the ``name`` field is defined in the Zarr V2
    [specification document](https://github.com/zarr-developers/zarr-specs/blob/main/docs/v2/v2.0.rst#data-type-encoding).


    Examples
    --------
    ```python
    {
        "name": "<m8[1s]",
        "object_codec_id": None
    }
    ```
    """
```

--------------------------------

### Initialize and use a CacheStore

Source: https://zarr.readthedocs.io/en/stable/api/zarr/experimental

Demonstrates how to instantiate a CacheStore with source and cache stores, and perform basic array operations.

```python
import zarr
from zarr.storage import MemoryStore
from zarr.experimental.cache_store import CacheStore

# Create a cached store
source_store = MemoryStore()
cache_store = MemoryStore()
cached_store = CacheStore(
    store=source_store,
    cache_store=cache_store,
    max_age_seconds=60,
    max_size=1024*1024
)

# Use it like any other store
array = zarr.create(shape=(100,), store=cached_store)
array[:] = 42
```

--------------------------------

### Setup 3D Zarr Array

Source: https://zarr.readthedocs.io/en/stable/api/zarr/array

Initialize a 3-dimensional Zarr array with numpy data.

```python
>>> data = np.arange(1000).reshape(10, 10, 10)
>>> z = zarr.create_array(
...     {},
...     shape=data.shape,
...     chunks=(5, 5, 5),
...     dtype=data.dtype,
... )
>>> z[:] = data
```

--------------------------------

### DateTime64JSON_V2 Example

Source: https://zarr.readthedocs.io/en/stable/api/zarr/dtype

Example of the JSON structure for the DateTime64 data type in Zarr V2.

```python
{
    "name": "<M8[10s]",
    "object_codec_id": None
}
```

```python
class DateTime64JSON_V2(DTypeConfig_V2[str, None]):
    """
    A wrapper around the JSON representation of the ``DateTime64`` data type in Zarr V2.

    The ``name`` field of this class contains the value that would appear under the
    ``dtype`` field in Zarr V2 array metadata.

    References
    ----------
    The structure of the ``name`` field is defined in the Zarr V2
    [specification document](https://github.com/zarr-developers/zarr-specs/blob/main/docs/v2/v2.0.rst#data-type-encoding).


    Examples
    --------
    ```python
    {
        "name": "<M8[10s]",
        "object_codec_id": None
    }
    ```
    """
```

--------------------------------

### open(*args: Any, **kwargs: Any) -> Self

Source: https://zarr.readthedocs.io/en/stable/api/zarr/abc/store

Create and open the store instance.

```APIDOC
## open(*args: Any, **kwargs: Any) -> Self

### Description
Create and open the store.

### Parameters
- **args** (Any) - Optional - Positional arguments to pass to the store constructor.
- **kwargs** (Any) - Optional - Keyword arguments to pass to the store constructor.

### Returns
- **Store** - The opened store instance.
```

--------------------------------

### open(store_cls, *args, **kwargs)

Source: https://zarr.readthedocs.io/en/stable/api/zarr/storage

Create and open a store instance.

```APIDOC
## classmethod open(store_cls, *args, **kwargs)

### Description
Create and open the store.

### Parameters
- **store_cls** (type[T_Store]) - Required - The class of the store to instantiate.
- **args** (Any) - Optional - Positional arguments to pass to the store constructor.
- **kwargs** (Any) - Optional - Keyword arguments to pass to the store constructor.

### Returns
- **Store** - The opened store instance.
```

--------------------------------

### Install Zarr via conda

Source: https://zarr.readthedocs.io/en/stable/user-guide/installation

Installation command for Zarr using the conda-forge channel.

```bash
conda install -c conda-forge zarr
```

--------------------------------

### Serve documentation locally

Source: https://zarr.readthedocs.io/en/stable/contributing

Use Hatch to serve the documentation with live updates during development.

```bash
hatch --env docs run serve
```

--------------------------------

### Initialize CacheStore

Source: https://zarr.readthedocs.io/en/stable/user-guide/experimental

Create a CacheStore by wrapping a source store with a cache backend.

```python
import zarr
from zarr.storage import LocalStore
import numpy as np
from tempfile import mkdtemp
from zarr.experimental.cache_store import CacheStore

# Create a local store and a separate cache store
local_store_path = mkdtemp(suffix='.zarr')
source_store = LocalStore(local_store_path)
cache_store = zarr.storage.MemoryStore()  # In-memory cache
cached_store = CacheStore(
    store=source_store,
    cache_store=cache_store,
    max_size=256*1024*1024  # 256MB cache
)

# Create an array using the cached store
zarr_array = zarr.zeros((100, 100), chunks=(10, 10), dtype='f8', store=cached_store, mode='w')

# Write some data to force chunk creation
zarr_array[:] = np.random.random((100, 100))
```

--------------------------------

### Install Zarr-Python

Source: https://zarr.readthedocs.io/en/stable?__cf_chl_rt_tk=zFJ5hFVkUlqJGfzzpccxh5od_FLMuEssw3zXzkSzdT0-1787231459-1.0.1.1-wAf1A.ABxQup0OJKnD2i1BN963hLgxLKbUW3xdtT.e0

Installation commands for Zarr-Python using pip or conda package managers.

```bash
pip install zarr
```

```bash
conda install -c conda-forge zarr
```

--------------------------------

### Build documentation locally

Source: https://zarr.readthedocs.io/en/stable/contributing

Use Hatch to build the documentation into the site folder.

```bash
hatch --env docs run build
```

--------------------------------

### Install Zarr CLI dependencies

Source: https://zarr.readthedocs.io/en/stable/user-guide/cli

Install the necessary dependencies to enable the Zarr command-line interface.

```bash
pip install "zarr[cli]"
```

--------------------------------

### Install prek hook manager

Source: https://zarr.readthedocs.io/en/stable/contributing

Alternative methods to install the prek pre-commit hook manager.

```bash
uv tool install prek
```

```bash
pip install prek
```

--------------------------------

### Install Zarr-Python 2.x

Source: https://zarr.readthedocs.io/en/stable/user-guide/v3_migration

Use this command to install the latest Zarr-Python 2 release for legacy support.

```bash
$ pip install "zarr==2.*"
```

--------------------------------

### Open store instance

Source: https://zarr.readthedocs.io/en/stable/api/zarr/abc/store

Create and open a store instance using provided arguments.

```python
open(*args: Any, **kwargs: Any) -> Self
```

```python
@classmethod
async def open(cls, *args: Any, **kwargs: Any) -> Self:
    """
    Create and open the store.

    Parameters
    ----------
    *args : Any
        Positional arguments to pass to the store constructor.
    **kwargs : Any
        Keyword arguments to pass to the store constructor.

    Returns
    -------
    Store
        The opened store instance.
    """
    store = cls(*args, **kwargs)
    await store._open()
    return store
```

--------------------------------

### Create a LocalStore

Source: https://zarr.readthedocs.io/en/stable/user-guide/storage

Initializes a store on the local filesystem. The store must be opened with the appropriate mode.

```python
store = zarr.storage.LocalStore('data/foo/bar', read_only=True)
group = zarr.open_group(store=store, mode='r')
print(group)
```

--------------------------------

### Run custom dtype example with pytest

Source: https://zarr.readthedocs.io/en/stable/user-guide/examples/custom_dtype

Executes the example script using pytest with specific configuration to avoid plugin errors.

```python
if __name__ == "__main__":
    # Run the example with printed output, and a dummy pytest configuration file specified.
    # Without the dummy configuration file, at test time pytest will attempt to use the
    # configuration file in the project root, which will error because Zarr is using some
    # plugins that are not installed in this example.
    sys.exit(
        pytest.main(
            [
                "-s",
                __file__,
                f"-c {__file__}",
                # Suppress: "PytestAssertRewriteWarning: Module already imported so
                # cannot be rewritten; zarr"
                "-W",
                "ignore::pytest.PytestAssertRewriteWarning",
            ]
        )
    )
```

--------------------------------

### Initialize BloscCodec

Source: https://zarr.readthedocs.io/en/stable/api/zarr/codecs

Demonstrates creating a BloscCodec instance with default settings and custom compression parameters.

```python
>>> codec = BloscCodec()
>>> codec.typesize
1
>>> codec.shuffle
'bitshuffle'
```

```python
>>> codec = BloscCodec(cname='zstd', clevel=9, shuffle='shuffle')
>>> codec.cname
'zstd'
```

--------------------------------

### WrapperStore.__init__

Source: https://zarr.readthedocs.io/en/stable/api/zarr/storage

Initializes a new WrapperStore instance wrapping a specific storage backend.

```APIDOC
## __init__(store: T_Store)

### Description
Initializes the wrapper with a provided storage backend.

### Parameters
- **store** (T_Store) - Required - The underlying storage object to be wrapped.
```

--------------------------------

### Retrieve group members with get()

Source: https://zarr.readthedocs.io/en/stable/api/zarr/group

Use the get method to retrieve an array or group member by path, returning a default value if the path does not exist.

```python
import zarr
from zarr.core.group import Group
group = Group.from_store(zarr.storage.MemoryStore())
group.create_array(name="subarray", shape=(10,), chunks=(10,), dtype="float64")
group.create_group(name="subgroup")
group.get("subarray")
# <Array memory://... shape=(10,) dtype=float64>
group.get("subgroup")
# <Group memory://...>
group.get("nonexistent", None)
# None
```

--------------------------------

### getitem

Source: https://zarr.readthedocs.io/en/stable/api/zarr/group

Get a subarray or subgroup from the group.

```APIDOC
## getitem(key: str) -> AnyAsyncArray | AsyncGroup

### Description
Get a subarray or subgroup from the group.

### Parameters
- **key** (str) - Required - Array or group name.

### Returns
- **AnyAsyncArray | AsyncGroup** - The requested subarray or subgroup.
```

--------------------------------

### LocalStore.open(root, read_only=False, mode=None)

Source: https://zarr.readthedocs.io/en/stable/api/zarr/storage?q=

Asynchronously creates and opens a LocalStore instance.

```APIDOC
## LocalStore.open(root, read_only=False, mode=None)

### Description
Asynchronously creates and opens the store at the specified root directory.

### Parameters
- **root** (str or Path) - Required - Directory to use as root of store.
- **read_only** (bool) - Optional - Whether the store is read-only.
- **mode** (AccessModeLiteral) - Optional - Mode in which to create the store.
```

--------------------------------

### get

Source: https://zarr.readthedocs.io/en/stable/api/zarr/storage?q=

Reads bytes from the store at the current path.

```APIDOC
## get(prototype=None, byte_range=None)

### Description
Read bytes from the store.

### Parameters
- **prototype** (BufferPrototype, optional) - The buffer prototype to use when reading the bytes.
- **byte_range** (ByteRequest, optional) - The range of bytes to read.

### Returns
- **buffer** (Buffer or None) - The read bytes, or None if the key does not exist.
```

--------------------------------

### Using ManagedMemoryStore

Source: https://zarr.readthedocs.io/en/stable/api/zarr/storage?q=

Demonstrates creating a store, resolving it via URL, and using path prefixes.

```python
>>> store = ManagedMemoryStore(name="my-data")
>>> str(store)
'memory://my-data'
>>> # Later, resolve the URL back to the store's dict
>>> store2 = ManagedMemoryStore.from_url("memory://my-data")
>>> store2._store_dict is store._store_dict
True
>>> # Create a store with a path prefix
>>> store3 = ManagedMemoryStore.from_url("memory://my-data/subdir")
>>> store3.path
'subdir'
```

--------------------------------

### get

Source: https://zarr.readthedocs.io/en/stable/api/zarr/storage?q=

Retrieve the value associated with a given key from the storage.

```APIDOC
## get(key, prototype=None, byte_range=None)

### Description
Retrieve the value associated with a given key. Optionally specify a buffer prototype or a byte range to fetch.

### Parameters
- **key** (str) - Required - The key to retrieve.
- **prototype** (BufferPrototype) - Optional - The prototype of the output buffer.
- **byte_range** (ByteRequest) - Optional - The byte range to retrieve. Can be RangeByteRequest, OffsetByteRequest, or SuffixByteRequest.

### Returns
- **Buffer | None** - The retrieved buffer or None if the key does not exist.
```

--------------------------------

### Create local store using string or Path

Source: https://zarr.readthedocs.io/en/stable/user-guide/storage

Demonstrates using either a string or a pathlib.Path object to define a local store location.

```python
group = zarr.open_group(store='data/foo/bar')
print(group)
```

```text
<Group file://data/foo/bar>
```

```python
from pathlib import Path
group = zarr.open_group(store=Path('data/foo/bar'))
print(group)
```

```text
<Group file://data/foo/bar>
```

--------------------------------

### list_prefix(prefix)

Source: https://zarr.readthedocs.io/en/stable/api/zarr/storage

Lists all files starting with a specific prefix.

```APIDOC
### Method
`async list_prefix(self, prefix: str) -> AsyncIterator[str]`

### Description
Asynchronously yields all file paths that start with the given prefix.

### Parameters
- **prefix** (str) - The prefix to filter files by.
```

--------------------------------

### Open store instance

Source: https://zarr.readthedocs.io/en/stable/api/zarr/experimental

Creates and initializes a store instance asynchronously.

```python
@classmethod
async def open(cls: type[Self], store_cls: type[T_Store], *args: Any, **kwargs: Any) -> Self:
    store = store_cls(*args, **kwargs)
    await store._open()
    return cls(store=store)
```

--------------------------------

### MemoryStore.delete_dir

Source: https://zarr.readthedocs.io/en/stable/api/zarr/testing/buffer

Removes all keys and prefixes starting with a given prefix.

```APIDOC
## delete_dir(prefix: str) -> None

### Description
Asynchronously removes all keys and prefixes in the store that begin with the specified prefix.

### Parameters
- **prefix** (str) - Required - The prefix string to match for deletion.
```

--------------------------------

### Initialization

Source: https://zarr.readthedocs.io/en/stable/api/zarr/storage?q=

Initializes the LoggingStore with a store and logging configuration.

```python
def __init__(
    self,
    store: T_Store,
    log_level: str = "DEBUG",
    log_handler: logging.Handler | None = None,
) -> None:
    super().__init__(store)
    self.counter = defaultdict(int)
    self.log_level = log_level
    self.log_handler = log_handler
    self._configure_logger(log_level, log_handler)
```

--------------------------------

### Get String Representation of Path

Source: https://zarr.readthedocs.io/en/stable/api/zarr/storage?q=

Returns the path string for the store.

```python
def __str__(self) -> str:
    return _join_paths([f"memory://{self._name}", self.path])
```

--------------------------------

### ZipStore.__init__

Source: https://zarr.readthedocs.io/en/stable/api/zarr/storage

Initializes a new ZipStore instance, which can be backed by a file path or a file-like object.

```APIDOC
## __init__(path, *, mode='r', read_only=None, compression=ZIP_STORED, allowZip64=True)

### Description
Initializes a ZipStore instance. The store can be opened from a file path or an existing binary file object.

### Parameters
- **path** (Path | str | IO[bytes]) - Required - The file path or file-like object to store data.
- **mode** (ZipStoreAccessModeLiteral) - Optional - Access mode, defaults to 'r'.
- **read_only** (bool | None) - Optional - Whether the store is read-only.
- **compression** (int) - Optional - Compression method to use.
- **allowZip64** (bool) - Optional - Whether to allow Zip64 extensions.
```

--------------------------------

### Get array basename

Source: https://zarr.readthedocs.io/en/stable/api/zarr/array

Retrieve the final component of the array name.

```python
basename: str
```

--------------------------------

### CacheStore.__init__

Source: https://zarr.readthedocs.io/en/stable/api/zarr/experimental

Initializes a new CacheStore instance with a primary store and a cache store.

```APIDOC
## __init__(store, *, cache_store, max_age_seconds='infinity', max_size=None, cache_set_data=True)

### Description
Initializes the CacheStore. The cache_store must support delete operations.

### Parameters
- **store** (Store) - Required - The primary store to wrap.
- **cache_store** (Store) - Required - The store used for caching.
- **max_age_seconds** (int | str) - Optional - Maximum age of cached items in seconds, or 'infinity'.
- **max_size** (int) - Optional - Maximum size of the cache.
- **cache_set_data** (bool) - Optional - Whether to cache set data operations.
```

--------------------------------

### BZ2.__init__

Source: https://zarr.readthedocs.io/en/stable/api/zarr/codecs/numcodecs

Initializes a new BZ2 codec instance with the provided configuration.

```APIDOC
## BZ2.__init__

### Description
Initializes the BZ2 codec instance. This class is used for BZ2 compression within the Zarr framework.

### Parameters
- **codec_config** (dict) - Optional - Configuration parameters for the codec.
```

--------------------------------

### Get Buffer Length

Source: https://zarr.readthedocs.io/en/stable/api/zarr/buffer/gpu

Returns the length of the underlying data array.

```python
def __len__(self) -> int:
    return self._data.__len__()
```

--------------------------------

### Get Buffer length

Source: https://zarr.readthedocs.io/en/stable/api/zarr/buffer/gpu

Returns the size of the underlying data array.

```python
def __len__(self) -> int:
    return self._data.size
```

--------------------------------

### Quantize.__init__

Source: https://zarr.readthedocs.io/en/stable/api/zarr/codecs/numcodecs

Initializes a new instance of the Quantize codec with the provided configuration.

```APIDOC
## Quantize.__init__(**codec_config: JSON)

### Description
Initializes the Quantize codec instance. The codec_config dictionary contains parameters required for the quantization process.

### Parameters
- **codec_config** (dict) - Required - Configuration parameters for the codec.
```

--------------------------------

### open(store_cls: type[T_Store], *args, **kwargs)

Source: https://zarr.readthedocs.io/en/stable/api/zarr/experimental

Create and open a Zarr store instance.

```APIDOC
## open(store_cls: type[T_Store], *args, **kwargs)

### Description
Create and open the store.

### Parameters
- **store_cls** (type[T_Store]) - Required - The class of the store to instantiate.
- **args** (Any) - Optional - Positional arguments to pass to the store constructor.
- **kwargs** (Any) - Optional - Keyword arguments to pass to the store constructor.

### Returns
- **Store** - The opened store instance.
```

--------------------------------

### List keys by prefix

Source: https://zarr.readthedocs.io/en/stable/api/zarr/storage?q=

Retrieves all keys that start with the specified prefix.

```python
def list_prefix(self, prefix: str) -> AsyncGenerator[str, None]:
    # docstring inherited
    return (obj["path"] async for obj in self._list(prefix))
```

--------------------------------

### open

Source: https://zarr.readthedocs.io/en/stable/api/zarr/storage?q=

Creates and opens a Zarr store at the specified root directory.

```APIDOC
## open(root: Path | str, *, read_only: bool = False, mode: AccessModeLiteral | None = None) -> Self

### Description
Create and open the store.

### Parameters
- **root** (str or Path) - Required - Directory to use as root of store.
- **read_only** (bool) - Optional - Whether the store is read-only (default: False).
- **mode** (AccessModeLiteral | None) - Optional - Mode in which to create the store (default: None).

### Returns
- **Store** - The opened store instance.
```

--------------------------------

### Implement to_dict for CRC32C

Source: https://zarr.readthedocs.io/en/stable/api/zarr/codecs

Example implementation of the to_dict method for the CRC32C codec.

```python
def to_dict(self) -> dict[str, JSON]:
    return {"name": "crc32c"}
```

--------------------------------

### has_cupy()

Source: https://zarr.readthedocs.io/en/stable/api/zarr/testing/utils

Checks if CuPy is installed and if at least one GPU device is available.

```APIDOC
## has_cupy

### Description
Determines if the environment supports GPU operations via CuPy.

### Signature
`has_cupy() -> bool`

### Returns
- **bool** - True if CuPy is installed and a GPU is detected, False otherwise.
```

--------------------------------

### Configure LocalStore with Memory Cache

Source: https://zarr.readthedocs.io/en/stable/user-guide/experimental

Initialize a CacheStore using a LocalStore as the source and a MemoryStore for temporary caching.

```python
from zarr.storage import LocalStore, MemoryStore
from zarr.experimental.cache_store import CacheStore
from tempfile import mkdtemp

local_store_path = mkdtemp(suffix='.zarr')
source_store = LocalStore(local_store_path)
cache_store = MemoryStore()
cached_store = CacheStore(
    store=source_store,
    cache_store=cache_store,
    max_size=128*1024*1024
)
```

--------------------------------

### Get ZipStore string representation

Source: https://zarr.readthedocs.io/en/stable/api/zarr/storage?q=

Returns a string representation of the ZipStore instance.

```python
def __str__(self) -> str:
    if self.path is None:
        return f"zip://{self._fileobj!r}"
    return f"zip://{self.path}"
```

--------------------------------

### ZFPY.__init__

Source: https://zarr.readthedocs.io/en/stable/api/zarr/codecs/numcodecs

Initializes a new instance of the ZFPY codec with the provided configuration.

```APIDOC
## ZFPY.__init__

### Description
Initializes the ZFPY codec instance with specific configuration parameters.

### Parameters
- **codec_config** (dict[str, JSON]) - Required - Configuration settings for the codec.
```

--------------------------------

### Get chunk data shape

Source: https://zarr.readthedocs.io/en/stable/api/zarr/array

Retrieve the number of chunks along each dimension.

```python
cdata_shape: tuple[int, ...]
```

--------------------------------

### StorePath.__init__

Source: https://zarr.readthedocs.io/en/stable/api/zarr/storage?q=

Initializes a new StorePath instance with a given store and path.

```APIDOC
## StorePath.__init__(store: Store, path: str = '')

### Description
Initializes a new StorePath instance associated with a specific Zarr store and a path within that store.

### Parameters
- **store** (Store) - Required - The Zarr store instance.
- **path** (str) - Optional - The path within the store (defaults to '').
```

--------------------------------

### Setup a 2-dimensional Zarr array

Source: https://zarr.readthedocs.io/en/stable/api/zarr/array

Initializes a 10x10 Zarr array with sequential data for demonstration purposes.

```python
>>> import zarr
>>> import numpy as np
>>> data = np.arange(100).reshape(10, 10)
>>> z = zarr.create_array(
...     {},
...     shape=data.shape,
...     chunks=data.shape,
...     dtype=data.dtype,
... )
>>> z[:] = data
```

--------------------------------

### Get MemoryStore Representation

Source: https://zarr.readthedocs.io/en/stable/api/zarr/testing/buffer

Methods to retrieve string representations of the store instance.

```python
def __repr__(self) -> str:
    return f"MemoryStore('{self}')"
```

```python
def __str__(self) -> str:
    return f"memory://{id(self._store_dict)}"
```

--------------------------------

### Buffer Representation and Length

Source: https://zarr.readthedocs.io/en/stable/api/zarr/abc/buffer

Methods for getting the length and string representation of the buffer.

```python
def __len__(self) -> int:
    return self._data.__len__()
```

```python
def __repr__(self) -> str:
    return f"<NDBuffer shape={self.shape} dtype={self.dtype} {self._data!r}>"
```

--------------------------------

### Initialize store

Source: https://zarr.readthedocs.io/en/stable/api/zarr/testing/stateful

Initializes the store by clearing it and creating a root group.

```python
@initialize()
def init_store(self) -> None:
    # This lets us reuse the fixture provided store.
    self._sync(self.store.clear())
    zarr.group(store=self.store)
```

--------------------------------

### Delete a directory prefix

Source: https://zarr.readthedocs.io/en/stable/api/zarr/storage?q=

Removes all keys and prefixes starting with the provided prefix.

```python
async def delete_dir(self, prefix: str) -> None:
    # docstring inherited
    self._check_writable()
    path = self.root / prefix
    if path.is_dir():
        shutil.rmtree(path)
    elif path.is_file():
        raise ValueError(f"delete_dir was passed a {prefix=!r} that is a file")
    else:
        # Non-existent directory
        # This path is tested by test_group:test_create_creates_parents for one
        pass
```

--------------------------------

### Delta.__init__

Source: https://zarr.readthedocs.io/en/stable/api/zarr/codecs/numcodecs

Initializes a new Delta codec instance with the provided configuration.

```APIDOC
## Delta.__init__(**codec_config: JSON)

### Description
Initializes the Delta codec with specific configuration parameters.

### Parameters
- **codec_config** (JSON) - Required - Configuration dictionary for the codec.
```

--------------------------------

### Define OffsetByteRequest dataclass

Source: https://zarr.readthedocs.io/en/stable/api/zarr/abc/store

Dataclass for requesting bytes starting from a specific offset.

```python
@dataclass(frozen=True, slots=True)
class OffsetByteRequest:
    """Request all bytes starting from a given byte offset"""

    offset: int
    """The byte offset for the offset range request."""
```

--------------------------------

### DateTime64 JSON Configuration

Source: https://zarr.readthedocs.io/en/stable/api/zarr/dtype

Example JSON structure for representing numpy.datetime64 in Zarr V3.

```json
{
    "name": "numpy.datetime64",
    "configuration": {
        "unit": "ms",
        "scale_factor": 1
    }
}
```

--------------------------------

### Create Zarr arrays asynchronously

Source: https://zarr.readthedocs.io/en/stable/api/zarr/api/asynchronous

Examples demonstrating how to initialize Zarr arrays from different data sources using asyncio.run.

```python
>>> arr3 = asyncio.run(
...     from_array({}, data=np.arange(10000, dtype="i4").reshape(100, 100))
... )
>>> arr3
<AsyncArray memory://... shape=(100, 100) dtype=int32>
```

```python
>>> arr4 = asyncio.run(from_array({}, data=[[1, 2], [3, 4]]))
>>> arr4
<AsyncArray memory://... shape=(2, 2) dtype=int64>
>>> asyncio.run(arr4.getitem(...))
array([[1, 2],
       [3, 4]])
```

```python
>>> arr5 = asyncio.run(from_array({}, data=Array(arr4), write_data=False))
>>> arr5
<AsyncArray memory://... shape=(2, 2) dtype=int64>
>>> asyncio.run(arr5.getitem(...))
array([[0, 0],
       [0, 0]])
```

--------------------------------

### Create a hierarchy of nodes

Source: https://zarr.readthedocs.io/en/stable/api/zarr/group

Example input structure for creating a hierarchy of arrays or groups.

```python
{'a/b': GroupMetadata}
```

```python
{'': GroupMetadata, 'a': GroupMetadata, 'b': Groupmetadata}
```

```python
nodes = {'': GroupMetadata()}
```

--------------------------------

### Open a store asynchronously

Source: https://zarr.readthedocs.io/en/stable/api/zarr/storage?q=

Creates and opens a store instance with specified configuration.

```python
@classmethod
async def open(cls: type[Self], store_cls: type[T_Store], *args: Any, **kwargs: Any) -> Self:
    log_level = kwargs.pop("log_level", "DEBUG")
    log_handler = kwargs.pop("log_handler", None)
    store = store_cls(*args, **kwargs)
    await store._open()
    return cls(store=store, log_level=log_level, log_handler=log_handler)
```

--------------------------------

### Define LZ4 Codec Class

Source: https://zarr.readthedocs.io/en/stable/api/zarr/codecs/numcodecs

Example of defining a codec class inheriting from _NumcodecsBytesBytesCodec.

```python
class LZ4(_NumcodecsBytesBytesCodec, codec_name="lz4"):
    pass
```

--------------------------------

### Asynchronous open method for StorePath

Source: https://zarr.readthedocs.io/en/stable/api/zarr/storage?q=

This method initializes a StorePath instance, enforcing access mode constraints and performing necessary setup operations like creating read-only copies or clearing directories.

```python
@classmethod
async def open(cls, store: Store, path: str, mode: AccessModeLiteral | None = None) -> Self:
    """
    Open StorePath based on the provided mode.

    * If the mode is None, return an opened version of the store with no changes.
    * If the mode is 'r+', 'w-', 'w', or 'a' and the store is read-only, raise a ValueError.
    * If the mode is 'r' and the store is not read-only, return a copy of the store with read_only set to True.
    * If the mode is 'w-' and the store is not read-only and the StorePath contains keys, raise a FileExistsError.
    * If the mode is 'w'  and the store is not read-only, delete all keys nested within the StorePath.

    Parameters
    ----------
    mode : AccessModeLiteral
        The mode to use when initializing the store path.

        The accepted values are:

        - ``'r'``: read only (must exist)
        - ``'r+'``: read/write (must exist)
        - ``'a'``: read/write (create if doesn't exist)
        - ``'w'``: read/write (overwrite if exists)
        - ``'w-'``: read/write (create if doesn't exist).

    Raises
    ------
    FileExistsError
        If the mode is 'w-' and the store path already exists.
    ValueError
        If the mode is not "r" and the store is read-only, or
    """

    # fastpath if mode is None
    if mode is None:
        return await cls._create_open_instance(store, path)

    if mode not in ANY_ACCESS_MODE:
        raise ValueError(f"Invalid mode: {mode}, expected one of {ANY_ACCESS_MODE}")

    if store.read_only:
        # Don't allow write operations on a read-only store
        if mode != "r":
            raise ValueError(
                f"Store is read-only but mode is {mode!r}. Create a writable store or use 'r' mode."
            )
        self = await cls._create_open_instance(store, path)
    elif mode == "r":
        # Create read-only copy for read mode on writable store
        try:
            read_only_store = store.with_read_only(True)
        except NotImplementedError as e:
            raise ValueError(
                "Store is not read-only but mode is 'r'. Unable to create a read-only copy of the store. "
                "Please use a read-only store or a storage class that implements .with_read_only()."
            ) from e
        self = await cls._create_open_instance(read_only_store, path)
    else:
        # writable store and writable mode
        self = await cls._create_open_instance(store, path)

    # Handle mode-specific operations
    match mode:
        case "w-":
            if not await self.is_empty():
                raise FileExistsError(
                    f"Cannot create '{path}' with mode 'w-' because it already contains data. "
                    f"Use mode 'w' to overwrite or 'a' to append."
                )
        case "w":
            await self.delete_dir()
    return self
```

--------------------------------

### Define BitRound codec class

Source: https://zarr.readthedocs.io/en/stable/api/zarr/codecs/numcodecs

Example of defining a codec class inheriting from _NumcodecsArrayArrayCodec.

```python
class BitRound(_NumcodecsArrayArrayCodec, codec_name="bitround"):
    pass
```

--------------------------------

### __init__(store, *, get_latency=0, set_latency=0)

Source: https://zarr.readthedocs.io/en/stable/api/zarr/testing/store

Initializes a new testing store wrapper around an existing store, with optional synthetic latency for get and set operations.

```APIDOC
## __init__(store, *, get_latency=0, set_latency=0)

### Description
Initializes the testing store wrapper. This wraps an existing store and allows for the configuration of synthetic latency for read and write operations.

### Parameters
- **store** (Store) - Required - The underlying store to wrap.
- **get_latency** (float | tuple[float, float]) - Optional - Synthetic latency for get operations, either a fixed float or a range tuple.
- **set_latency** (float | tuple[float, float]) - Optional - Synthetic latency for set operations, either a fixed float or a range tuple.
```

--------------------------------

### Shuffle.__init__

Source: https://zarr.readthedocs.io/en/stable/api/zarr/codecs/numcodecs

Initializes a new Shuffle codec instance with the provided configuration.

```APIDOC
## Shuffle.__init__(**codec_config: JSON)

### Description
Initializes the Shuffle codec with specific configuration parameters.

### Parameters
- **codec_config** (JSON) - Required - Configuration dictionary for the codec.
```

--------------------------------

### Resolve Numcodec

Source: https://zarr.readthedocs.io/en/stable/api/zarr/registry?q=

Resolves a codec from the numcodecs registry. Requires the Numcodecs package to be installed.

```python
get_numcodec(data: CodecJSON_V2[str]) -> Numcodec
```

```python
from zarr.registry import get_numcodec
codec = get_numcodec({'id': 'zlib', 'level': 1})
codec
# Zlib(level=1)
```

```python
def get_numcodec(data: CodecJSON_V2[str]) -> Numcodec:
    """
    Resolve a numcodec codec from the numcodecs registry.

    This requires the Numcodecs package to be installed.

    Parameters
    ----------
    data : CodecJSON_V2
        The JSON metadata for the codec.

    Returns
    -------
    codec : Numcodec

    Examples
    --------
    ```python
    from zarr.registry import get_numcodec
    codec = get_numcodec({'id': 'zlib', 'level': 1})
    codec
    # Zlib(level=1)
    ```
    """

    from numcodecs.registry import get_codec

    return get_codec(data)  # type: ignore[no-any-return]
```

--------------------------------

### Implement directory and file listing methods

Source: https://zarr.readthedocs.io/en/stable/api/zarr/storage

Methods for listing files and directories within the store path.

```python
async def list(self) -> AsyncIterator[str]:
    # docstring inherited
    allfiles = await self.fs._find(self.path, detail=False, withdirs=False)
    for onefile in (a.removeprefix(f"{self.path}/") for a in allfiles):
        yield onefile
```

```python
async def list_dir(self, prefix: str) -> AsyncIterator[str]:
    # docstring inherited
    prefix = f"{self.path}/{prefix.rstrip('/')}"
    try:
        allfiles = await self.fs._ls(prefix, detail=False)
    except FileNotFoundError:
        return
    for onefile in (a.replace(f"{prefix}/", "") for a in allfiles):
        yield onefile.removeprefix(self.path).removeprefix("/")
```

```python
async def list_prefix(self, prefix: str) -> AsyncIterator[str]:
    # docstring inherited
    for onefile in await self.fs._find(
        f"{self.path}/{prefix}", detail=False, maxdepth=None, withdirs=False
    ):
        yield onefile.removeprefix(f"{self.path}/")
```

--------------------------------

### BitRound.__init__

Source: https://zarr.readthedocs.io/en/stable/api/zarr/codecs/numcodecs

Initializes a new instance of the BitRound codec with the provided configuration.

```APIDOC
## BitRound.__init__

### Description
Initializes the BitRound codec instance using a dictionary of configuration parameters.

### Parameters
- **codec_config** (dict[str, JSON]) - Required - Configuration settings for the codec.
```

--------------------------------

### __init__(array: NDArrayLike)

Source: https://zarr.readthedocs.io/en/stable/api/zarr/buffer/gpu

Initializes a new NDBuffer instance. Requires cupy to be installed.

```APIDOC
## __init__(array: NDArrayLike)

### Description
Initializes a new NDBuffer instance using the provided array. If the array does not support the __cuda_array_interface__, it will fall back to a copy-based path.

### Parameters
- **array** (NDArrayLike) - Required - The input array to be stored in the buffer.
```
Tokens:
Raw