opencodecs 0.1.3__tar.gz → 0.1.6__tar.gz

opencodecs-0.1.6/3rdparty/cfitsio/pliocomp.c

@@ -0,0 +1,331 @@
+/* stdlib is needed for the abs function */
+#include <stdlib.h>
+/*
+   The following prototype code was provided by Doug Tody, NRAO, for
+   performing conversion between pixel arrays and line lists.  The
+   compression technique is used in IRAF.
+*/
+int pl_p2li (int *pxsrc, int xs, short *lldst, int npix);
+int pl_l2pi (short *ll_src, int xs, int *px_dst, int npix);
+
+
+/*
+ * PL_P2L -- Convert a pixel array to a line list.  The length of the list is
+ * returned as the function value.
+ *
+ * Translated from the SPP version using xc -f, f2c.  8Sep99 DCT.
+ */
+
+#ifndef min
+#define min(a,b)        (((a)<(b))?(a):(b))
+#endif
+#ifndef max
+#define max(a,b)        (((a)>(b))?(a):(b))
+#endif
+
+int pl_p2li (int *pxsrc, int xs, short *lldst, int npix)
+/* int *pxsrc;                      input pixel array */
+/* int xs;                          starting index in pxsrc (?) */
+/* short *lldst;                    encoded line list */
+/* int npix;                        number of pixels to convert */
+{
+    /* System generated locals */
+    int ret_val, i__1, i__2, i__3;
+
+    /* Local variables */
+    int zero, v, x1, hi, ip, dv, xe, np, op, iz, nv = 0, pv, nz;
+
+    /* Parameter adjustments */
+    --lldst;
+    --pxsrc;
+
+    /* Function Body */
+    if (! (npix <= 0)) {
+        goto L110;
+    }
+    ret_val = 0;
+    goto L100;
+L110:
+    lldst[3] = -100;
+    lldst[2] = 7;
+    lldst[1] = 0;
+    lldst[6] = 0;
+    lldst[7] = 0;
+    xe = xs + npix - 1;
+    op = 8;
+    zero = 0;
+/* Computing MAX */
+    i__1 = zero, i__2 = pxsrc[xs];
+    pv = max(i__1,i__2);
+    x1 = xs;
+    iz = xs;
+    hi = 1;
+    i__1 = xe;
+    for (ip = xs; ip <= i__1; ++ip) {
+        if (! (ip < xe)) {
+            goto L130;
+        }
+/* Computing MAX */
+        i__2 = zero, i__3 = pxsrc[ip + 1];
+        nv = max(i__2,i__3);
+        if (! (nv == pv)) {
+            goto L140;
+        }
+        goto L120;
+L140:
+        if (! (pv == 0)) {
+            goto L150;
+        }
+        pv = nv;
+        x1 = ip + 1;
+        goto L120;
+L150:
+        goto L131;
+L130:
+        if (! (pv == 0)) {
+            goto L160;
+        }
+        x1 = xe + 1;
+L160:
+L131:
+        np = ip - x1 + 1;
+        nz = x1 - iz;
+        if (! (pv > 0)) {
+            goto L170;
+        }
+        dv = pv - hi;
+        if (! (dv != 0)) {
+            goto L180;
+        }
+        hi = pv;
+        if (! (abs(dv) > 4095)) {
+            goto L190;
+        }
+        lldst[op] = (short) ((pv & 4095) + 4096);
+        ++op;
+        lldst[op] = (short) (pv / 4096);
+        ++op;
+        goto L191;
+L190:
+        if (! (dv < 0)) {
+            goto L200;
+        }
+        lldst[op] = (short) (-dv + 12288);
+        goto L201;
+L200:
+        lldst[op] = (short) (dv + 8192);
+L201:
+        ++op;
+        if (! (np == 1 && nz == 0)) {
+            goto L210;
+        }
+        v = lldst[op - 1];
+        lldst[op - 1] = (short) (v | 16384);
+        goto L91;
+L210:
+L191:
+L180:
+L170:
+        if (! (nz > 0)) {
+            goto L220;
+        }
+L230:
+        if (! (nz > 0)) {
+            goto L232;
+        }
+        lldst[op] = (short) min(4095,nz);
+        ++op;
+/* L231: */
+        nz += -4095;
+        goto L230;
+L232:
+        if (! (np == 1 && pv > 0)) {
+            goto L240;
+        }
+        lldst[op - 1] = (short) (lldst[op - 1] + 20481);
+        goto L91;
+L240:
+L220:
+L250:
+        if (! (np > 0)) {
+            goto L252;
+        }
+        lldst[op] = (short) (min(4095,np) + 16384);
+        ++op;
+/* L251: */
+        np += -4095;
+        goto L250;
+L252:
+L91:
+        x1 = ip + 1;
+        iz = x1;
+        pv = nv;
+L120:
+        ;
+    }
+/* L121: */
+    lldst[4] = (short) ((op - 1) % 32768);
+    lldst[5] = (short) ((op - 1) / 32768);
+    ret_val = op - 1;
+    goto L100;
+L100:
+    return ret_val;
+} /* plp2li_ */
+
+/*
+ * PL_L2PI -- Translate a PLIO line list into an integer pixel array.
+ * The number of pixels output (always npix) is returned as the function
+ * value.
+ *
+ * Translated from the SPP version using xc -f, f2c.  8Sep99 DCT.
+ */
+
+int pl_l2pi (short *ll_src, int xs, int *px_dst, int npix)
+/* short *ll_src;                   encoded line list */
+/* int xs;                          starting index in ll_src */
+/* int *px_dst;                    output pixel array */
+/* int npix;                       number of pixels to convert */
+{
+    /* System generated locals */
+    int ret_val, i__1, i__2;
+
+    /* Local variables */
+    int data, sw0001, otop, i__, lllen, i1, i2, x1, x2, ip, xe, np,
+             op, pv, opcode, llfirt;
+    int skipwd;
+
+    /* Parameter adjustments */
+    --px_dst;
+    --ll_src;
+
+    /* Function Body */
+    if (! (ll_src[3] > 0)) {
+        goto L110;
+    }
+    lllen = ll_src[3];
+    llfirt = 4;
+    goto L111;
+L110:
+    lllen = (ll_src[5] << 15) + ll_src[4];
+    llfirt = ll_src[2] + 1;
+L111:
+    if (! (npix <= 0 || lllen <= 0)) {
+        goto L120;
+    }
+    ret_val = 0;
+    goto L100;
+L120:
+    xe = xs + npix - 1;
+    skipwd = 0;
+    op = 1;
+    x1 = 1;
+    pv = 1;
+    i__1 = lllen;
+    for (ip = llfirt; ip <= i__1; ++ip) {
+        if (! skipwd) {
+            goto L140;
+        }
+        skipwd = 0;
+        goto L130;
+L140:
+        opcode = ll_src[ip] / 4096;
+        data = ll_src[ip] & 4095;
+        sw0001 = opcode;
+        goto L150;
+L160:
+        x2 = x1 + data - 1;
+        i1 = max(x1,xs);
+        i2 = min(x2,xe);
+        np = i2 - i1 + 1;
+        if (! (np > 0)) {
+            goto L170;
+        }
+        otop = op + np - 1;
+        if (! (opcode == 4)) {
+            goto L180;
+        }
+        i__2 = otop;
+        for (i__ = op; i__ <= i__2; ++i__) {
+            px_dst[i__] = pv;
+/* L190: */
+        }
+/* L191: */
+        goto L181;
+L180:
+        i__2 = otop;
+        for (i__ = op; i__ <= i__2; ++i__) {
+            px_dst[i__] = 0;
+/* L200: */
+        }
+/* L201: */
+        if (! (opcode == 5 && i2 == x2)) {
+            goto L210;
+        }
+        px_dst[otop] = pv;
+L210:
+L181:
+        op = otop + 1;
+L170:
+        x1 = x2 + 1;
+        goto L151;
+L220:
+        pv = (ll_src[ip + 1] << 12) + data;
+        skipwd = 1;
+        goto L151;
+L230:
+        pv += data;
+        goto L151;
+L240:
+        pv -= data;
+        goto L151;
+L250:
+        pv += data;
+        goto L91;
+L260:
+        pv -= data;
+L91:
+        if (! (x1 >= xs && x1 <= xe)) {
+            goto L270;
+        }
+        px_dst[op] = pv;
+        ++op;
+L270:
+        ++x1;
+        goto L151;
+L150:
+        ++sw0001;
+        if (sw0001 < 1 || sw0001 > 8) {
+            goto L151;
+        }
+        switch ((int)sw0001) {
+            case 1:  goto L160;
+            case 2:  goto L220;
+            case 3:  goto L230;
+            case 4:  goto L240;
+            case 5:  goto L160;
+            case 6:  goto L160;
+            case 7:  goto L250;
+            case 8:  goto L260;
+        }
+L151:
+        if (! (x1 > xe)) {
+            goto L280;
+        }
+        goto L131;
+L280:
+L130:
+        ;
+    }
+L131:
+    i__1 = npix;
+    for (i__ = op; i__ <= i__1; ++i__) {
+        px_dst[i__] = 0;
+/* L290: */
+    }
+/* L291: */
+    ret_val = npix;
+    goto L100;
+L100:
+    return ret_val;
+} /* pll2pi_ */
+

{opencodecs-0.1.3 → opencodecs-0.1.6}/CHANGES.rst

@@ -10,6 +10,228 @@ 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.1.6 (2026-06-01)
+------------------
+
+**libultrahdr now bundled (fixes missing ``_uhdr`` on PyPI wheels)**
+
+* ``bench/build_codec_libs.sh::build_libultrahdr`` builds libuhdr
+  v1.4.0 (Apache-2.0) into ``$OPENCODECS_LIBS_PREFIX/{include,lib}``
+  alongside the other source-built codec libs. The Linux + Windows
+  CI ``--only=...`` lists pick it up; the macOS ``before-all`` brew
+  install now includes ``libultrahdr`` as well.
+* setup.py's ``_uhdr`` Extension is now built by a probe
+  (``_maybe_build_uhdr_ext``) that finds the cached prefix, sets
+  ``library_dirs``, and bakes the rpath into the resulting ``.so``
+  so delocate / auditwheel / delvewheel can bundle ``libuhdr``'s
+  dylib/.so/.dll into the wheel.
+* ``_uhdr`` is now in ``MUST_SHIP_ALL_PLATFORMS`` in
+  ``ci/check_wheel_contents.py``; a wheel without the Ultra-HDR
+  extension fails the wheel-coverage step.
+* The stale ``_ultrahdr.pyx`` source file (orphaned in commit
+  ``c9347f5`` when the direct libuhdr binding shipped as ``_uhdr``)
+  is removed.
+
+**New API: ``opencodecs.uhdr.decode_native``**
+
+Fused-Cython fast-path Ultra-HDR decoder. Uses libuhdr's parser to
+pull out the compressed SDR base + gain-map JPEGs + metadata (no
+pixel decode), then decodes both JPEGs in parallel via
+``imagecodecs.jpeg_decode`` (libjpeg-turbo SIMD, GIL released) and
+applies the gain map in a Cython kernel that uses the same sRGB
+EOTF LUT + IEEE-754 polynomial ``exp2`` the encoder uses. ~1.4×
+faster than libuhdr's reference decode on a 2k² float HDR (M-series
+Mac: ~52 ms vs ~72 ms). Output matches libuhdr's decode to within
+JPEG-q95 + 8-bit gain-quantisation noise. ``display_boost`` kwarg
+exposes the ISO 21496-1 headroom scaler — default is full HDR
+(``hdr_capacity_max``), pass ``1.0`` to match libuhdr's default
+SDR-equivalent decode.
+
+Backed by two new Cython helpers exposed for advanced callers:
+
+* ``opencodecs.codecs._uhdr.extract_layers(data)`` — parse the
+  container, return ``{base_jpeg, gainmap_jpeg, gainmap_metadata,
+  width, height, gainmap_{width,height}}`` without decoding pixels.
+* ``opencodecs.codecs._uhdr.apply_gainmap_fp32(sdr_u8, gain_u8,
+  metadata, display_boost=...)`` — the per-pixel gain-application
+  kernel.
+
+**New API: ``opencodecs.uhdr.encode_to``**
+
+Streaming variant of :func:`encode_native` — writes Ultra-HDR bytes
+directly to a file-like (anything with ``write(bytes)``: open file,
+``io.BytesIO``, HTTP upload streamer). Returns the byte count.
+Forward-compatible alias: the libuhdr api-4 path we currently use
+for container assembly doesn't expose a streaming writer, so the
+function is ``fp.write(encode_native(...))`` today; the API exists
+so callers can adopt it now and pick up any future libuhdr
+streaming write-out without changing their code.
+
+**CI / build robustness**
+
+* ``_uhdr`` extension now links ``-lmvec -lm`` on Linux. GCC at
+  ``-O3 -ffast-math`` auto-vectorises the sRGB LUT-init ``pow()``
+  calls into ``_ZGV*`` symbols from glibc's libmvec. AlmaLinux 8's
+  manylinux toolchain auto-links libmvec so the issue was masked
+  in CI, but Ubuntu's GCC doesn't — caught when verifying on a
+  threadripper Ubuntu 25.04 box.
+* The libaec source URL moved from ``gitlab.dkrz.de`` (now
+  auth-gated; anonymous requests redirect to ``/users/sign_in``)
+  to DKRZ's GitHub mirror at
+  ``github.com/Deutsches-Klimarechenzentrum/libaec``.
+* ``fetch_tar`` now has a 4-attempt shell retry loop with empty-
+  extract detection — covers transient mirror outages that
+  curl's own ``--retry`` doesn't see (e.g. 200 OK with a
+  truncated body).
+
+0.1.5 (2026-05-31)
+------------------
+
+**New codecs**
+
+* ``opencodecs.uhdr`` — Ultra-HDR / ISO 21496-1 (gainmap JPEG) via a
+  direct Cython binding to Google's libultrahdr. ``encode(hdr, ...)``
+  wraps libuhdr's full pipeline; ``encode_native(hdr, sdr=None, ...)``
+  is a fused-Cython fast path that computes SDR base + gain map in
+  ``nogil`` kernels (IEEE-754 polynomial log2/pow, cross-platform —
+  no Apple Accelerate intrinsics), JPEG-encodes both layers in
+  parallel via a 3-worker ThreadPoolExecutor, then hands the
+  pre-encoded JPEGs to libuhdr's api-4 for container assembly.
+  Measured 31 ms median for a 2000² float HDR on M-series Mac vs
+  ~173 ms for the libuhdr reference path — 5.5× faster. The
+  ``sdr=`` argument lets callers (notably tilescan pipelines) supply
+  their own SDR base instead of accepting the peak-normalised default.
+
+* ``PLIO_1`` — IRAF run-length mask coding closes the last FITS
+  tile-compression gap. Vendors cfitsio's ``pliocomp.c`` (Doug Tody /
+  NRAO, public-domain) and adds the tiny
+  ``opencodecs.codecs._plio.decode_raw`` shim. Round-trip tested
+  against astropy. The ``COMPRESSED_DATA`` BINTABLE column walker
+  now tracks per-column element byte width so the ``1PI`` (int16
+  opcodes) layout PLIO uses works alongside the ``1PB`` byte VLA the
+  other compressors use.
+
+**New API**
+
+* ``EerReader.sum(start, stop, *, weights=None, dtype=...)`` —
+  per-frame dose curve. ``weights[k]`` multiplies the k-th frame in
+  the requested range; output promotes to float64 when weights are
+  given so fractional contributions don't truncate. Use case:
+  beam-induced-motion correction and temporal-binning schemes that
+  emphasise different exposures across the acquisition.
+
+**Bug fixes**
+
+* HEIF encode against libheif ≥ 1.18 — newer libheif calls
+  ``strlen()`` on the user write-callback's ``heif_error.message``
+  even on success and rejects a ``NULL`` pointer with *"heif_writer
+  callback returned a null error text"*. The callback now hands back
+  a static empty string on success and a descriptive string on OOM.
+  Six tests (``test_heif_*``, ``test_phase5_icc.py[heif]``) go back
+  to green across every CI matrix entry.
+
+**CI / build**
+
+* ``bench/build_codec_libs.sh`` — the ``is_built`` cache-marker now
+  records the install dir alongside the version and re-verifies the
+  install dir exists before short-circuiting a recipe. Without this,
+  cibuildwheel's manylinux cache (which only covers ``/cibw-jxl-prefix``)
+  preserved the marker for recipes that install to
+  ``~/.cache/opencodecs/<lib>/`` outside the cached prefix —
+  ``lerc``, ``mozjpeg``, ``brotli``, ``zstd``, ``giflib`` — so the
+  recipe thought it was done while the actual library files were
+  gone. ``_lerc`` + ``_mozjpeg`` had been silently dropped from
+  Linux wheels for this reason; the fix restores them.
+
+* ``test_omezarr.py`` skips at module level on zarr-python < 3 —
+  fixtures use the v3 API surface, which doesn't exist on the v2
+  branch pip resolves on Python 3.10.
+
+* ``test_eer_imagecodecs_cross_validate`` is now symmetric on
+  decoder error: if either implementation raises, both must raise
+  for the combo to count. Tolerates imagecodecs ≥ 2026.5's tighter
+  output-buffer sizing.
+
+0.1.4 (2026-05-25)
+------------------
+
+**libvips-inspired streaming improvements**
+
+* ``HTTPDataSource(access='sequential', sequential_chunk_bytes=4*1024*1024)``
+  — opt-in libvips-style sequential read mode. Replaces the LRU +
+  adaptive read-ahead with a single rolling buffer that slides forward
+  as the caller reads. Memory stays bounded to one chunk regardless of
+  file size. Target workload: tile-by-tile raster scan over a huge
+  COG / OME-TIFF served over HTTP. Backward seeks still work but
+  invalidate the buffer; ``stats['sequential_backward_seeks']`` tracks
+  the count so users can spot a workload that's actually random and
+  would benefit from ``access='random'``.
+
+* ``TiffPyramidReader.read_region`` now parallelises tile decode
+  across a thread pool (default ``min(cpu_count(), 8)``). The
+  compressed-tile decoders (JPEG, JPEG-2000, deflate, zstd, LZW, WebP,
+  LERC) all release the GIL in their C path, so threads scale across
+  cores on CPython. Kicks in only when the region covers 4+ tiles —
+  fewer than that and thread-pool spin-up cost dominates. Pass
+  ``num_decode_workers=1`` to force the serial path for benchmarks /
+  regression-diff.
+
+* ``TiffWriter.write_pyramid_auto`` gained ``stream_levels=True``
+  (default for COG layout). Computes and writes one level at a time
+  via a new ``iter_pyramid_levels`` generator, dropping each finished
+  level before computing the next. Peak memory drops from
+  ``~1.33 × level0`` (entire geometric series materialised) to
+  ``~2 × current_level``. Useful when level 0 already dominates RAM
+  (whole-slide pathology, cryo-EM tomograms). Output file is
+  byte-identical to the materialize-all path. SubIFD layout
+  (``subifds=True``) still uses the materialize path because that
+  layout writes sub-resolution IFD offsets into the main IFD's tag
+  330 — sub-level offsets have to be known up front.
+
+  Validated via tests:
+  ``test_http_sequential_serves_from_rolling_buffer``,
+  ``test_http_sequential_backward_seek_counted``,
+  ``test_pyramid_reader_parallel_decode_matches_serial``,
+  ``test_pyramid_auto_stream_matches_materialize``,
+  ``test_iter_pyramid_levels_matches_make_pyramid_levels``.
+
+**MozJPEG ships on every wheel**
+
+* Added MozJPEG (Mozilla's libjpeg-turbo fork) to the cibuildwheel
+  codec-lib build set on Linux, macOS, and Windows. MozJPEG produces
+  JPEG files ~10-15% smaller than baseline libjpeg-turbo at the same
+  quality setting (progressive encoding + trellis quantization +
+  better quantization tables). The ``_mozjpeg`` extension has shipped
+  on macOS wheels for a while via brew; v0.1.4 brings it to
+  Linux + Windows so the codec is available everywhere.
+* New ``build_mozjpeg`` recipe in ``bench/build_codec_libs.sh``
+  installs into a keg-style ``mozjpeg/`` subdir under the prefix
+  (rather than the shared ``$PREFIX/{include,lib}``) to avoid the
+  libturbojpeg / libjpeg name collision with the libjpeg-turbo 3.x
+  install. setup.py's mozjpeg probe was extended to recognise the
+  new candidate paths on Linux (``~/.cache/opencodecs/mozjpeg``),
+  Windows (``$CONDA_PREFIX/Library/mozjpeg``), and the Windows
+  fallback (no ``nm``: trust the keg-style directory name).
+* Locally validated on win-vm (MSVC 14.44 — same as CI) and
+  kevin-tower (Linux x86_64): ``bash bench/build_codec_libs.sh
+  --only=mozjpeg`` followed by ``setup.py build_ext --inplace``
+  produces ``_mozjpeg.{pyd,so}`` cleanly. Per the new lesson in
+  CLAUDE.md, this iteration was validated end-to-end through the
+  same script CI runs, with the same env vars, before any push.
+
+**Post-publish wheel coverage check (CI hardening)**
+
+* New ``ci/check_wheel_contents.py`` runs in the wheel-build job
+  immediately after ``cibuildwheel`` produces each wheel. It unzips
+  the wheel, walks ``opencodecs/codecs/``, and asserts every codec
+  in the ``MUST_SHIP_ALL_PLATFORMS`` set has a ``.pyd``/``.so``
+  present. Missing codec → matrix job fails → publish step gated.
+* Catches the v0.1.2-style "changelog overclaim" silent-drop class
+  of bugs at build time instead of after publish. v0.1.2's Windows
+  wheels shipped without ``_sperr``/``_brunsli`` despite the
+  changelog claim; this check would have failed that build.
+
+
 0.1.3 (2026-05-22)
 ------------------
 

{opencodecs-0.1.3/src/opencodecs.egg-info → opencodecs-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencodecs
-Version: 0.1.3
+Version: 0.1.6
 Summary: Streaming, network-aware image codecs for scientific imaging (prototype: JPEG XL)
 Author: Kevin Cutler
 License: BSD-3-Clause

{opencodecs-0.1.3 → opencodecs-0.1.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "opencodecs"
-version = "0.1.3"
+version = "0.1.6"
 description = "Streaming, network-aware image codecs for scientific imaging (prototype: JPEG XL)"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -142,7 +142,7 @@ before-all = [
     # bench/build_codec_libs.sh into the cached /cibw-jxl-prefix mount.
     # Skips encoders (aom, x265) — wheel ships decode-only AVIF/HEIF to
     # keep build < 12 min cold + avoid GPL x265.
-    "bash -c 'PATH=$HOME/.cargo/bin:$PATH bash bench/build_codec_libs.sh --only=libjpeg-turbo,c-blosc2,libde265,dav1d,libavif,libheif,libaec,lerc,zfp,SZ3,pcodec,SPERR,brunsli'",
+    "bash -c 'PATH=$HOME/.cargo/bin:$PATH bash bench/build_codec_libs.sh --only=libjpeg-turbo,c-blosc2,libde265,dav1d,libavif,libheif,libaec,lerc,zfp,SZ3,pcodec,SPERR,brunsli,mozjpeg,libultrahdr'",
     "bash bench/build_libjxl.sh",
 ]
 # Don't set OPENCODECS_*_PREFIX here — build_wheels.yml's
@@ -159,8 +159,11 @@ before-all = [
 # cache by bench/build_codec_libs.sh. brunsli vendors brotli as a
 # submodule so the brew brotli isn't required at link time.
 before-all = [
-    "brew install jpeg-xl libavif libheif webp libpng jpeg-turbo openjpeg zstd brotli c-blosc2 lz4 libdeflate libaec liblerc zfp rust cmake ninja",
-    "bash bench/build_codec_libs.sh --only=SZ3,pcodec,SPERR,brunsli",
+    # mozjpeg removed from this brew install — the formula ships libjpeg
+    # only, not libturbojpeg, so the _mozjpeg probe couldn't find what it
+    # needed. Source-build via build_codec_libs.sh produces both libs.
+    "brew install jpeg-xl libavif libheif webp libpng jpeg-turbo openjpeg zstd brotli c-blosc2 lz4 libdeflate libaec liblerc zfp rust cmake ninja libultrahdr",
+    "bash bench/build_codec_libs.sh --only=SZ3,pcodec,SPERR,brunsli,mozjpeg",
 ]
 # macos-latest is now macOS 15 (Sequoia) on arm64. Homebrew formulas are
 # compiled for 15.x, so any wheel target lower than 15 fails the delocate