rigour 2.1.2__tar.gz → 2.2.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rigour
-Version: 2.1.2
+Version: 2.2.2
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
 Classifier: License :: OSI Approved :: MIT License
@@ -12,6 +12,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Rust
 Requires-Dist: pyyaml>=5.0.0,<7.0.0
 Requires-Dist: normality>=3.0.1,<4.0.0
+Requires-Dist: prefixdate>=0.5.0,<1.0.0
 Requires-Dist: orjson>=3.0.0,<4.0.0
 Requires-Dist: python-stdnum>=2.0,<3.0.0
 Requires-Dist: jinja2>=3.1.0,<4.0.0

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

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "rigour"
-version = "2.1.2"
+version = "2.2.2"
 description = "Financial crime domain data validation and normalization library."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -24,6 +24,7 @@ requires-python = ">= 3.10"
 dependencies = [
     "pyyaml >= 5.0.0, < 7.0.0",
     "normality >= 3.0.1, < 4.0.0",
+    "prefixdate >= 0.5.0, < 1.0.0",
     "orjson >= 3.0.0, < 4.0.0",
     "python-stdnum >= 2.0, < 3.0.0",
     "jinja2 >= 3.1.0, < 4.0.0",
@@ -60,7 +61,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.2/rigour/dates.py

@@ -0,0 +1,203 @@
+"""Compare prefix dates without pretending they are exact instants.
+
+A prefix date such as ``2026`` or ``2026-06`` represents an interval, rather
+than the first instant of that year or month. Use the string wrappers for
+one-off comparisons, or parse a [DateInterval][rigour.dates.DateInterval] once
+when comparing the same value repeatedly.
+
+Age and recency checks use the same comparisons with a shifted reference:
+
+```python
+cutoff = now - max_age
+is_recent = not ended_before(value, cutoff)
+```
+"""
+
+import re
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from functools import lru_cache
+
+from prefixdate import Precision, parse
+
+from rigour.util import MEMO_SMALL
+
+_TIMEZONE_SUFFIX_RE = re.compile(r"(?:Z|[+-]\d{2}(?::?\d{2})?)$")
+_SECOND_TIMESTAMP_RE = re.compile(
+    r"^[12]\d{3}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}"
+    r"(?:Z|[+-]\d{2}(?::?\d{2})?)?$"
+)
+
+
+@dataclass(frozen=True)
+class DateInterval:
+    """Represent every possible instant described by an imprecise date.
+
+    Use this parsed form when applying multiple comparisons to the same prefix
+    date. Both bounds are timezone-aware UTC datetimes and ``end`` is exclusive.
+
+    Attributes:
+        start: Earliest instant represented by the date.
+        end: First instant after the represented interval.
+    """
+
+    start: datetime
+    end: datetime
+
+
+def _ensure_utc(value: datetime) -> datetime:
+    """Adapt legacy naive-UTC values to aware UTC datetimes."""
+    if value.tzinfo is None or value.utcoffset() is None:
+        return value.replace(tzinfo=timezone.utc)
+    return value.astimezone(timezone.utc)
+
+
+def parse_utc(value: str) -> datetime:
+    """Parse an exact timestamp as an aware UTC datetime.
+
+    Use this at a prefix-date boundary where an exact timestamp may carry an
+    offset. Naive timestamps use the ecosystem convention of implicit UTC.
+
+    Args:
+        value: Canonical second-precision timestamp.
+
+    Returns:
+        The represented instant as a timezone-aware UTC datetime.
+
+    Raises:
+        ValueError: The timestamp is invalid or is not precise to the second.
+    """
+    if _SECOND_TIMESTAMP_RE.fullmatch(value) is None:
+        raise ValueError(f"Invalid exact timestamp: {value!r}")
+    try:
+        timestamp = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError as exc:
+        raise ValueError(f"Invalid timestamp: {value!r}") from exc
+    return _ensure_utc(timestamp)
+
+
+@lru_cache(maxsize=MEMO_SMALL)
+def prefix_interval(value: str) -> DateInterval:
+    """Expand a canonical prefix date into its represented UTC interval.
+
+    Use this at the boundary between prefix-date strings and interval comparison.
+    Feed it normalized property values only, not uncleaned source strings. Exact
+    timestamps with offsets are converted to UTC before their one-second interval
+    is constructed.
+
+    Args:
+        value: Canonical prefix date, from year through second precision.
+
+    Returns:
+        The timezone-aware UTC, half-open interval represented by the value.
+
+    Raises:
+        ValueError: The value is invalid or non-canonical, or an imprecise value
+            carries a timezone.
+    """
+    if _SECOND_TIMESTAMP_RE.fullmatch(value) is not None:
+        start = parse_utc(value)
+        return DateInterval(start=start, end=start + timedelta(seconds=1))
+    has_timezone = value.endswith("Z") or (
+        "T" in value and _TIMEZONE_SUFFIX_RE.search(value) is not None
+    )
+    if has_timezone:
+        raise ValueError("timezone suffixes require second precision")
+
+    prefix = parse(value)
+    if prefix.dt is None or prefix.text is None or prefix.precision == Precision.EMPTY:
+        raise ValueError(f"Invalid prefix date: {value!r}")
+    if prefix.text != value:
+        raise ValueError(f"Prefix date is not canonical: {value!r}")
+
+    start = prefix.dt.replace(tzinfo=timezone.utc)
+    precision = prefix.precision
+    if precision == Precision.YEAR:
+        end = start.replace(year=start.year + 1)
+    elif precision == Precision.MONTH:
+        if start.month == 12:
+            end = start.replace(year=start.year + 1, month=1)
+        else:
+            end = start.replace(month=start.month + 1)
+    elif precision == Precision.DAY:
+        end = start + timedelta(days=1)
+    elif precision == Precision.HOUR:
+        end = start + timedelta(hours=1)
+    elif precision == Precision.MINUTE:
+        end = start + timedelta(minutes=1)
+    elif precision == Precision.SECOND:
+        end = start + timedelta(seconds=1)
+    else:
+        raise ValueError(f"Unsupported prefix date precision: {value!r}")
+    return DateInterval(start=start, end=end)
+
+
+def interval_ended_before(value: DateInterval, reference: datetime) -> bool:
+    """Check whether an interval has completely elapsed before a point in time.
+
+    Use this for end dates and age cutoffs when the prefix date has already been
+    parsed.
+
+    Args:
+        value: Interval to compare.
+        reference: Timezone-aware UTC point in time.
+
+    Returns:
+        ``True`` if every instant represented by the interval precedes the
+        reference.
+    """
+    return value.end <= reference
+
+
+def interval_starts_after(value: DateInterval, reference: datetime) -> bool:
+    """Check whether an interval begins strictly after a point in time.
+
+    Use this for start dates and future-date guardrails when the prefix date has
+    already been parsed.
+
+    Args:
+        value: Interval to compare.
+        reference: Timezone-aware UTC point in time.
+
+    Returns:
+        ``True`` if the earliest instant in the interval follows the reference.
+    """
+    return value.start > reference
+
+
+def ended_before(value: str, reference: datetime) -> bool:
+    """Check whether a prefix date has completely elapsed.
+
+    Use this string wrapper for one-off end-date and age-cutoff checks. Parse
+    once with [prefix_interval][rigour.dates.prefix_interval] when making
+    several comparisons against the same value.
+
+    Args:
+        value: Canonical prefix date, from year through second precision.
+        reference: UTC point in time. Legacy naive values are interpreted as
+            UTC; aware values are converted to UTC.
+
+    Returns:
+        ``True`` if every instant represented by the date precedes the
+        reference.
+    """
+    return interval_ended_before(prefix_interval(value), _ensure_utc(reference))
+
+
+def starts_after(value: str, reference: datetime) -> bool:
+    """Check whether a prefix date begins after a point in time.
+
+    Use this string wrapper for one-off start-date and future-date checks. Parse
+    once with [prefix_interval][rigour.dates.prefix_interval] when reusing the
+    same value.
+
+    Args:
+        value: Canonical prefix date, from year through second precision.
+        reference: UTC point in time. Legacy naive values are interpreted as
+            UTC; aware values are converted to UTC.
+
+    Returns:
+        ``True`` if the earliest instant represented by the date follows the
+        reference.
+    """
+    return interval_starts_after(prefix_interval(value), _ensure_utc(reference))

rigour-2.2.2/rigour/ids/imo.py

@@ -0,0 +1,125 @@
+import re
+from typing import Callable, List, Optional, Tuple
+
+from rigour.ids.common import IdentifierFormat
+
+IMO_RE = re.compile(r"(IMO[\s:.#-]*)?(?<!\d)(\d{5,7})(?!\d)")
+
+Checksum = Callable[[List[int]], bool]
+
+
+def _vessel_checksum(digits: List[int]) -> bool:
+    return sum(d * (7 - i) for i, d in enumerate(digits[:6])) % 10 == digits[6]
+
+
+def _company_checksum(digits: List[int]) -> bool:
+    weights = (8, 6, 4, 2, 9, 7)
+    checksum = sum(d * w for d, w in zip(digits, weights))
+    return (11 - checksum % 11) % 10 == digits[6]
+
+
+class IMO(IdentifierFormat):
+    """An IMO number for a ship or a shipping company.
+
+    Ship and company IMO numbers are both seven digits but use different check
+    digit algorithms; this format admits both. Use
+    [is_valid_vessel][rigour.ids.imo.IMO.is_valid_vessel] or
+    [is_valid_company][rigour.ids.imo.IMO.is_valid_company] when the value
+    must belong to one specific scheme, e.g. when minting scheme-specific
+    entity IDs.
+
+    Extraction considers digit runs of five to seven digits, preferring longer
+    runs, then runs carrying an `IMO` prefix, then earlier ones; the first
+    candidate that passes a checksum wins. Runs shorter than seven digits are
+    left-padded with zeros, since data sources commonly strip leading zeros
+    from IMO fields. The all-zero value is rejected.
+    """
+
+    NAME = "imo"
+    TITLE = "IMO"
+    STRONG = True
+
+    @classmethod
+    def is_valid(cls, text: str) -> bool:
+        """Determine if the given text contains a valid IMO number.
+
+        Args:
+            text: A string that may contain an IMO number.
+
+        Returns:
+            True if an IMO number valid in either checksum scheme can be
+            extracted from the text.
+        """
+        return cls._extract(text, (_vessel_checksum, _company_checksum)) is not None
+
+    @classmethod
+    def is_valid_vessel(cls, text: str) -> bool:
+        """Determine if the given text contains a valid ship IMO number.
+
+        Args:
+            text: A string that may contain an IMO number.
+
+        Returns:
+            True if an IMO number valid in the vessel checksum scheme can be
+            extracted from the text.
+        """
+        return cls._extract(text, (_vessel_checksum,)) is not None
+
+    @classmethod
+    def is_valid_company(cls, text: str) -> bool:
+        """Determine if the given text contains a valid company IMO number.
+
+        Args:
+            text: A string that may contain an IMO number.
+
+        Returns:
+            True if an IMO number valid in the company checksum scheme can be
+            extracted from the text.
+        """
+        return cls._extract(text, (_company_checksum,)) is not None
+
+    @classmethod
+    def normalize(cls, text: str) -> Optional[str]:
+        """Extract and normalize an IMO number from the given text.
+
+        Args:
+            text: A string that may contain an IMO number.
+
+        Returns:
+            The number in `IMO0000000` form, or None if the text contains no
+            checksum-valid IMO number.
+        """
+        value = cls._extract(text, (_vessel_checksum, _company_checksum))
+        if value is None:
+            return None
+        return f"IMO{value}"
+
+    @classmethod
+    def _extract(cls, text: str, checksums: Tuple[Checksum, ...]) -> Optional[str]:
+        matches = sorted(
+            IMO_RE.finditer(text),
+            key=lambda m: (-len(m.group(2)), m.group(1) is None, m.start()),
+        )
+        for match in matches:
+            value = match.group(2).zfill(7)
+            digits = [int(d) for d in value]
+            if not any(digits):
+                continue
+            if any(check(digits) for check in checksums):
+                return value
+        return None
+
+    @classmethod
+    def format(cls, value: str) -> str:
+        """Format the given value as an IMO number.
+
+        Args:
+            value: A pre-validated IMO number.
+
+        Returns:
+            The value with an `IMO` prefix.
+        """
+        value = value.replace(" ", "")
+        if not value.startswith("IMO"):
+            value = f"IMO{value}"
+        return value

rigour-2.2.2/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.2}/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.2/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.2}/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.2}/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.2}/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.2}/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.2}/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.2}/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` —