numcodecs 0.13.0__cp312-cp312-win_amd64.whl → 0.14.0__cp312-cp312-win_amd64.whl

numcodecs/tests/test_lz4.py

@@ -1,10 +1,8 @@
 import itertools
 
-
 import numpy as np
 import pytest
 
-
 try:
     from numcodecs.lz4 import LZ4
 except ImportError:  # pragma: no cover
@@ -12,16 +10,15 @@ except ImportError:  # pragma: no cover
 
 
 from numcodecs.tests.common import (
-    check_encode_decode,
-    check_config,
-    check_repr,
     check_backwards_compatibility,
+    check_config,
+    check_encode_decode,
     check_err_decode_object_buffer,
     check_err_encode_object_buffer,
     check_max_buffer_size,
+    check_repr,
 )
 
-
 codecs = [
     LZ4(),
     LZ4(acceleration=-1),

numcodecs/tests/test_lzma.py

@@ -1,27 +1,28 @@
 import itertools
 import unittest
-
+from types import ModuleType
+from typing import cast
 
 import numpy as np
 import pytest
 
-
 try:
     # noinspection PyProtectedMember
     from numcodecs.lzma import LZMA, _lzma
-except ImportError:  # pragma: no cover
-    raise unittest.SkipTest("LZMA not available")
+except ImportError as e:  # pragma: no cover
+    raise unittest.SkipTest("LZMA not available") from e
 
 
 from numcodecs.tests.common import (
-    check_encode_decode,
-    check_config,
-    check_repr,
     check_backwards_compatibility,
+    check_config,
+    check_encode_decode,
     check_err_decode_object_buffer,
     check_err_encode_object_buffer,
+    check_repr,
 )
 
+_lzma = cast(ModuleType, _lzma)
 
 codecs = [
     LZMA(),

numcodecs/tests/test_msgpacks.py

@@ -1,25 +1,22 @@
 import unittest
 
-
 import numpy as np
 import pytest
 
-
 try:
     from numcodecs.msgpacks import MsgPack
-except ImportError:  # pragma: no cover
-    raise unittest.SkipTest("msgpack not available")
+except ImportError as e:  # pragma: no cover
+    raise unittest.SkipTest("msgpack not available") from e
 
 
 from numcodecs.tests.common import (
+    check_backwards_compatibility,
     check_config,
-    check_repr,
     check_encode_decode_array,
-    check_backwards_compatibility,
+    check_repr,
     greetings,
 )
 
-
 # object array with strings
 # object array with mix strings / nans
 # object array with mix of string, int, float
@@ -58,8 +55,11 @@ def test_backwards_compatibility():
     check_backwards_compatibility(codec.codec_id, arrays, [codec])
 
 
+@pytest.mark.filterwarnings(
+    "ignore:Creating an ndarray from ragged nested sequences .* is deprecated.*"
+)
 @pytest.mark.parametrize(
-    "input_data, dtype",
+    ("input_data", "dtype"),
     [
         ([0, 1], None),
         ([[0, 1], [2, 3]], None),

numcodecs/tests/test_packbits.py

@@ -1,15 +1,13 @@
 import numpy as np
 
-
 from numcodecs.packbits import PackBits
 from numcodecs.tests.common import (
-    check_encode_decode,
+    check_backwards_compatibility,
     check_config,
+    check_encode_decode,
     check_repr,
-    check_backwards_compatibility,
 )
 
-
 arrays = [
     np.random.randint(0, 2, size=1000, dtype=bool),
     np.random.randint(0, 2, size=(100, 10), dtype=bool),

numcodecs/tests/test_pcodec.py

@@ -1,5 +1,5 @@
-import pytest
 import numpy as np
+import pytest
 
 from numcodecs.pcodec import PCodec
 
@@ -10,15 +10,14 @@ except ImportError:  # pragma: no cover
     pytest.skip("pcodec not available", allow_module_level=True)
 
 from numcodecs.tests.common import (
-    check_encode_decode_array_to_bytes,
-    check_config,
-    check_repr,
     check_backwards_compatibility,
+    check_config,
+    check_encode_decode_array_to_bytes,
     check_err_decode_object_buffer,
     check_err_encode_object_buffer,
+    check_repr,
 )
 
-
 codecs = [
     PCodec(),
     PCodec(level=1),
@@ -58,8 +57,8 @@ def test_config():
 
 
 def test_invalid_config_error():
+    codec = PCodec(mode_spec='bogus')
     with pytest.raises(ValueError):
-        codec = PCodec(mode_spec='bogus')
         check_encode_decode_array_to_bytes(arrays[0], codec)
 
 

numcodecs/tests/test_pickles.py

@@ -6,14 +6,13 @@ import pytest
 
 from numcodecs.pickles import Pickle
 from numcodecs.tests.common import (
+    check_backwards_compatibility,
     check_config,
-    check_repr,
     check_encode_decode_array,
-    check_backwards_compatibility,
+    check_repr,
     greetings,
 )
 
-
 codecs = [Pickle(protocol=i) for i in range(5)]
 
 # object array with strings

numcodecs/tests/test_quantize.py

@@ -1,20 +1,17 @@
 import itertools
 
-
 import numpy as np
-from numpy.testing import assert_array_equal, assert_array_almost_equal
 import pytest
-
+from numpy.testing import assert_array_almost_equal, assert_array_equal
 
 from numcodecs.quantize import Quantize
 from numcodecs.tests.common import (
-    check_encode_decode,
+    check_backwards_compatibility,
     check_config,
+    check_encode_decode,
     check_repr,
-    check_backwards_compatibility,
 )
 
-
 arrays = [
     np.linspace(100, 200, 1000, dtype='<f8'),
     np.random.normal(loc=0, scale=1, size=1000).astype('<f8'),

numcodecs/tests/test_registry.py

@@ -1,7 +1,7 @@
-import pytest
-
 import inspect
 
+import pytest
+
 import numcodecs
 from numcodecs.registry import get_codec
 
@@ -26,15 +26,17 @@ def test_all_classes_registered():
 
     see #346 for more info
     """
-    missing = set()
-    for name, submod in inspect.getmembers(numcodecs, inspect.ismodule):
-        for name, obj in inspect.getmembers(submod):
-            if inspect.isclass(obj):
-                if issubclass(obj, numcodecs.abc.Codec):
-                    if obj.codec_id not in numcodecs.registry.codec_registry:
-                        missing.add(obj.codec_id)
-
-    # remove `None``
-    missing.remove(None)
+    missing = set(
+        obj.codec_id
+        for _, submod in inspect.getmembers(numcodecs, inspect.ismodule)
+        for _, obj in inspect.getmembers(submod)
+        if (
+            inspect.isclass(obj)
+            and issubclass(obj, numcodecs.abc.Codec)
+            and obj.codec_id not in numcodecs.registry.codec_registry
+            and obj.codec_id is not None  # remove `None`
+        )
+    )
+
     if missing:
         raise Exception(f"these codecs are missing: {missing}")  # pragma: no cover

numcodecs/tests/test_shuffle.py

@@ -1,11 +1,9 @@
 from multiprocessing import Pool
 from multiprocessing.pool import ThreadPool
 
-
 import numpy as np
 import pytest
 
-
 try:
     from numcodecs.shuffle import Shuffle
 except ImportError:  # pragma: no cover
@@ -13,12 +11,11 @@ except ImportError:  # pragma: no cover
 
 
 from numcodecs.tests.common import (
-    check_encode_decode,
-    check_config,
     check_backwards_compatibility,
+    check_config,
+    check_encode_decode,
 )
 
-
 codecs = [
     Shuffle(),
     Shuffle(elementsize=0),
@@ -92,7 +89,7 @@ def _decode_worker(enc):
     return data
 
 
-@pytest.mark.parametrize('pool', (Pool, ThreadPool))
+@pytest.mark.parametrize('pool', [Pool, ThreadPool])
 def test_multiprocessing(pool):
     data = np.arange(1000000)
     enc = _encode_worker(data)
@@ -165,7 +162,7 @@ def test_expected_result():
 
 
 def test_incompatible_elementsize():
+    arr = np.arange(1001, dtype='u1')
+    codec = Shuffle(elementsize=4)
     with pytest.raises(ValueError):
-        arr = np.arange(1001, dtype='u1')
-        codec = Shuffle(elementsize=4)
         codec.encode(arr)

numcodecs/tests/test_vlen_array.py

@@ -5,17 +5,16 @@ import pytest
 
 try:
     from numcodecs.vlen import VLenArray
-except ImportError:  # pragma: no cover
-    raise unittest.SkipTest("vlen-array not available")
+except ImportError as e:  # pragma: no cover
+    raise unittest.SkipTest("vlen-array not available") from e
 from numcodecs.tests.common import (
+    assert_array_items_equal,
+    check_backwards_compatibility,
     check_config,
-    check_repr,
     check_encode_decode_array,
-    check_backwards_compatibility,
-    assert_array_items_equal,
+    check_repr,
 )
 
-
 arrays = [
     np.array([np.array([1, 2, 3]), np.array([4]), np.array([5, 6])] * 300, dtype=object),
     np.array([np.array([1, 2, 3]), np.array([4]), np.array([5, 6])] * 300, dtype=object).reshape(

numcodecs/tests/test_vlen_bytes.py

@@ -5,18 +5,17 @@ import pytest
 
 try:
     from numcodecs.vlen import VLenBytes
-except ImportError:  # pragma: no cover
-    raise unittest.SkipTest("vlen-bytes not available")
+except ImportError as e:  # pragma: no cover
+    raise unittest.SkipTest("vlen-bytes not available") from e
 from numcodecs.tests.common import (
+    assert_array_items_equal,
+    check_backwards_compatibility,
     check_config,
-    check_repr,
     check_encode_decode_array,
-    check_backwards_compatibility,
+    check_repr,
     greetings,
-    assert_array_items_equal,
 )
 
-
 greetings_bytes = [g.encode('utf-8') for g in greetings]
 
 

numcodecs/tests/test_vlen_utf8.py

@@ -1,24 +1,21 @@
 import unittest
 
-
 import numpy as np
 import pytest
 
-
 try:
     from numcodecs.vlen import VLenUTF8
-except ImportError:  # pragma: no cover
-    raise unittest.SkipTest("vlen-utf8 not available")
+except ImportError as e:  # pragma: no cover
+    raise unittest.SkipTest("vlen-utf8 not available") from e
 from numcodecs.tests.common import (
+    assert_array_items_equal,
+    check_backwards_compatibility,
     check_config,
-    check_repr,
     check_encode_decode_array,
-    check_backwards_compatibility,
+    check_repr,
     greetings,
-    assert_array_items_equal,
 )
 
-
 arrays = [
     np.array(['foo', 'bar', 'baz'] * 300, dtype=object),
     np.array(greetings * 100, dtype=object),

numcodecs/tests/test_zarr3.py

@@ -0,0 +1,248 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+import pytest
+
+if not TYPE_CHECKING:
+    zarr = pytest.importorskip("zarr")
+else:
+    import zarr
+
+import zarr.storage
+from zarr.core.common import JSON
+
+import numcodecs.zarr3
+
+pytestmark = [
+    pytest.mark.skipif(zarr.__version__ < "3.0.0", reason="zarr 3.0.0 or later is required"),
+    pytest.mark.filterwarnings("ignore:Codec 'numcodecs.*' not configured in config.*:UserWarning"),
+    pytest.mark.filterwarnings(
+        "ignore:Numcodecs codecs are not in the Zarr version 3 specification and may not be supported by other zarr implementations."
+    ),
+]
+
+get_codec_class = zarr.registry.get_codec_class
+Array = zarr.Array
+BytesCodec = zarr.codecs.BytesCodec
+Store = zarr.abc.store.Store
+MemoryStore = zarr.storage.MemoryStore
+StorePath = zarr.storage.StorePath
+
+
+EXPECTED_WARNING_STR = "Numcodecs codecs are not in the Zarr version 3.*"
+
+
+@pytest.fixture
+def store() -> StorePath:
+    return StorePath(MemoryStore(mode="w"))
+
+
+ALL_CODECS = [getattr(numcodecs.zarr3, cls_name) for cls_name in numcodecs.zarr3.__all__]
+
+
+@pytest.mark.parametrize("codec_class", ALL_CODECS)
+def test_entry_points(codec_class: type[numcodecs.zarr3._NumcodecsCodec]):
+    codec_name = codec_class.codec_name
+    assert get_codec_class(codec_name) == codec_class
+
+
+@pytest.mark.parametrize("codec_class", ALL_CODECS)
+def test_docstring(codec_class: type[numcodecs.zarr3._NumcodecsCodec]):
+    if codec_class.__doc__ is None:
+        pytest.skip()
+    assert "See :class:`numcodecs." in codec_class.__doc__
+
+
+@pytest.mark.parametrize(
+    "codec_class",
+    [
+        numcodecs.zarr3.Blosc,
+        numcodecs.zarr3.LZ4,
+        numcodecs.zarr3.Zstd,
+        numcodecs.zarr3.Zlib,
+        numcodecs.zarr3.GZip,
+        numcodecs.zarr3.BZ2,
+        numcodecs.zarr3.LZMA,
+        numcodecs.zarr3.Shuffle,
+    ],
+)
+def test_generic_codec_class(store: StorePath, codec_class: type[numcodecs.zarr3._NumcodecsCodec]):
+    data = np.arange(0, 256, dtype="uint16").reshape((16, 16))
+
+    with pytest.warns(UserWarning, match=EXPECTED_WARNING_STR):
+        a = Array.create(
+            store / "generic",
+            shape=data.shape,
+            chunk_shape=(16, 16),
+            dtype=data.dtype,
+            fill_value=0,
+            codecs=[BytesCodec(), codec_class()],
+        )
+
+    a[:, :] = data.copy()
+    np.testing.assert_array_equal(data, a[:, :])
+
+
+@pytest.mark.parametrize(
+    ("codec_class", "codec_config"),
+    [
+        (numcodecs.zarr3.Delta, {"dtype": "float32"}),
+        (numcodecs.zarr3.FixedScaleOffset, {"offset": 0, "scale": 25.5}),
+        (numcodecs.zarr3.FixedScaleOffset, {"offset": 0, "scale": 51, "astype": "uint16"}),
+        (numcodecs.zarr3.AsType, {"encode_dtype": "float32", "decode_dtype": "float64"}),
+    ],
+    ids=[
+        "delta",
+        "fixedscaleoffset",
+        "fixedscaleoffset2",
+        "astype",
+    ],
+)
+def test_generic_filter(
+    store: StorePath,
+    codec_class: type[numcodecs.zarr3._NumcodecsCodec],
+    codec_config: dict[str, JSON],
+):
+    data = np.linspace(0, 10, 256, dtype="float32").reshape((16, 16))
+
+    with pytest.warns(UserWarning, match=EXPECTED_WARNING_STR):
+        a = Array.create(
+            store / "generic",
+            shape=data.shape,
+            chunk_shape=(16, 16),
+            dtype=data.dtype,
+            fill_value=0,
+            codecs=[
+                codec_class(**codec_config),
+                BytesCodec(),
+            ],
+        )
+
+        a[:, :] = data.copy()
+        a = Array.open(store / "generic")
+    np.testing.assert_array_equal(data, a[:, :])
+
+
+def test_generic_filter_bitround(store: StorePath):
+    data = np.linspace(0, 1, 256, dtype="float32").reshape((16, 16))
+
+    with pytest.warns(UserWarning, match=EXPECTED_WARNING_STR):
+        a = Array.create(
+            store / "generic_bitround",
+            shape=data.shape,
+            chunk_shape=(16, 16),
+            dtype=data.dtype,
+            fill_value=0,
+            codecs=[numcodecs.zarr3.BitRound(keepbits=3), BytesCodec()],
+        )
+
+        a[:, :] = data.copy()
+        a = Array.open(store / "generic_bitround")
+    assert np.allclose(data, a[:, :], atol=0.1)
+
+
+def test_generic_filter_quantize(store: StorePath):
+    data = np.linspace(0, 10, 256, dtype="float32").reshape((16, 16))
+
+    with pytest.warns(UserWarning, match=EXPECTED_WARNING_STR):
+        a = Array.create(
+            store / "generic_quantize",
+            shape=data.shape,
+            chunk_shape=(16, 16),
+            dtype=data.dtype,
+            fill_value=0,
+            codecs=[numcodecs.zarr3.Quantize(digits=3), BytesCodec()],
+        )
+
+        a[:, :] = data.copy()
+        a = Array.open(store / "generic_quantize")
+    assert np.allclose(data, a[:, :], atol=0.001)
+
+
+def test_generic_filter_packbits(store: StorePath):
+    data = np.zeros((16, 16), dtype="bool")
+    data[0:4, :] = True
+
+    with pytest.warns(UserWarning, match=EXPECTED_WARNING_STR):
+        a = Array.create(
+            store / "generic_packbits",
+            shape=data.shape,
+            chunk_shape=(16, 16),
+            dtype=data.dtype,
+            fill_value=0,
+            codecs=[numcodecs.zarr3.PackBits(), BytesCodec()],
+        )
+
+        a[:, :] = data.copy()
+        a = Array.open(store / "generic_packbits")
+    np.testing.assert_array_equal(data, a[:, :])
+
+    with pytest.raises(ValueError, match=".*requires bool dtype.*"):
+        Array.create(
+            store / "generic_packbits_err",
+            shape=data.shape,
+            chunk_shape=(16, 16),
+            dtype="uint32",
+            fill_value=0,
+            codecs=[numcodecs.zarr3.PackBits(), BytesCodec()],
+        )
+
+
+@pytest.mark.parametrize(
+    "codec_class",
+    [
+        numcodecs.zarr3.CRC32,
+        numcodecs.zarr3.CRC32C,
+        numcodecs.zarr3.Adler32,
+        numcodecs.zarr3.Fletcher32,
+        numcodecs.zarr3.JenkinsLookup3,
+    ],
+)
+def test_generic_checksum(store: StorePath, codec_class: type[numcodecs.zarr3._NumcodecsCodec]):
+    data = np.linspace(0, 10, 256, dtype="float32").reshape((16, 16))
+
+    with pytest.warns(UserWarning, match=EXPECTED_WARNING_STR):
+        a = Array.create(
+            store / "generic_checksum",
+            shape=data.shape,
+            chunk_shape=(16, 16),
+            dtype=data.dtype,
+            fill_value=0,
+            codecs=[BytesCodec(), codec_class()],
+        )
+
+        a[:, :] = data.copy()
+        a = Array.open(store / "generic_checksum")
+    np.testing.assert_array_equal(data, a[:, :])
+
+
+@pytest.mark.parametrize("codec_class", [numcodecs.zarr3.PCodec, numcodecs.zarr3.ZFPY])
+def test_generic_bytes_codec(store: StorePath, codec_class: type[numcodecs.zarr3._NumcodecsCodec]):
+    try:
+        codec_class()._codec  # noqa: B018
+    except ValueError as e:
+        if "codec not available" in str(e):
+            pytest.xfail(f"{codec_class.codec_name} is not available: {e}")
+        else:
+            raise  # pragma: no cover
+    except ImportError as e:
+        pytest.xfail(f"{codec_class.codec_name} is not available: {e}")
+
+    data = np.arange(0, 256, dtype="float32").reshape((16, 16))
+
+    with pytest.warns(UserWarning, match=EXPECTED_WARNING_STR):
+        a = Array.create(
+            store / "generic",
+            shape=data.shape,
+            chunk_shape=(16, 16),
+            dtype=data.dtype,
+            fill_value=0,
+            codecs=[
+                codec_class(),
+            ],
+        )
+
+    a[:, :] = data.copy()
+    np.testing.assert_array_equal(data, a[:, :])

numcodecs/tests/test_zarr3_import.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+import pytest
+
+
+def test_zarr3_import():
+    ERROR_MESSAGE_MATCH = "zarr 3.0.0 or later.*"
+
+    try:
+        import zarr  # noqa: F401
+    except ImportError:  # pragma: no cover
+        with pytest.raises(ImportError, match=ERROR_MESSAGE_MATCH):
+            import numcodecs.zarr3  # noqa: F401

numcodecs/tests/test_zfpy.py

@@ -1,8 +1,8 @@
-import pytest
-
+from types import ModuleType
+from typing import cast
 
 import numpy as np
-
+import pytest
 
 try:
     # noinspection PyProtectedMember
@@ -12,14 +12,16 @@ except ImportError:  # pragma: no cover
 
 
 from numcodecs.tests.common import (
-    check_encode_decode_array,
-    check_config,
-    check_repr,
     check_backwards_compatibility,
+    check_config,
+    check_encode_decode_array,
     check_err_decode_object_buffer,
     check_err_encode_object_buffer,
+    check_repr,
 )
 
+_zfpy = cast(ModuleType, _zfpy)
+
 
 codecs = [
     ZFPY(mode=_zfpy.mode_fixed_rate, rate=-1),

numcodecs/tests/test_zlib.py

@@ -1,20 +1,17 @@
 import itertools
 
-
 import numpy as np
 import pytest
 
-
-from numcodecs.zlib import Zlib
 from numcodecs.tests.common import (
-    check_encode_decode,
-    check_config,
-    check_repr,
     check_backwards_compatibility,
+    check_config,
+    check_encode_decode,
     check_err_decode_object_buffer,
     check_err_encode_object_buffer,
+    check_repr,
 )
-
+from numcodecs.zlib import Zlib
 
 codecs = [
     Zlib(),