zarrs 0.1.0__cp311-abi3-win_arm64.whl

zarrs/__init__.py

@@ -0,0 +1,20 @@
+from zarr.registry import register_pipeline
+
+from ._internal import __version__
+from .pipeline import ZarrsCodecPipeline as _ZarrsCodecPipeline
+from .utils import CollapsedDimensionError, DiscontiguousArrayError
+
+
+# Need to do this redirection so people can access the pipeline as `zarrs.ZarrsCodecPipeline` instead of `zarrs.pipeline.ZarrsCodecPipeline`
+class ZarrsCodecPipeline(_ZarrsCodecPipeline):
+    pass
+
+
+register_pipeline(ZarrsCodecPipeline)
+
+__all__ = [
+    "ZarrsCodecPipeline",
+    "DiscontiguousArrayError",
+    "CollapsedDimensionError",
+    "__version__",
+]

zarrs/_internal.pyi

@@ -0,0 +1,47 @@
+# This file is automatically generated by pyo3_stub_gen
+# ruff: noqa: E501, F401
+
+import typing
+
+import numpy
+import numpy.typing
+
+class CodecPipelineImpl:
+    def __new__(
+        cls,
+        metadata,
+        *,
+        validate_checksums=...,
+        store_empty_chunks=...,
+        chunk_concurrent_minimum=...,
+        chunk_concurrent_maximum=...,
+        num_threads=...,
+    ): ...
+    def retrieve_chunks_and_apply_index(
+        self,
+        chunk_descriptions: typing.Sequence[
+            tuple[
+                tuple[str, typing.Sequence[int], str, typing.Sequence[int]],
+                typing.Sequence[slice],
+                typing.Sequence[slice],
+            ]
+        ],
+        value: numpy.NDArray[typing.Any],
+    ) -> None: ...
+    def retrieve_chunks(
+        self,
+        chunk_descriptions: typing.Sequence[
+            tuple[str, typing.Sequence[int], str, typing.Sequence[int]]
+        ],
+    ) -> list[numpy.typing.NDArray[numpy.uint8]]: ...
+    def store_chunks_with_indices(
+        self,
+        chunk_descriptions: typing.Sequence[
+            tuple[
+                tuple[str, typing.Sequence[int], str, typing.Sequence[int]],
+                typing.Sequence[slice],
+                typing.Sequence[slice],
+            ]
+        ],
+        value: numpy.NDArray[typing.Any],
+    ) -> None: ...

zarrs/pipeline.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+import asyncio
+import json
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+from zarr.abc.codec import (
+    Codec,
+    CodecPipeline,
+)
+from zarr.core.config import config
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Iterator
+    from typing import Self
+
+    from zarr.abc.store import ByteGetter, ByteSetter
+    from zarr.core.array_spec import ArraySpec
+    from zarr.core.buffer import Buffer, NDBuffer
+    from zarr.core.chunk_grids import ChunkGrid
+    from zarr.core.common import ChunkCoords
+    from zarr.core.indexing import SelectorTuple
+
+from ._internal import CodecPipelineImpl
+from .utils import (
+    CollapsedDimensionError,
+    DiscontiguousArrayError,
+    make_chunk_info_for_rust,
+    make_chunk_info_for_rust_with_indices,
+)
+
+
+@dataclass(frozen=True)
+class ZarrsCodecPipeline(CodecPipeline):
+    codecs: tuple[Codec, ...]
+    impl: CodecPipelineImpl
+
+    def evolve_from_array_spec(self, array_spec: ArraySpec) -> Self:
+        raise NotImplementedError("evolve_from_array_spec")
+
+    @classmethod
+    def from_codecs(cls, codecs: Iterable[Codec]) -> Self:
+        codec_metadata = [codec.to_dict() for codec in codecs]
+        codec_metadata_json = json.dumps(codec_metadata)
+        # TODO: upstream zarr-python has not settled on how to deal with configs yet
+        # Should they be checked when an array is created, or when an operation is performed?
+        # https://github.com/zarr-developers/zarr-python/issues/2409
+        # https://github.com/zarr-developers/zarr-python/pull/2429
+        return cls(
+            codecs=tuple(codecs),
+            impl=CodecPipelineImpl(
+                codec_metadata_json,
+                validate_checksums=config.get(
+                    "codec_pipeline.validate_checksums", None
+                ),
+                # TODO: upstream zarr-python array.write_empty_chunks is not merged yet #2429
+                store_empty_chunks=config.get("array.write_empty_chunks", None),
+                chunk_concurrent_minimum=config.get(
+                    "codec_pipeline.chunk_concurrent_minimum", None
+                ),
+                chunk_concurrent_maximum=config.get(
+                    "codec_pipeline.chunk_concurrent_maximum", None
+                ),
+                num_threads=config.get("threading.max_workers", None),
+            ),
+        )
+
+    @property
+    def supports_partial_decode(self) -> bool:
+        return False
+
+    @property
+    def supports_partial_encode(self) -> bool:
+        return False
+
+    def __iter__(self) -> Iterator[Codec]:
+        yield from self.codecs
+
+    def validate(
+        self, *, shape: ChunkCoords, dtype: np.dtype[Any], chunk_grid: ChunkGrid
+    ) -> None:
+        raise NotImplementedError("validate")
+
+    def compute_encoded_size(self, byte_length: int, array_spec: ArraySpec) -> int:
+        raise NotImplementedError("compute_encoded_size")
+
+    async def decode(
+        self,
+        chunk_bytes_and_specs: Iterable[tuple[Buffer | None, ArraySpec]],
+    ) -> Iterable[NDBuffer | None]:
+        raise NotImplementedError("decode")
+
+    async def encode(
+        self,
+        chunk_arrays_and_specs: Iterable[tuple[NDBuffer | None, ArraySpec]],
+    ) -> Iterable[Buffer | None]:
+        raise NotImplementedError("encode")
+
+    async def read(
+        self,
+        batch_info: Iterable[
+            tuple[ByteGetter, ArraySpec, SelectorTuple, SelectorTuple]
+        ],
+        out: NDBuffer,
+        drop_axes: tuple[int, ...] = (),  # FIXME: unused
+    ) -> None:
+        out = out.as_ndarray_like()  # FIXME: Error if array is not in host memory
+        if not out.dtype.isnative:
+            raise RuntimeError("Non-native byte order not supported")
+        try:
+            chunks_desc = make_chunk_info_for_rust_with_indices(batch_info, drop_axes)
+            index_in_rust = True
+        except (DiscontiguousArrayError, CollapsedDimensionError):
+            chunks_desc = make_chunk_info_for_rust(batch_info)
+            index_in_rust = False
+        if index_in_rust:
+            await asyncio.to_thread(
+                self.impl.retrieve_chunks_and_apply_index,
+                chunks_desc,
+                out,
+            )
+            return None
+        chunks = await asyncio.to_thread(self.impl.retrieve_chunks, chunks_desc)
+        for chunk, chunk_info in zip(chunks, batch_info):
+            out_selection = chunk_info[3]
+            selection = chunk_info[2]
+            spec = chunk_info[1]
+            chunk_reshaped = chunk.view(spec.dtype).reshape(spec.shape)
+            chunk_selected = chunk_reshaped[selection]
+            if drop_axes:
+                chunk_selected = np.squeeze(chunk_selected, axis=drop_axes)
+            out[out_selection] = chunk_selected
+
+    async def write(
+        self,
+        batch_info: Iterable[
+            tuple[ByteSetter, ArraySpec, SelectorTuple, SelectorTuple]
+        ],
+        value: NDBuffer,
+        drop_axes: tuple[int, ...] = (),
+    ) -> None:
+        value = value.as_ndarray_like()  # FIXME: Error if array is not in host memory
+        if not value.dtype.isnative:
+            value = np.ascontiguousarray(value, dtype=value.dtype.newbyteorder("="))
+        elif not value.flags.c_contiguous:
+            value = np.ascontiguousarray(value)
+        chunks_desc = make_chunk_info_for_rust_with_indices(batch_info, drop_axes)
+        await asyncio.to_thread(
+            self.impl.store_chunks_with_indices,
+            chunks_desc,
+            value,
+        )
+        return None

zarrs/utils.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+import operator
+import os
+from functools import reduce
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+from zarr.core.indexing import SelectorTuple, is_integer
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from types import EllipsisType
+
+    from zarr.abc.store import ByteGetter, ByteSetter
+    from zarr.core.array_spec import ArraySpec
+    from zarr.core.common import ChunkCoords
+
+
+# adapted from https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.ThreadPoolExecutor
+def get_max_threads() -> int:
+    return (os.cpu_count() or 1) + 4
+
+
+class DiscontiguousArrayError(Exception):
+    pass
+
+
+class CollapsedDimensionError(Exception):
+    pass
+
+
+# This is a (mostly) copy of the function from zarr.core.indexing that fixes:
+#   DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated
+# TODO: Upstream this fix
+def make_slice_selection(selection: tuple[np.ndarray | float]) -> list[slice]:
+    ls: list[slice] = []
+    for dim_selection in selection:
+        if is_integer(dim_selection):
+            ls.append(slice(int(dim_selection), int(dim_selection) + 1, 1))
+        elif isinstance(dim_selection, np.ndarray):
+            dim_selection = dim_selection.ravel()
+            if len(dim_selection) == 1:
+                ls.append(
+                    slice(int(dim_selection.item()), int(dim_selection.item()) + 1, 1)
+                )
+            else:
+                diff = np.diff(dim_selection)
+                if (diff != 1).any() and (diff != 0).any():
+                    raise DiscontiguousArrayError(diff)
+                ls.append(slice(dim_selection[0], dim_selection[-1] + 1, 1))
+        else:
+            ls.append(dim_selection)
+    return ls
+
+
+def selector_tuple_to_slice_selection(selector_tuple: SelectorTuple) -> list[slice]:
+    if isinstance(selector_tuple, slice):
+        return [selector_tuple]
+    if all(isinstance(s, slice) for s in selector_tuple):
+        return list(selector_tuple)
+    return make_slice_selection(selector_tuple)
+
+
+def convert_chunk_to_primitive(
+    byte_getter: ByteGetter | ByteSetter, chunk_spec: ArraySpec
+) -> tuple[str, ChunkCoords, str, Any]:
+    return (
+        str(byte_getter),
+        chunk_spec.shape,
+        str(chunk_spec.dtype),
+        chunk_spec.fill_value.tobytes(),
+    )
+
+
+def resulting_shape_from_index(
+    array_shape: tuple[int, ...],
+    index_tuple: tuple[int | slice | EllipsisType | np.ndarray],
+    drop_axes: tuple[int, ...],
+    *,
+    pad: bool,
+) -> tuple[int, ...]:
+    result_shape = []
+    advanced_index_shapes = [
+        idx.shape for idx in index_tuple if isinstance(idx, np.ndarray)
+    ]
+    basic_shape_index = 0
+
+    # Broadcast all advanced indices, if any
+    if advanced_index_shapes:
+        result_shape += np.broadcast_shapes(*advanced_index_shapes)
+        # Consume dimensions from array_shape
+        basic_shape_index += len(advanced_index_shapes)
+
+    # Process each remaining index in index_tuple
+    for idx in index_tuple:
+        if isinstance(idx, int):
+            # Integer index reduces dimension, so skip this dimension in array_shape
+            basic_shape_index += 1
+        elif isinstance(idx, slice):
+            if idx.step is not None and idx.step > 1:
+                raise DiscontiguousArrayError(
+                    "Step size greater than 1 is not supported"
+                )
+            # Slice keeps dimension, adjust size accordingly
+            start, stop, _ = idx.indices(array_shape[basic_shape_index])
+            result_shape.append(stop - start)
+            basic_shape_index += 1
+        elif idx is Ellipsis:
+            # Calculate number of dimensions that Ellipsis should fill
+            num_to_fill = len(array_shape) - len(index_tuple) + 1
+            result_shape += array_shape[
+                basic_shape_index : basic_shape_index + num_to_fill
+            ]
+            basic_shape_index += num_to_fill
+        elif not isinstance(idx, np.ndarray):
+            raise ValueError(f"Invalid index type: {type(idx)}")
+
+    # Step 4: Append remaining dimensions from array_shape if fewer indices were used
+    if basic_shape_index < len(array_shape) and pad:
+        result_shape += array_shape[basic_shape_index:]
+
+    return tuple(size for idx, size in enumerate(result_shape) if idx not in drop_axes)
+
+
+def prod_op(x: Iterable[int]) -> int:
+    return reduce(operator.mul, x, 1)
+
+
+def get_shape_for_selector(
+    selector_tuple: SelectorTuple,
+    shape: tuple[int, ...],
+    *,
+    pad: bool,
+    drop_axes: tuple[int, ...] = (),
+) -> tuple[int, ...]:
+    if isinstance(selector_tuple, slice | np.ndarray):
+        return resulting_shape_from_index(
+            shape,
+            (selector_tuple,),
+            drop_axes,
+            pad=pad,
+        )
+    return resulting_shape_from_index(shape, selector_tuple, drop_axes, pad=pad)
+
+
+def make_chunk_info_for_rust_with_indices(
+    batch_info: Iterable[
+        tuple[ByteGetter | ByteSetter, ArraySpec, SelectorTuple, SelectorTuple]
+    ],
+    drop_axes: tuple[int, ...],
+) -> list[tuple[tuple[str, ChunkCoords, str, Any], list[slice], list[slice]]]:
+    chunk_info_with_indices = []
+    for byte_getter, chunk_spec, chunk_selection, out_selection in batch_info:
+        chunk_info = convert_chunk_to_primitive(byte_getter, chunk_spec)
+        out_selection_as_slices = selector_tuple_to_slice_selection(out_selection)
+        chunk_selection_as_slices = selector_tuple_to_slice_selection(chunk_selection)
+        shape_chunk_selection_slices = get_shape_for_selector(
+            tuple(chunk_selection_as_slices),
+            chunk_spec.shape,
+            pad=True,
+            drop_axes=drop_axes,
+        )
+        shape_chunk_selection = get_shape_for_selector(
+            chunk_selection, chunk_spec.shape, pad=True, drop_axes=drop_axes
+        )
+        if prod_op(shape_chunk_selection) != prod_op(shape_chunk_selection_slices):
+            raise CollapsedDimensionError(
+                f"{shape_chunk_selection} != {shape_chunk_selection_slices}"
+            )
+        chunk_info_with_indices.append(
+            (chunk_info, out_selection_as_slices, chunk_selection_as_slices)
+        )
+    return chunk_info_with_indices
+
+
+def make_chunk_info_for_rust(
+    batch_info: Iterable[
+        tuple[ByteGetter | ByteSetter, ArraySpec, SelectorTuple, SelectorTuple]
+    ],
+) -> list[tuple[str, ChunkCoords, str, Any]]:
+    return list(
+        convert_chunk_to_primitive(byte_getter, chunk_spec)
+        for (byte_getter, chunk_spec, _, _) in batch_info
+    )

zarrs-0.1.0.dist-info/METADATA

@@ -0,0 +1,159 @@
+Metadata-Version: 2.3
+Name: zarrs
+Version: 0.1.0
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Typing :: Typed
+Requires-Dist: asciitree
+Requires-Dist: numpy >=1.24
+Requires-Dist: fasteners
+Requires-Dist: numcodecs[msgpack] >=0.10.0
+Requires-Dist: fsspec >2024
+Requires-Dist: crc32c
+Requires-Dist: zstandard
+Requires-Dist: typing-extensions
+Requires-Dist: donfig
+Requires-Dist: pytest
+Requires-Dist: universal-pathlib >=0.2.0
+Requires-Dist: zarr >=3.0.0b2
+Requires-Dist: coverage ; extra == 'test'
+Requires-Dist: pytest ; extra == 'test'
+Requires-Dist: pytest-cov ; extra == 'test'
+Requires-Dist: msgpack ; extra == 'test'
+Requires-Dist: lmdb ; extra == 'test'
+Requires-Dist: s3fs ; extra == 'test'
+Requires-Dist: pytest-asyncio ; extra == 'test'
+Requires-Dist: moto[s3] ; extra == 'test'
+Requires-Dist: flask-cors ; extra == 'test'
+Requires-Dist: flask ; extra == 'test'
+Requires-Dist: requests ; extra == 'test'
+Requires-Dist: mypy ; extra == 'test'
+Requires-Dist: hypothesis ; extra == 'test'
+Requires-Dist: pytest-xdist ; extra == 'test'
+Requires-Dist: maturin ; extra == 'dev'
+Requires-Dist: pip ; extra == 'dev'
+Requires-Dist: pre-commit ; extra == 'dev'
+Requires-Dist: sphinx >=7.4.6 ; extra == 'doc'
+Requires-Dist: myst-parser ; extra == 'doc'
+Provides-Extra: test
+Provides-Extra: dev
+Provides-Extra: doc
+License-File: LICENSE
+Author: Ilan Gold, Lachlan Deakin, Philipp Angerer
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# zarrs-python
+
+```{warning}
+⚠️ The version of `zarr-python` we currently depend on is still in pre-release and this
+package is accordingly extremely experimental.
+We cannot guarantee any stability or correctness at the moment, although we have
+tried to do extensive testing and make clear what we think we support and do not.
+```
+
+This project serves as a bridge between [`zarrs`](https://docs.rs/zarrs/latest/zarrs/) and [`zarr`](https://zarr.readthedocs.io/en/latest/index.html) via [`PyO3`](https://pyo3.rs/v0.22.3/).  The main goal of the project is to speed up i/o.
+
+To use the project, simply install our package (which depends on `zarr-python>3.0.0b0`), and run:
+
+```python
+import zarr
+import zarrs
+zarr.config.set({"codec_pipeline.path": "zarrs.ZarrsCodecPipeline"})
+```
+
+You can then use your `zarr` as normal (with some caveats)!
+
+## API
+
+We export a `ZarrsCodecPipeline` class so that `zarr-python` can use the class but it is not meant to be instantiated and we do not guarantee the stability of its API beyond what is required so that `zarr-python` can use it.  Therefore, it is not documented here.  We also export two errors, `DiscontiguousArrayError` and `CollapsedDimensionError` that can be thrown in the process of converting to indexers that `zarrs` can understand (see below for more details).
+
+### Configuration
+
+`ZarrsCodecPipeline` options are exposed through `zarr.config`.
+
+Standard `zarr.config` options control some functionality (see the defaults in the [config.py](https://github.com/zarr-developers/zarr-python/blob/main/src/zarr/core/config.py) of `zarr-python`):
+- `threading.max_workers`: the maximum number of threads used internally by the `ZarrsCodecPipeline` on the Rust side.
+  - Defaults to the number of threads in the global `rayon` thread pool if set to `None`, which is [typically the number of logical CPUs](https://docs.rs/rayon/latest/rayon/struct.ThreadPoolBuilder.html#method.num_threads).
+- `array.write_empty_chunks`: whether or not to store empty chunks.
+  - Defaults to false if `None`. Note that checking for emptiness has some overhead, see [here](https://docs.rs/zarrs/latest/zarrs/config/struct.Config.html#store-empty-chunks) for more info.
+  - This option name is proposed in [zarr-python #2429](https://github.com/zarr-developers/zarr-python/pull/2429)
+
+The `ZarrsCodecPipeline` specific options are:
+- `codec_pipeline.chunk_concurrent_maximum`: the maximum number of chunks stored/retrieved concurrently.
+  - Defaults to the number of logical CPUs if `None`. It is constrained by `threading.max_workers` as well.
+- `codec_pipeline.chunk_concurrent_minimum`: the minimum number of chunks retrieved/stored concurrently when balancing chunk/codec concurrency.
+  - Defaults to 4 if `None`. See [here](https://docs.rs/zarrs/latest/zarrs/config/struct.Config.html#chunk-concurrent-minimum) for more info.
+- `codec_pipeline.validate_checksums`: enable checksum validation (e.g. with the CRC32C codec).
+  - Defaults to true if `None`. See [here](https://docs.rs/zarrs/latest/zarrs/config/struct.Config.html#validate-checksums) for more info.
+
+For example:
+```python
+zarr.config.set({
+    "threading.max_workers": None,
+    "array.write_empty_chunks": False,
+    "codec_pipeline": {
+        "path": "zarrs.ZarrsCodecPipeline",
+        "validate_checksums": True,
+        "store_empty_chunks": False,
+        "chunk_concurrent_maximum": None,
+        "chunk_concurrent_minimum": 4,
+    }
+})
+```
+
+## Concurrency
+
+Concurrency can be classified into two types:
+- chunk (outer) concurrency: the number of chunks retrieved/stored concurrently.
+  - This is chosen automatically based on various factors, such as the chunk size and codecs.
+  - It is constrained between `codec_pipeline.chunk_concurrent_minimum` and `codec_pipeline.chunk_concurrent_maximum` for operations involving multiple chunks.
+- codec (inner) concurrency: the number of threads encoding/decoding a chunk.
+  - This is chosen automatically in combination with the chunk concurrency.
+
+The product of the chunk and codec concurrency will approximately match `threading.max_workers`.
+
+Chunk concurrency is typically favored because:
+- parallel encoding/decoding can have a high overhead with some codecs, especially with small chunks, and
+- it is advantageous to retrieve/store multiple chunks concurrently, especially with high latency stores.
+
+`zarrs-python` will often favor codec concurrency with sharded arrays, as they are well suited to codec concurrency.
+
+## Supported Indexing Methods
+
+We **do not** officially support the following indexing methods.  Some of these methods may error out, others may not:
+
+1. Any `oindex` or `vindex` integer `np.ndarray` indexing with dimensionality >=3 i.e.,
+
+   ```python
+   arr[np.array([...]), :, np.array([...])]
+   arr[np.array([...]), np.array([...]), np.array([...])]
+   arr[np.array([...]), np.array([...]), np.array([...])] = ...
+   arr.oindex[np.array([...]), np.array([...]), np.array([...])] = ...
+   ```
+
+2. Any `vindex` or `oindex` discontinuous integer `np.ndarray` indexing for writes in 2D
+
+   ```python
+   arr[np.array([0, 5]), :] = ...
+   arr.oindex[np.array([0, 5]), :] = ...
+   ```
+
+3. `vindex` writes in 2D where both indexers are integer `np.ndarray` indices i.e.,
+
+   ```python
+   arr[np.array([...]), np.array([...])] = ...
+   ```
+
+4. Ellipsis indexing.  We have tested some, but others fail even with `zarr-python`'s default codec pipeline.  Thus for now we advise proceeding with caution here.
+
+   ```python
+   arr[0:10, ..., 0:5]
+   ```
+
+Otherwise, we believe that we support your indexing case: slices, ints, and all integer `np.ndarray` indices in 2D for reading, contiguous integer `np.ndarray` indices along one axis for writing etc.  Please file an issue if you believe we have more holes in our coverage than we are aware of or you wish to contribute!  For example, we have an [issue in zarrs for integer-array indexing](https://github.com/LDeakin/zarrs/issues/52) that would unblock a lot of these issues!
+
+That being said, using non-contiguous integer `np.ndarray` indexing for reads may not be as fast as expected given the performance of other supported methods.  Until `zarrs` supports integer indexing, only fetching chunks is done in `rust` while indexing then occurs in `python`.
+

zarrs-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+zarrs-0.1.0.dist-info/METADATA,sha256=VVcA3Tg_ZiPJbKKRGHcdkh8EBF6FhNccFYCNYSsVaMg,8034
+zarrs-0.1.0.dist-info/WHEEL,sha256=IIOEIeL6JkNdHLaHuqnvZYoUNEEUPYODpDuSBpZNzPA,95
+zarrs-0.1.0.dist-info/licenses/LICENSE,sha256=JRFtUrB6PKdja3SAsuPOyvJ25Z9zGYOQqpcq8vGH4VI,1120
+zarrs/pipeline.py,sha256=U2JgDsUZnqthtlo_tNkXBAsEu8duzNYgdja5xQiz5r8,5731
+zarrs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+zarrs/utils.py,sha256=Qk36lsjwXFPPhzTUDvV655bAaXEq_eDSU_4BadnRZfw,6773
+zarrs/_internal.pyi,sha256=2pUSpGTgC8ZWe4P_Yj8tLFiJIaqLk6dBhu_8FLQZ8zk,1377
+zarrs/__init__.py,sha256=sH-kAXq8toCGbdGm1IOxr2JambnwnzqNxwrSjmv5hlk,593
+zarrs/_internal.pyd,sha256=zCX5Z7xqG0BHH8-1lBYLV9mScmB1i_DSMhXVyYCw4Pk,2421760
+zarrs-0.1.0.dist-info/RECORD,,

zarrs-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.7.4)
+Root-Is-Purelib: false
+Tag: cp311-abi3-win_arm64

zarrs-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Ilan Gold, Lachlan Deakin, Philipp Angerer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.