opencodecs 0.7.0__tar.gz → 0.7.1__tar.gz

{opencodecs-0.7.0 → opencodecs-0.7.1}/CHANGES.rst

@@ -10,6 +10,85 @@ Versions follow the same ``YYYY.M.D`` cadence as upstream when we
 publish; the entries below cluster work by date rather than by
 release because most of it has shipped continuously to ``main``.
 
+0.7.1 (unreleased)
+------------------
+
+Every encoder is now tested against a decoder that is not ours.
+``tests/test_foreign_readers.py`` encodes with each of the 46 codecs that can
+encode and decodes with the format's own library where it has a Python
+binding (zstandard, lz4, brotli, python-blosc2, cramjam, lerc, zfpy, pcodec,
+qoi, pillow-heif, the standard library), imagecodecs, and format readers
+(tifffile, mrcfile, nibabel, pydicom, numcodecs, numpy); it also opens the
+files every writer produces (TIFF with each compression, pyramids, NDTiff,
+OME-Zarr, MRC, NIfTI, RGBE, JPEG XL animation, CZI pyramids). A codec that
+gains an encoder without a case fails the suite. CI installs these readers.
+It found:
+
+- Fix: the JPEG XL encoder refused ``level``, so ``TiffWriter`` and the NDTiff
+  writer raised for JPEG XL with ``compression_level``, which their
+  documentation promised to pass through. ``level`` now means what it means
+  in ``imagecodecs.jpegxl_encode``: 100 or below is lossy at that quality,
+  above 100 lossless. Passing both ``level`` and ``quality`` raises.
+- Fix: OME-Zarr stores written with ``compressor="blosc2"`` opened only in
+  opencodecs. No zarr specification defines Blosc2; the one numcodecs plugin
+  for it, ocf-blosc2 (Open Climate Fix), registers the id ``blosc2`` with
+  the parameters ``cname`` and ``clevel``, where the writer recorded
+  ``level``, which that plugin refuses. v2 stores now record ``cname`` and
+  ``clevel``, and v3 stores name the codec ``numcodecs.blosc2``, as zarr
+  names a numcodecs codec. With ocf-blosc2 installed, zarr opens both and
+  reads the pixels exactly. The chunks themselves are unchanged, and stores
+  written the old way still read here.
+- Fix: on Windows, which has no ``os.preadv``, the CZI reader maps the file,
+  and ``close()`` left the closed mapping in place: the next call raised the
+  mapping's ``ValueError: mmap closed or invalid`` instead of the reader's
+  own closed-reader ``CziError``. Two tests encoded the positional-read path
+  as universal (the payload index is kept on every path; a stored stack is
+  one copy out of the mapping on one worker there) and now assert each
+  path's own behavior.
+
+- Fix: a CZI this library wrote with default metadata could not be opened by
+  libCZI, so not by czicompress and not by ZEN. ``CziWriter``'s default
+  metadata was a bare ``<Metadata/>``, and libCZI requires the document to be
+  rooted at ``ImageDocument``; it refuses anything else outright with
+  ``Root-node "ImageDocument" not found``. Every round-trip test in this
+  suite passed because every one of them read the file back with our own
+  reader, which accepts it. Metadata lacking the root is now wrapped in one,
+  so a caller writing a new file cannot produce an unopenable one.
+  ``czi_recompress`` passes ``metadata_as_is=True``: it promises the source's
+  metadata is carried across unchanged, and rewriting it there would break
+  that promise, while silently "fixing" a source libCZI could not open either
+  is a surprise rather than a service. Its output is then exactly as openable
+  as its input.
+- ``tests/test_czi_foreign_readers.py`` never uses opencodecs to read. It
+  writes with opencodecs and opens with pylibCZIrw (libCZI itself, so what
+  ZEN and czicompress see), czifile (an independent implementation) and
+  aicspylibczi, skipping any reader that is absent rather than passing
+  silently. It covers all three compressions, a foreign decoder reading
+  pixels back exactly, both metadata regressions, a recompressed real file,
+  and 481 JPEG XR sub-blocks carried across. Its header records what to
+  assume when one fails: the writer is wrong, not the reader, because all
+  three open ZEN files and we are the new participant in a format we did not
+  define.
+- ``tests/_czi_fixture.py`` takes the same default. That serializer is an
+  independent reimplementation of the layout, and
+  ``test_file_bytes_match_the_fixture_serializer`` compares the writer's bytes
+  against it, so the two have to agree on the default; it is written as a
+  literal on both sides rather than imported, because importing would make
+  them agree by construction and hollow the test out. Fixture files are also
+  the sources for the ``czi_recompress`` tests, so that corpus now produces
+  files libCZI accepts.
+- Documented why the ZSTDHDR zstd level is 3 and not a parameter. Measured end
+  to end on a 503 MB uncompressed CZI, against ZEISS czicompress at 0.87 s and
+  319.9 MB on the same file: level 3 gives 0.24 s and 318.3 MB, level 6 gives
+  0.92 s and 315.3 MB, level 9 gives 1.38 s and 314.4 MB. The encode cost
+  transfers almost 1:1 into wall clock because this path is encode-bound
+  rather than I/O-bound, so 32 workers hide none of it, and level 6 is already
+  slower than the tool it replaces. About 1% of size for 4 to 6x the time is
+  not a trade worth a default. The hi-lo byte-plane shuffle is where the gain
+  actually is, and it is already on: on real microscopy pixels it takes the
+  ratio from 0.537 to 0.485 while being faster than raw zstd, 923 against
+  199 MB/s.
+
 0.7.0 (2026-10-03)
 ------------------
 

{opencodecs-0.7.0/src/opencodecs.egg-info → opencodecs-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencodecs
-Version: 0.7.0
+Version: 0.7.1
 Summary: Streaming, network-aware image codecs for scientific imaging (prototype: JPEG XL)
 Author: Kevin Cutler
 License-Expression: BSD-3-Clause
@@ -39,6 +39,18 @@ Requires-Dist: nd2; extra == "reference"
 Requires-Dist: readlif; extra == "reference"
 Requires-Dist: oiffile; extra == "reference"
 Requires-Dist: blosc2; extra == "reference"
+Requires-Dist: zstandard; extra == "reference"
+Requires-Dist: lz4; extra == "reference"
+Requires-Dist: brotli; extra == "reference"
+Requires-Dist: cramjam; extra == "reference"
+Requires-Dist: lerc; extra == "reference"
+Requires-Dist: zfpy; extra == "reference"
+Requires-Dist: pcodec; extra == "reference"
+Requires-Dist: ocf-blosc2; extra == "reference"
+Requires-Dist: qoi; extra == "reference"
+Requires-Dist: pillow-heif; extra == "reference"
+Requires-Dist: pylibCZIrw; extra == "reference"
+Requires-Dist: aicspylibczi; extra == "reference"
 Provides-Extra: test
 Requires-Dist: pytest>=8; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"

{opencodecs-0.7.0 → opencodecs-0.7.1}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "opencodecs"
-version = "0.7.0"
+version = "0.7.1"
 description = "Streaming, network-aware image codecs for scientific imaging (prototype: JPEG XL)"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -54,7 +54,21 @@ reference = [
     "nd2",            # ND2
     "readlif",        # LIF
     "oiffile",        # OIB
-    "blosc2",         # MRCZ
+    "blosc2",         # MRCZ, and Blosc2 / B2ND streams
+    # The libraries' own bindings, which test_foreign_readers.py decodes
+    # our streams with alongside imagecodecs.
+    "zstandard",      # zstd
+    "lz4",            # LZ4 frame
+    "brotli",         # Brotli
+    "cramjam",        # Snappy raw and framed
+    "lerc",           # LERC
+    "zfpy",           # ZFP
+    "pcodec",         # pcodec
+    "ocf-blosc2",     # Blosc2 in zarr (no zarr spec defines it)
+    "qoi",            # QOI
+    "pillow-heif",    # HEIF, libheif's decoder
+    "pylibCZIrw",     # CZI through libCZI
+    "aicspylibczi",   # CZI, the Allen Institute's libCZI binding
 ]
 test = [
     "pytest>=8",

{opencodecs-0.7.0 → opencodecs-0.7.1}/src/opencodecs/__init__.py

@@ -349,4 +349,4 @@ __all__ = [
     "czi_recompress", "subblock_dims",
 ]
 
-__version__ = "0.7.0"
+__version__ = "0.7.1"

{opencodecs-0.7.0 → opencodecs-0.7.1}/src/opencodecs/_czi_reader.py

@@ -813,6 +813,10 @@ class CziReader(Reader):
         finally:
             os.close(self._fd)
             self._owns_fd = False
+            # As on the positional-read path: a closed reader has no
+            # buffer, so the next call raises the reader's own "closed"
+            # error, not the mapping's "mmap closed or invalid".
+            self._mmap = None
 
     @classmethod
     def from_http(

{opencodecs-0.7.0 → opencodecs-0.7.1}/src/opencodecs/_czi_writer.py

@@ -70,6 +70,39 @@ _CMP_NAME_TO_CODE = {
 }
 
 
+#: libCZI refuses metadata that is not rooted at ``ImageDocument``, with
+#: ``Root-node "ImageDocument" not found``. That means czicompress and ZEN
+#: cannot open the file at all -- not a degraded read, no read. The writer's
+#: old default was a bare ``<Metadata/>``, which opencodecs' own reader
+#: accepts, so every round-trip test passed while the files were unreadable
+#: by every other CZI tool. Found 2026-10-04 when czicompress rejected a file
+#: this writer had just produced.
+#:
+#: So metadata lacking the root is WRAPPED in one, and a caller writing a NEW
+#: file cannot produce an unopenable one by accident or on purpose.
+#:
+#: ``metadata_as_is=True`` opts out, and exactly one caller needs it:
+#: ``czi_recompress``, which promises the source's metadata is carried across
+#: UNCHANGED. Rewriting it there would break that promise, and silently
+#: "fixing" a source that libCZI could not open either is a surprise, not a
+#: service -- the output is then exactly as openable as the input, which is
+#: what faithful means.
+_DEFAULT_METADATA = b"<ImageDocument><Metadata/></ImageDocument>"
+
+
+def _ensure_image_document(xml: bytes) -> bytes:
+    """Return ``xml`` rooted at ImageDocument, wrapping it if it is not."""
+    head = xml.lstrip()
+    decl = b""
+    if head.startswith(b"<?xml"):
+        end = head.find(b"?>")
+        if end != -1:
+            decl, head = head[:end + 2], head[end + 2:].lstrip()
+    if head.startswith(b"<ImageDocument>") or head.startswith(b"<ImageDocument "):
+        return xml
+    return decl + b"<ImageDocument>" + head + b"</ImageDocument>"
+
+
 class CziWriterError(RuntimeError):
     """Raised on writer state-machine violations."""
 
@@ -263,6 +296,27 @@ def _zstdhdr_encode(pixel_bytes, itemsize: int, hilo: bool, *, scratch=None):
     before this returns, and verification later reads the encoded payload
     and the caller's own pixel snapshot rather than this buffer, so the
     next frame may reuse it.
+
+    WHY LEVEL 3, AND WHY IT IS NOT A PARAMETER
+    Measured end to end through this pipeline on a 503 MB uncompressed CZI
+    (2026-10-04), against ZEISS czicompress at 0.87 s / 319.9 MB on the same
+    file:
+
+        level 3   0.24 s   318.3 MB     beats czicompress on size AND speed
+        level 6   0.92 s   315.3 MB     0.93% smaller, 3.91x slower
+        level 9   1.38 s   314.4 MB     1.23% smaller, 5.83x slower
+
+    The encode cost transfers almost 1:1 into wall clock, because this path is
+    encode-bound rather than I/O-bound: there is no I/O to hide it behind, even
+    with 32 workers. So a higher level buys about 1% of size for 4-6x the time,
+    and level 6 is already slower than the tool we replaced. Level 3 is the
+    only setting that wins on both axes.
+
+    The hi-lo shuffle, by contrast, is free and large: on real microscopy
+    pixels it took the ratio from 0.537 to 0.485 (9.7% smaller) while being
+    FASTER than raw zstd, 923 MB/s against 199 MB/s, because shuffled byte
+    planes are far more compressible. That is where the gain is, and it is
+    already on by default.
     """
     from .codecs._zstd import encode as zstd_encode
     if hilo and itemsize > 1:
@@ -519,15 +573,22 @@ class _CziStreamWriter(Writer):
     """Shared sub-block sink with optional bounded pixel verification."""
 
     def __init__(self, path: str | Path, *, compression: str = "none",
-                 hilo: bool = True, metadata_xml: bytes | str = b"<Metadata/>",
-                 verify: bool = False, background_encode: bool = False):
+                 hilo: bool = True, metadata_xml: bytes | str | None = None,
+                 verify: bool = False, background_encode: bool = False,
+                 metadata_as_is: bool = False):
         if compression not in _CMP_NAME_TO_CODE:
             raise CziWriterError(f"unknown compression {compression!r}")
         self._path = Path(path)
         self._cmp_code = _CMP_NAME_TO_CODE[compression]
         self._hilo = bool(hilo)
-        xml = metadata_xml.encode("utf-8") if isinstance(metadata_xml, str) else metadata_xml
-        self._metadata_segment = _build_metadata_segment(xml)
+        if metadata_xml is None:
+            xml = _DEFAULT_METADATA
+        elif isinstance(metadata_xml, str):
+            xml = metadata_xml.encode("utf-8")
+        else:
+            xml = metadata_xml
+        self._metadata_segment = _build_metadata_segment(
+            xml if metadata_as_is else _ensure_image_document(xml))
         self._header_size = (32 + 88 + 31) // 32 * 32
         self._position = self._header_size + len(self._metadata_segment)
         self._entries: list[dict] = []
@@ -1119,7 +1180,7 @@ def czi_recompress(src, dst, *, compression: str = "zstdhdr", hilo: bool = True,
         n = len(reader.entries)
         if not n:
             raise CziWriterError(f"czi: {src} has no sub-blocks to recompress")
-        metadata = reader.metadata_bytes or b"<Metadata/>"
+        metadata = reader.metadata_bytes or _DEFAULT_METADATA
 
         counts = {"recompressed": 0, "carried": 0}
 
@@ -1160,7 +1221,8 @@ def czi_recompress(src, dst, *, compression: str = "zstdhdr", hilo: bool = True,
         try:
             with CziWriter(str(dst), compression=compression, hilo=hilo,
                            metadata_xml=metadata, verify=verify,
-                           background_encode=background_encode) as writer:
+                           background_encode=background_encode,
+                           metadata_as_is=True) as writer:
                 writer.write_many(frames(), workers=workers, copy_frames=False)
         except BaseException:
             # An interrupted rewrite must not leave a file behind. A CZI

{opencodecs-0.7.0 → opencodecs-0.7.1}/src/opencodecs/_jxl_codec.py

@@ -139,6 +139,22 @@ class JpegXLReader(Reader):
         self._inner.close()
 
 
+def jxl_level_as_quality(opts: dict) -> dict:
+    """imagecodecs.jpegxl_encode's ``level`` is a quality: 100 or below is
+    lossy at that quality, above 100 lossless. The encoder's ``quality``
+    has exactly that meaning, so ``level`` is passed as ``quality``.
+    Writers that take one compression level for every codec (TIFF,
+    NDTiff) reach JPEG XL through this too."""
+    if opts.get("level") is None:
+        opts.pop("level", None)
+        return opts
+    if opts.get("quality") is not None:
+        raise TypeError("jxl: pass level or quality, not both")
+    opts = dict(opts)
+    opts["quality"] = opts.pop("level")
+    return opts
+
+
 class JpegXLCodec(Codec):
     """Native JPEG XL codec (libjxl 0.11).
 
@@ -176,7 +192,7 @@ class JpegXLCodec(Codec):
         return _jxl_check_signature(head)
 
     def encode(self, arr: np.ndarray, *, dest=None, **opts) -> bytes | None:
-        return _jxl_encode(arr, dest=dest, **opts)
+        return _jxl_encode(arr, dest=dest, **jxl_level_as_quality(opts))
 
     def decode(self, src: Any, **opts) -> np.ndarray:
         """Decode a JXL codestream.

{opencodecs-0.7.0 → opencodecs-0.7.1}/src/opencodecs/_omezarr.py

@@ -496,7 +496,10 @@ def _run_decoder(name: str, cfg: dict, data: bytes) -> bytes:
             _DECODER_CACHE["blosc2"] = fn
         if fn:
             return fn(data)
-    if name == "blosc2":
+    if name in ("blosc2", "numcodecs.blosc2"):
+        # "numcodecs.blosc2" is ocf-blosc2's v3 name, which our writer
+        # uses; plain "blosc2" is the v2 id, and what v3 stores this
+        # package wrote before 0.7.0 carry.
         fn = _DECODER_CACHE.get("blosc2")
         if not fn:
             from .codecs._blosc2 import decode as _b_decode

{opencodecs-0.7.0 → opencodecs-0.7.1}/src/opencodecs/_omezarr_writer.py

@@ -53,7 +53,10 @@ _CODEC_NAME_MAP = {
     "none":   (None, None),
     "raw":    (None, None),
     "zstd":   ("zstd", "zstd"),
-    "blosc2": ("blosc2", "blosc2"),     # blosc2 wire format (v2 + v3)
+    # No zarr specification defines Blosc2. These are the names ocf-blosc2,
+    # the one numcodecs plugin for it, registers: "blosc2" for v2, and
+    # "numcodecs.blosc2" for v3, which is how zarr names a numcodecs codec.
+    "blosc2": ("blosc2", "numcodecs.blosc2"),
     "gzip":   ("gzip", "gzip"),
     "blosc":  ("blosc", None),          # v2-only (no v3 spec)
 }
@@ -68,6 +71,16 @@ class OmeZarrWriterError(RuntimeError):
 # ---------------------------------------------------------------------------
 
 
+def _blosc2_config(level: int | None, v3: bool = False) -> dict:
+    """The parameters ocf-blosc2's Blosc2(cname, clevel) takes, so zarr with
+    that plugin installed opens the store. cname names the inner codec;
+    _encode_chunk compresses with zstd, blosc2's default, and ocf-blosc2
+    reads "zstd" as that. (Before 0.7.0 the writer recorded "level", which
+    no reader but opencodecs accepted; those stores still read here.)"""
+    config = {"cname": "zstd", "clevel": level if level is not None else 5}
+    return config if v3 else {"id": "blosc2", **config}
+
+
 def _encode_chunk(raw: bytes, codec: str, level: int | None) -> bytes:
     """Compress one chunk's bytes."""
     if codec in (None, "none", "raw"):
@@ -309,8 +322,7 @@ def _write_v2(
         metadata["compressor"] = {"id": "zstd",
                                   "level": level if level is not None else 3}
     elif compressor == "blosc2":
-        metadata["compressor"] = {"id": "blosc2",
-                                  "level": level if level is not None else 5}
+        metadata["compressor"] = _blosc2_config(level)
     elif compressor == "gzip":
         metadata["compressor"] = {"id": "gzip",
                                   "level": level if level is not None else 6}
@@ -375,8 +387,8 @@ def _write_v3(
         })
     elif compressor == "blosc2":
         codecs.append({
-            "name": "blosc2",
-            "configuration": {"clevel": level if level is not None else 5},
+            "name": "numcodecs.blosc2",
+            "configuration": _blosc2_config(level, v3=True),
         })
     elif compressor == "gzip":
         codecs.append({
@@ -460,8 +472,8 @@ def _v3_codecs_for_shard_inner(
         })
     elif compressor == "blosc2":
         codecs.append({
-            "name": "blosc2",
-            "configuration": {"clevel": level if level is not None else 5},
+            "name": "numcodecs.blosc2",
+            "configuration": _blosc2_config(level, v3=True),
         })
     elif compressor == "gzip":
         codecs.append({

{opencodecs-0.7.0 → opencodecs-0.7.1}/src/opencodecs/core/segment_compression.py

@@ -254,6 +254,9 @@ def encode_segment(data, codec: str | int, *, level: int | None = None,
         kw["level"] = level
     if code == JPEG2000:
         kw.setdefault("planar", False)
+    if code == JXL:
+        from .._jxl_codec import jxl_level_as_quality
+        kw = jxl_level_as_quality(kw)
     if code in (ZSTD, JPEG2000, JXL):
         from .pipeline import native_workers, in_worker
         # Zstandard counts background workers: zero means inline serial.
@@ -292,6 +295,9 @@ def bind_segment_encoder(codec: str | int, *, level=None, owned_output=False,
         options.setdefault("level", level)
     if code == JPEG2000:
         options.setdefault("planar", False)
+    if code == JXL:
+        from .._jxl_codec import jxl_level_as_quality
+        options = jxl_level_as_quality(options)
     eager = partial(fn, **options)
     if code not in (ZSTD, JPEG2000, JXL):
         return eager

{opencodecs-0.7.0 → opencodecs-0.7.1/src/opencodecs.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencodecs
-Version: 0.7.0
+Version: 0.7.1
 Summary: Streaming, network-aware image codecs for scientific imaging (prototype: JPEG XL)
 Author: Kevin Cutler
 License-Expression: BSD-3-Clause
@@ -39,6 +39,18 @@ Requires-Dist: nd2; extra == "reference"
 Requires-Dist: readlif; extra == "reference"
 Requires-Dist: oiffile; extra == "reference"
 Requires-Dist: blosc2; extra == "reference"
+Requires-Dist: zstandard; extra == "reference"
+Requires-Dist: lz4; extra == "reference"
+Requires-Dist: brotli; extra == "reference"
+Requires-Dist: cramjam; extra == "reference"
+Requires-Dist: lerc; extra == "reference"
+Requires-Dist: zfpy; extra == "reference"
+Requires-Dist: pcodec; extra == "reference"
+Requires-Dist: ocf-blosc2; extra == "reference"
+Requires-Dist: qoi; extra == "reference"
+Requires-Dist: pillow-heif; extra == "reference"
+Requires-Dist: pylibCZIrw; extra == "reference"
+Requires-Dist: aicspylibczi; extra == "reference"
 Provides-Extra: test
 Requires-Dist: pytest>=8; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"

{opencodecs-0.7.0 → opencodecs-0.7.1}/src/opencodecs.egg-info/SOURCES.txt

@@ -306,6 +306,7 @@ tests/test_coverage_push.py
 tests/test_czi_bounded_iteration.py
 tests/test_czi_direct_decode.py
 tests/test_czi_fixture.py
+tests/test_czi_foreign_readers.py
 tests/test_czi_mixed_subblocks.py
 tests/test_czi_parallel_write.py
 tests/test_czi_pread_indices.py
@@ -347,6 +348,7 @@ tests/test_filter_compat.py
 tests/test_filter_scratch.py
 tests/test_fits.py
 tests/test_fits_parallel.py
+tests/test_foreign_readers.py
 tests/test_gif.py
 tests/test_gif_compositing.py
 tests/test_gzip_presized.py

{opencodecs-0.7.0 → opencodecs-0.7.1}/src/opencodecs.egg-info/requires.txt

@@ -17,6 +17,18 @@ nd2
 readlif
 oiffile
 blosc2
+zstandard
+lz4
+brotli
+cramjam
+lerc
+zfpy
+pcodec
+ocf-blosc2
+qoi
+pillow-heif
+pylibCZIrw
+aicspylibczi
 
 [reference:python_version >= "3.11"]
 czifile>=2026.3.12

opencodecs-0.7.1/tests/test_czi_foreign_readers.py

@@ -0,0 +1,163 @@
+"""Every CZI opencodecs writes must open in the OTHER readers, not just ours.
+
+WHY THIS FILE EXISTS
+--------------------
+On 2026-10-04 czicompress refused a file this writer had just produced:
+
+    An unrecoverable runtime error occurred: Root-node "ImageDocument" not found.
+
+The writer's default metadata was a bare ``<Metadata/>``. opencodecs' own
+reader accepts that, so every round-trip test in the suite passed while the
+files were unopenable by libCZI, czicompress and ZEN -- which is to say, by
+everything a user would actually hand the file to. The bug was not in any
+code path; it was in the shape of the testing. A suite that only reads its
+own output cannot find it.
+
+So these tests never use opencodecs to read. They write with opencodecs and
+open with:
+
+    pylibCZIrw     the libCZI binding, i.e. what ZEN and czicompress use
+    czifile        Christoph Gohlke's independent pure-Python reader
+    aicspylibczi   the Allen Institute's libCZI binding
+
+Any reader that is not installed is skipped rather than silently passed over,
+so a thinned environment shows up as skips instead of false confidence.
+
+WHAT TO DO WHEN ONE OF THESE FAILS
+----------------------------------
+Assume the writer is wrong, not the reader. All three of these open files from
+ZEN; we are the new participant in a format we did not define. A disagreement
+between our reader and theirs means our reader is probably lenient in the same
+way the writer is wrong, which is exactly how the metadata bug survived.
+"""
+from __future__ import annotations
+
+import pathlib
+import sys
+
+import numpy as np
+import pytest
+
+sys.path.insert(0, str(pathlib.Path(__file__).parent))
+
+from opencodecs import CziWriter, czi_recompress  # noqa: E402
+
+CORPUS = pathlib.Path(__file__).resolve().parents[1] / ".test_data" / "czi"
+
+
+def _write(path, *, n=3, side=64, compression="none", **kw):
+    """A small multi-channel CZI, written by opencodecs."""
+    rs = np.random.RandomState(5)
+    with CziWriter(str(path), compression=compression, **kw) as w:
+        for c in range(n):
+            w.write_frame(rs.randint(0, 4096, (side, side)).astype("uint16"),
+                          dims=[("X", 0, side, side), ("Y", 0, side, side),
+                                ("C", c, 1, 1)])
+    return path
+
+
+# --------------------------------------------------------------- pylibCZIrw
+# The one that matters most: it is libCZI, so it is what ZEN and czicompress
+# see. A file this reader rejects is a file our users cannot open.
+
+@pytest.mark.parametrize("compression", ["none", "zstd", "zstdhdr"])
+def test_pylibczirw_opens_what_we_write(tmp_path, compression):
+    czirw = pytest.importorskip("pylibCZIrw.czi", reason="pylibCZIrw missing")
+    src = _write(tmp_path / f"{compression}.czi", compression=compression)
+    with czirw.open_czi(str(src)) as r:
+        plane = r.read(plane={"C": 0})
+        assert plane is not None and plane.size > 0
+        assert r.total_bounding_rectangle[2:] == (64, 64)
+
+
+def test_pylibczirw_reads_our_pixels_back_exactly(tmp_path):
+    """Lossless must mean lossless to a FOREIGN decoder, not only to ours."""
+    czirw = pytest.importorskip("pylibCZIrw.czi", reason="pylibCZIrw missing")
+    rs = np.random.RandomState(9)
+    frame = rs.randint(0, 4096, (64, 64)).astype("uint16")
+    out = tmp_path / "exact.czi"
+    with CziWriter(str(out), compression="zstdhdr") as w:
+        w.write_frame(frame, dims=[("X", 0, 64, 64), ("Y", 0, 64, 64),
+                                   ("C", 0, 1, 1)])
+    with czirw.open_czi(str(out)) as r:
+        got = np.squeeze(r.read(plane={"C": 0}))
+    assert np.array_equal(got, frame), "a foreign reader sees different pixels"
+
+
+def test_default_metadata_is_openable_by_libczi(tmp_path):
+    """The exact bug this file was created for.
+
+    The old default produced files libCZI refused outright. Asserting through
+    our own reader could never have caught it.
+    """
+    czirw = pytest.importorskip("pylibCZIrw.czi", reason="pylibCZIrw missing")
+    src = _write(tmp_path / "default_meta.czi")      # no metadata_xml passed
+    with czirw.open_czi(str(src)) as r:
+        assert r.total_bounding_rectangle is not None
+
+
+def test_rootless_metadata_still_opens_because_it_is_wrapped(tmp_path):
+    """Handing in the old broken value must not produce an unopenable file."""
+    czirw = pytest.importorskip("pylibCZIrw.czi", reason="pylibCZIrw missing")
+    src = _write(tmp_path / "rootless.czi", metadata_xml=b"<Metadata/>")
+    with czirw.open_czi(str(src)) as r:
+        assert r.total_bounding_rectangle is not None
+
+
+# ------------------------------------------------------------------ czifile
+# An independent implementation, not libCZI. It disagrees with libCZI in
+# places, which is the point of having both.
+
+def test_czifile_opens_what_we_write(tmp_path):
+    czifile = pytest.importorskip("czifile", reason="czifile missing")
+    src = _write(tmp_path / "cf.czi", compression="zstdhdr")
+    with czifile.CziFile(str(src)) as c:
+        # czifile exposes the directory and asarray(), not a .shape attribute.
+        assert len(c.filtered_subblock_directory) == 3, "sub-blocks not seen"
+        data = c.asarray()
+        assert data.size > 0 and data.dtype == np.uint16
+
+
+# ------------------------------------------------------------- aicspylibczi
+
+def test_aicspylibczi_opens_what_we_write(tmp_path):
+    aics = pytest.importorskip("aicspylibczi", reason="aicspylibczi missing")
+    src = _write(tmp_path / "aics.czi", compression="zstdhdr")
+    czi = aics.CziFile(str(src))
+    assert czi.get_dims_shape() is not None
+    img, _shape = czi.read_image(C=0)
+    assert img.size > 0
+
+
+# ------------------------------------------- recompressed real files
+# czi_recompress output is what the ingest pipeline actually produces, so it
+# is the output that most needs to open elsewhere.
+
+@pytest.mark.skipif(not (CORPUS / "idr0011_plate1_scene1.czi").is_file(),
+                    reason="corpus CZI not present")
+def test_recompressed_real_file_opens_in_libczi(tmp_path):
+    czirw = pytest.importorskip("pylibCZIrw.czi", reason="pylibCZIrw missing")
+    dst = tmp_path / "re.czi"
+    czi_recompress(CORPUS / "idr0011_plate1_scene1.czi", dst,
+                   compression="zstdhdr")
+    with czirw.open_czi(str(dst)) as r:
+        assert r.total_bounding_rectangle is not None
+
+
+@pytest.mark.skipif(not (CORPUS / "ome_axioscan_pyramid.czi").is_file(),
+                    reason="corpus slide scan not present")
+def test_carried_jpegxr_file_opens_in_libczi(tmp_path):
+    """Carrying lossy sub-blocks across must leave a file libCZI still reads.
+
+    This is the strongest interop case available: 481 JPEG XR sub-blocks
+    copied verbatim into a container our writer built. If the container is
+    wrong, libCZI will say so even though the payloads are untouched.
+    """
+    czirw = pytest.importorskip("pylibCZIrw.czi", reason="pylibCZIrw missing")
+    dst = tmp_path / "carried.czi"
+    info = czi_recompress(CORPUS / "ome_axioscan_pyramid.czi", dst,
+                          compression="zstdhdr",
+                          recompress_when=lambda e: e.compression == 0)
+    assert info["carried"] == info["subblocks"]
+    with czirw.open_czi(str(dst)) as r:
+        assert r.total_bounding_rectangle is not None

{opencodecs-0.7.0 → opencodecs-0.7.1}/tests/test_czi_pread_indices.py

@@ -73,7 +73,9 @@ def test_payload_buffers_are_reused(path):
 def test_payload_location_is_cached(path):
     with _open(path) as r:
         r.read()
-        assert len(r._payload_ranges) == (len(r) if _czi_reader._PAYLOAD_PREAD else 0)
+        # Every source type computes and keeps its payload ranges, the
+        # mapping (no positional reads, e.g. Windows) as well.
+        assert len(r._payload_ranges) == len(r)
 
 
 def test_concurrent_tile_reads_on_one_reader(path, frames):

{opencodecs-0.7.0 → opencodecs-0.7.1}/tests/test_czi_read_dispatch.py

@@ -231,4 +231,10 @@ def test_stored_stack_reads_on_more_than_one_worker(monkeypatch, tmp_path, n):
     assert np.array_equal(out, np.stack(tiles, axis=0))
     n_tasks, workers = seen[-1]
     assert n_tasks == n
-    assert workers >= 2
+    if cz._PAYLOAD_PREAD:
+        # Positional reads overlap their I/O across workers.
+        assert workers >= 2
+    else:
+        # Without positional reads (Windows) a stored stack is a copy out
+        # of the mapping, which did not scale across workers when measured.
+        assert workers == 1