rigour 2.1.2__tar.gz → 2.2.0__tar.gz

{rigour-2.1.2 → rigour-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rigour
-Version: 2.1.2
+Version: 2.2.0
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
 Classifier: License :: OSI Approved :: MIT License

{rigour-2.1.2 → rigour-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "rigour"
-version = "2.1.2"
+version = "2.2.0"
 description = "Financial crime domain data validation and normalization library."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -60,7 +60,9 @@ docs = [
 ]
 
 [tool.maturin]
-features = ["pyo3/extension-module", "python"]
+# pyo3/generate-import-lib lets the Windows wheel job link without a
+# real Python install (PyO3 generates a stub import library).
+features = ["pyo3/extension-module", "pyo3/generate-import-lib", "python"]
 module-name = "rigour._core"
 manifest-path = "rust/Cargo.toml"
 # `rigour/` is the Python package directory, sitting at the repo root. Maturin

rigour-2.2.0/rigour/names/name.py

@@ -0,0 +1,24 @@
+"""Name — the top-level object in the `rigour.names` object graph.
+
+Rust-backed via `rigour._core`. Python-side surface:
+
+* `Name(original, form=None, tag=NameTypeTag.UNK, phonetics=True)` —
+  `form` defaults to `casefold(original)` and is tokenised; each
+  token becomes a fresh `NamePart`.
+* eager attributes: `original`, `form`, `tag` (mutable), `parts`,
+  `spans`, `comparable`, `norm_form`
+* dynamic property: `symbols` (recomputed each access from `spans`)
+* mutation: `tag_text(text, tag, max_matches=1)`,
+  `apply_phrase(phrase, symbol)`, `apply_part(part, symbol)`
+* `contains(other)` for PER-aware subset checks
+* `Name.consolidate_names(names)` classmethod — drops names that are
+  substrings of longer names in the same iterable
+* `__hash__` / `__eq__` by `form` (stable across tag mutation)
+
+`parts` is a tuple built once at construction — attribute reads are
+zero-copy INCREFs. `spans` starts empty and grows via `apply_phrase`
+/ `apply_part`.
+"""
+from rigour._core import Name
+
+__all__ = ["Name"]

{rigour-2.1.2 → rigour-2.2.0}/rigour/names/org_types.py

@@ -88,27 +88,36 @@ def replace_org_types_display(
     """Replace organisation types in a name with their short display form.
 
     Spelt-out legal forms are shortened into common abbreviations
-    (e.g. ``"Siemens Aktiengesellschaft"`` → ``"Siemens AG"``), preserving
-    the case of non-matched portions. If the whole input is uppercase
-    (`str.isupper()`), the whole output is re-uppercased.
-
-    Matches case-insensitively across Unicode by casefolding a copy of
-    the input internally for the match step — `normalize_flags` must
-    therefore include `Normalize.CASEFOLD` so the alias table is
-    casefolded too. The default does this.
+    (e.g. ``"Siemens Aktiengesellschaft"`` → ``"Siemens AG"``), and
+    case-variant forms are canonicalised (``"Siemens GMBH"`` →
+    ``"Siemens GmbH"``). Everything outside a matched span is returned
+    verbatim — case, spacing and stray characters untouched. If the
+    whole input is uppercase (`str.isupper()`), the whole output is
+    re-uppercased, so ``"ACME COMPANY LIMITED"`` becomes
+    ``"ACME COMPANY LTD"`` rather than the odd-looking
+    ``"ACME COMPANY Ltd"``.
+
+    Matching is Unicode-case- and whitespace-insensitive: the input is
+    normalised internally with the same `normalize_flags` as the alias
+    table (which must therefore include `Normalize.CASEFOLD`; the
+    default does), and matches are mapped back to the original text.
+    Legal forms broken by copy/paste residue — soft hyphens, zero-width
+    characters, doubled spaces — are still recognised, and the
+    replacement swallows the residue.
 
     Args:
         name: The text to be processed.
         normalize_flags: `Normalize` flag
-            set applied to the alias list at build time. Must include
-            `Normalize.CASEFOLD` for Unicode-case-insensitive matching.
+            set applied to the alias list at build time and mirrored on
+            the input at match time. Must include `Normalize.CASEFOLD`
+            for Unicode-case-insensitive matching.
             Default `CASEFOLD | SQUASH_SPACES`.
         cleanup: `Cleanup` variant applied
             during alias normalisation. Default `Cleanup.Noop`.
 
     Returns:
         The text with recognised organisation types substituted for
-        their display form. Non-matched regions keep their original case.
+        their display form and all non-matched regions verbatim.
     """
     return _replace_org_types_display(name, int(normalize_flags), int(cleanup))
 

rigour-2.2.0/rigour/names/part.py

@@ -0,0 +1,23 @@
+"""NamePart / Span — the leaf classes of the `rigour.names` object graph.
+
+Rust-backed via `rigour._core`. Python-side surface:
+
+* `NamePart(form, index, tag=NamePartTag.UNSET, phonetics=True)` —
+  `index` is the part's position within its name and is required.
+* eager attributes: `form`, `index`, `tag` (mutable), `latinize`,
+  `numeric`, `ascii`, `integer`, `comparable`, `metaphone`
+* `NamePart.tag_sort(parts)` classmethod — stable-sort parts into
+  human display order by tag (honorifics, given, middle, family, …)
+* tag compatibility checks live on the tag: `part.tag.can_match(other.tag)`
+* `__hash__` / `__eq__` by the precomputed `_hash` (tuple of
+  `(index, form)`)
+* `Span(parts, symbol)` with precomputed `comparable`
+
+`phonetics=False` at construction skips the metaphone computation —
+`part.metaphone` is `None` in that case. `ascii` uses
+`rigour._core.maybe_ascii` (narrow 6-script transliteration); parts
+whose form is outside the admitted scripts resolve `ascii` to `None`.
+"""
+from rigour._core import NamePart, Span
+
+__all__ = ["NamePart", "Span"]

{rigour-2.1.2 → rigour-2.2.0}/rigour/names/pick.py

@@ -1,5 +1,6 @@
 from typing import Dict, List, Optional
 
+from rigour._core import pick_case as _pick_case
 from rigour._core import pick_name as pick_name
 from rigour._core import reduce_names as reduce_names
 from rigour.langs import LangStr, PREFERRED_LANG, PREFERRED_LANGS
@@ -152,8 +153,6 @@ def pick_case(names: List[str]) -> str:
     Returns:
         str: The best name for display.
     """
-    from rigour._core import pick_case as _pick_case
-
     result = _pick_case(names)
     if result is None:
         raise ValueError("Cannot pick a name from an empty list.")

{rigour-2.1.2 → rigour-2.2.0}/rigour/reset.py

@@ -5,7 +5,7 @@ from rigour.text.phonetics import soundex, metaphone
 from rigour.territories.territory import get_index
 from rigour.territories.lookup import lookup_territory
 from rigour.territories.lookup import _get_identifier_map, _get_territory_names
-from rigour.text.scripts import can_latinize_cp
+from rigour.text.scripts import codepoint_script
 from rigour.names.tokenize import normalize_name
 from rigour.names.prefix import (
     _person_prefix_regex,
@@ -29,7 +29,7 @@ def reset_caches() -> None:
     jaro_winkler.cache_clear()
     soundex.cache_clear()
     metaphone.cache_clear()
-    can_latinize_cp.cache_clear()
+    codepoint_script.cache_clear()
     _load_formats.cache_clear()
     _load_template.cache_clear()
     _address_replacer.cache_clear()

{rigour-2.1.2 → rigour-2.2.0}/rigour/territories/util.py

@@ -2,7 +2,7 @@ import unicodedata
 from typing import List
 from normality import latinize_text, squash_spaces
 
-from rigour.text.scripts import can_latinize_cp
+from rigour.text.scripts import can_latinize
 
 SKIP_CHARACTERS = ".()[],;:_-/ʻ'’"
 
@@ -20,7 +20,6 @@ def clean_codes(codes: List[str]) -> List[str]:
 def normalize_territory_name(name: str) -> str:
     """Normalize a territory name for lookup."""
     name = unicodedata.normalize("NFKD", name).casefold()
-    can_latinize = True
     filtered: List[str] = []
     for char in name:
         if char in SKIP_CHARACTERS:
@@ -28,12 +27,9 @@ def normalize_territory_name(name: str) -> str:
         if not char.isalnum():
             filtered.append(" ")
             continue
-        cp = ord(char)
-        if not can_latinize_cp(cp):
-            can_latinize = False
         filtered.append(char)
     normalized = "".join(filtered)
-    if can_latinize:
+    if can_latinize(normalized):
         normalized = latinize_text(normalized)
     normalized = unicodedata.normalize("NFKC", normalized)
     normalized = squash_spaces(normalized)

{rigour-2.1.2 → rigour-2.2.0}/rigour/text/normalize.py

@@ -41,7 +41,8 @@ value:
                               listed in its dispatch (NFKD)
     3. CASEFOLD             — Unicode full casefold (ß → ss, not lowercase)
     4. Cleanup              — category_replace, unless Cleanup.Noop
-    5. SQUASH_SPACES        — collapse whitespace runs, trim ends
+    5. SQUASH_SPACES        — delete invisible format characters,
+                              collapse whitespace runs, trim ends
     6. NAME                 — tokenize via
                               [tokenize_name][rigour.names.tokenize.tokenize_name]
                               and rejoin with a single ASCII space
@@ -132,10 +133,14 @@ class Normalize(IntFlag):
     Attributes:
         STRIP: Trim leading and trailing whitespace.
         SQUASH_SPACES: Collapse runs of whitespace (including newlines,
-            tabs, Unicode whitespace) into single spaces and trim the
-            edges. Runs as the final pipeline step, so cleaning up
-            whitespace introduced by earlier steps (e.g. category
-            replacement) comes out right.
+            tabs, Unicode whitespace, and the U+001C-001F information
+            separators) into single spaces and trim the edges. Also
+            deletes invisible format characters — zero-width
+            space/joiners (U+200B-U+200D), BOM (U+FEFF), soft hyphen
+            (U+00AD), and word joiners (U+2060-U+2064) — so that text
+            pasted from PDFs or web pages (``Gm\\u00ADbH``) compares
+            equal to its clean form (``GmbH``). Cleans up whitespace
+            introduced by earlier steps (e.g. category replacement).
         CASEFOLD: Unicode full casefold (e.g. ``ß → ss``). This is
             *not* the same as `str.lower()` — casefold is the correct
             tool for case-insensitive comparison across Unicode.

{rigour-2.1.2 → rigour-2.2.0}/rigour/text/scripts.py

@@ -3,15 +3,11 @@ from typing import Optional
 
 from rigour._core import codepoint_script as _codepoint_script
 from rigour._core import common_scripts as _common_scripts
+from rigour._core import should_ascii as _should_ascii
 from rigour._core import text_scripts as _text_scripts
 from rigour.util import MEMO_MEDIUM
 
 
-#: Scripts whose romanisation is well-defined enough that
-#: rigour will automatically transliterate them to ASCII via
-#: :func:`rigour.text.translit.maybe_ascii`.
-LATINIZE_SCRIPTS = {"Hangul", "Cyrillic", "Greek", "Armenian", "Latin", "Georgian"}
-
 #: Letter-based writing systems with explicit vowels — these
 #: transliterate reliably to Latin without language hints.
 #: Excludes Hangul (syllabic) and the dense logographic scripts.
@@ -99,38 +95,14 @@ def common_scripts(a: str, b: str) -> set[str]:
     return _common_scripts(a, b)
 
 
-@lru_cache(maxsize=MEMO_MEDIUM)
-def can_latinize_cp(cp: int) -> Optional[bool]:
-    """Check whether a single codepoint can be latinized.
-
-    Three-valued: distinguishing-script-bearing codepoints get a
-    True/False; others (digits, punctuation, combining marks)
-    return `None` because the question doesn't apply to them.
-
-    Args:
-        cp: Codepoint as an integer.
-
-    Returns:
-        `True` if the codepoint's script is in
-        :data:`LATINIZE_SCRIPTS`, `False` if it has a real script
-        outside that set, `None` for non-alphanumeric or
-        Common/Inherited/Unknown codepoints.
-    """
-    char = chr(cp)
-    if not char.isalnum():
-        return None
-    script = codepoint_script(cp)
-    if script is None or script in ("Common", "Inherited"):
-        return None
-    return script in LATINIZE_SCRIPTS
-
-
 def can_latinize(word: str) -> bool:
     """Check whether every script in a word is latinizable.
 
-    Equivalent to `text_scripts(word) <= LATINIZE_SCRIPTS`. When
-    True, :func:`rigour.text.translit.maybe_ascii` will produce
-    an ASCII output; when False, it returns the input unchanged.
+    Alias for `should_ascii` in [rigour.text.translit][] — the two
+    call the same Rust predicate, which admits Latin, Cyrillic,
+    Greek, Armenian, Georgian, and Hangul. When True, `maybe_ascii`
+    will produce an ASCII output; when False, it returns the input
+    unchanged.
     Characters with no distinguishing script (digits, punctuation,
     spaces, combining marks) are ignored. Empty input and
     pure-Common input (`"123"`) return True vacuously.
@@ -139,10 +111,10 @@ def can_latinize(word: str) -> bool:
         word: A string.
 
     Returns:
-        True iff every distinguishing script is in
-        :data:`LATINIZE_SCRIPTS`.
+        True iff every distinguishing script is admitted for
+        transliteration.
     """
-    return text_scripts(word) <= LATINIZE_SCRIPTS
+    return _should_ascii(word)
 
 
 def is_modern_alphabet(word: str) -> bool:

{rigour-2.1.2 → rigour-2.2.0}/rigour/text/translit.py

@@ -1,10 +1,10 @@
 """Opportunistic transliteration: `should_ascii` + `maybe_ascii`.
 
 The minimal transliteration surface rigour exposes going forward.
-Covers only the scripts listed in `rigour.text.scripts.LATINIZE_SCRIPTS`
-(Latin, Cyrillic, Greek, Armenian, Georgian, Hangul). Anything
-outside that set passes through unchanged (default) or becomes
-empty (``drop=True``).
+Covers only six admitted scripts (Latin, Cyrillic, Greek, Armenian,
+Georgian, Hangul); the admission policy is defined in the Rust core.
+Anything outside that set passes through unchanged (default) or
+becomes empty (``drop=True``).
 
 For broader-script, lossy transliteration (Han, Arabic, Devanagari,
 etc.) use `normality.ascii_text` / `normality.latinize_text` —

{rigour-2.1.2 → rigour-2.2.0}/rust/Cargo.lock

@@ -25,9 +25,9 @@ checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
 [[package]]
 name = "bitflags"
-version = "2.12.1"
+version = "2.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84d7ced0ae9557296835c32bf1b1e02b44c746701f898460fb000d7eaa84f00a"
+checksum = "b588b76d00fde79687d7646a9b5bdf3cc0f655e0bbd080335a95d7e96f3587da"
 
 [[package]]
 name = "calendrical_calculations"
@@ -623,9 +623,9 @@ checksum = "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092"
 
 [[package]]
 name = "lru"
-version = "0.18.0"
+version = "0.18.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a860605968fce16869fd239cf4237a82f3ac470723415db603b0e8b6c8d4fb9"
+checksum = "0b6180140927ee907000b0aa540091f6ea512ead4447c92b8fc35bc72788a5a6"
 dependencies = [
  "hashbrown",
 ]
@@ -724,9 +724,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.28.3"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91fd8e38a3b50ed1167fb981cd6fd60147e091784c427b8f7183a7ee32c31c12"
+checksum = "cd274650b21d4bfc26a0a47587962c1edb425f69287324355cd040c3ea66071c"
 dependencies = [
  "libc",
  "once_cell",
@@ -738,19 +738,18 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.28.3"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e368e7ddfdeb98c9bca7f8383be1648fd84ab466bf2bc015e94008db6d35611e"
+checksum = "c5e2a7d2f0d013342f295c048ad19237add5154a55b1c5a254c0ec93d4109078"
 dependencies = [
- "python3-dll-a",
  "target-lexicon",
 ]
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.28.3"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f29e10af80b1f7ccaf7f69eace800a03ecd13e883acfacc1e5d0988605f651e"
+checksum = "ca85c467da1bbc8d866eea5deff9cf29ea5f7785054a17da36e65bda9c05845b"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -758,9 +757,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.28.3"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df6e520eff47c45997d2fc7dd8214b25dd1310918bbb2642156ef66a67f29813"
+checksum = "9ac53762fd065daa3194dd09337a38bd793a188100fd1a9304c4ab312d901771"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -770,26 +769,16 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.28.3"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4cdc218d835738f81c2338f822078af45b4afdf8b2e33cbb5916f108b813acb"
+checksum = "4ca3a1557399783172dc5bf39cfca835157732532cba56b71d2292161e53b362"
 dependencies = [
  "heck",
  "proc-macro2",
- "pyo3-build-config",
  "quote",
  "syn",
 ]
 
-[[package]]
-name = "python3-dll-a"
-version = "0.2.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d80ba7540edb18890d444c5aa8e1f1f99b1bdf26fb26ae383135325f4a36042b"
-dependencies = [
- "cc",
-]
-
 [[package]]
 name = "quote"
 version = "1.0.45"
@@ -813,9 +802,9 @@ checksum = "270e04e5ea61d40841942bb15e451c29ee1618637bcf97fc7ede5dd4a9b1601b"
 
 [[package]]
 name = "regex"
-version = "1.12.3"
+version = "1.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276"
+checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -825,9 +814,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.4.14"
+version = "0.4.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
+checksum = "8fcfdb36bda0c880c5931cdc7a2bcdc8ba4556847b9d912bca70bc94708711ad"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -836,13 +825,13 @@ dependencies = [
 
 [[package]]
 name = "regex-syntax"
-version = "0.8.10"
+version = "0.8.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
+checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
 
 [[package]]
 name = "rigour-core"
-version = "2.1.2"
+version = "2.2.0"
 dependencies = [
  "aho-corasick",
  "bitflags",

{rigour-2.1.2 → rigour-2.2.0}/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rigour-core"
-version = "2.1.2"
+version = "2.2.0"
 edition = "2024"
 rust-version = "1.86"
 license = "MIT"
@@ -17,9 +17,11 @@ crate-type = ["cdylib", "rlib"]
 python = ["dep:pyo3"]
 
 [dependencies]
-# generate-import-lib avoids needing a real Python install on the Windows CI
-# runner at link time — PyO3 generates a stub import library instead.
-pyo3 = { version = "0.28", features = ["extension-module", "generate-import-lib"], optional = true }
+# Wheel-only pyo3 features (extension-module, generate-import-lib) are
+# deliberately NOT set here — they live in `[tool.maturin].features` in
+# pyproject.toml. Keeping them out of the crate lets `cargo test
+# --features python` link a standalone test binary against libpython.
+pyo3 = { version = "0.29", optional = true }
 
 # Phonetic algorithms (metaphone, soundex). Port of Apache commons-codec, pure
 # Rust. The upstream jellyfish Rust crate can't be used directly because it
@@ -43,7 +45,7 @@ bitflags = "2"
 # `rigour.text.distance` and `rigour.territories.lookup` consume.
 rapidfuzz = "0.5"
 
-# LRU caches. Currently used for `maybe_ascii`'s per-thread result
+# LRU caches. Currently used for `maybe_ascii`'s process-wide result
 # cache. Tiny crate (~500 LoC, no deps), O(1) get/put.
 lru = "0.18"
 

{rigour-2.1.2 → rigour-2.2.0}/rust/build.rs

@@ -9,10 +9,10 @@
 //   - `data/names/org_types.json`          (~125 KiB → ~15 KiB)
 //   - `data/territories/data.jsonl`        (~783 KiB → ~214 KiB)
 //
-// If a source file is missing (fresh checkout before
-// `contrib/namesdb/Makefile::dump` has been run, for example), we emit
-// an empty blob and print a cargo warning. Callers of the corresponding
-// `raw()` loader see an empty string.
+// All source files are committed, so a missing one means a broken
+// checkout — fail the build rather than embed an empty blob that
+// would ship as a silently non-functional wheel (empty tagger, zero
+// territories).
 
 use std::env;
 use std::fs;
@@ -21,36 +21,32 @@ use std::path::PathBuf;
 struct Compress {
     src: &'static str,     // path under rust/
     dst: &'static str,     // filename under OUT_DIR
-    missing: &'static str, // cargo warning if source file is absent
+    missing: &'static str, // error detail if source file is absent
 }
 
 const FILES: &[Compress] = &[
     Compress {
         src: "data/names/person_names.txt",
         dst: "person_names.txt.zst",
-        missing: "rust/data/names/person_names.txt not found — \
-                  compiling empty person-names corpus. Run \
+        missing: "rust/data/names/person_names.txt not found. Run \
                   `make -C contrib/namesdb dump` to regenerate.",
     },
     Compress {
         src: "data/territories/data.jsonl",
         dst: "territories.jsonl.zst",
-        missing: "rust/data/territories/data.jsonl not found — \
-                  compiling empty territories blob. Run \
+        missing: "rust/data/territories/data.jsonl not found. Run \
                   `make build-territories` to regenerate.",
     },
     Compress {
         src: "data/names/symbols.json",
         dst: "symbols.json.zst",
-        missing: "rust/data/names/symbols.json not found — \
-                  compiling empty symbols blob. Run \
+        missing: "rust/data/names/symbols.json not found. Run \
                   `make build-names` to regenerate.",
     },
     Compress {
         src: "data/names/org_types.json",
         dst: "org_types.json.zst",
-        missing: "rust/data/names/org_types.json not found — \
-                  compiling empty org-types blob. Run \
+        missing: "rust/data/names/org_types.json not found. Run \
                   `make build-names` to regenerate.",
     },
 ];
@@ -64,11 +60,7 @@ fn main() {
         let dest_path = out_dir.join(entry.dst);
         println!("cargo:rerun-if-changed={}", entry.src);
 
-        let Ok(bytes) = fs::read(&source_path) else {
-            println!("cargo:warning={}", entry.missing);
-            fs::write(&dest_path, [] as [u8; 0]).expect("write empty placeholder");
-            continue;
-        };
+        let bytes = fs::read(&source_path).unwrap_or_else(|_| panic!("{}", entry.missing));
 
         // Level 19 is the high-ratio tier — slow compression, but this
         // runs at build time only and gives the best wheel size.