id-extract 0.2.0__py3-none-any.whl

id_extract/__init__.py

@@ -0,0 +1,26 @@
+"""Extract structured identifiers with RE2 and checksums.
+
+This package finds placements. It does not replace text, build a mapping,
+or open files. Documentation lives in the anonymizer monorepo
+(https://leo-gan.github.io/anonymizer/).
+"""
+
+from id_extract.extract import extract
+from id_extract.opt_in import available_opt_in
+from id_extract.plugins import (
+    available_countries,
+    filter_regex_patterns,
+    pattern_country,
+    patterns,
+)
+from id_extract.types import Entity
+
+__all__ = [
+    "Entity",
+    "available_countries",
+    "available_opt_in",
+    "extract",
+    "filter_regex_patterns",
+    "pattern_country",
+    "patterns",
+]

id_extract/checksums.py

@@ -0,0 +1,472 @@
+"""Cheap, unambiguous checksums for structured regex hits.
+
+The regex stage is structural on purpose (RE2 cannot do Luhn, IBAN mod-97, etc.).
+After a match, this module checks the extra digit when one exists.
+
+- Check passes: keep the real type (``IBAN``).
+- Check fails: keep the text, but relabel as ``IBAN_LIKE`` so a mistyped
+  number is still hidden. Never drop the hit.
+- No registered check: accept the type unchanged.
+
+Only attach a check when it is cheap and unambiguous. Do not invent rules for
+identifiers that have none (most SSNs, many passports, most VAT numbers).
+"""
+
+from __future__ import annotations
+
+from typing import Callable, Dict
+
+# Official IBAN character lengths by country code (ISO 13616).
+# Unknown countries are rejected so random "ABxx..." tokens do not survive.
+_IBAN_LENGTHS: Dict[str, int] = {
+    "AD": 24,
+    "AE": 23,
+    "AL": 28,
+    "AT": 20,
+    "AZ": 28,
+    "BA": 20,
+    "BE": 16,
+    "BG": 22,
+    "BH": 22,
+    "BR": 29,
+    "BY": 28,
+    "CH": 21,
+    "CR": 22,
+    "CY": 28,
+    "CZ": 24,
+    "DE": 22,
+    "DK": 18,
+    "DO": 28,
+    "EE": 20,
+    "EG": 29,
+    "ES": 24,
+    "FI": 18,
+    "FO": 18,
+    "FR": 27,
+    "GB": 22,
+    "GE": 22,
+    "GI": 23,
+    "GL": 18,
+    "GR": 27,
+    "GT": 28,
+    "HR": 21,
+    "HU": 28,
+    "IE": 22,
+    "IL": 23,
+    "IQ": 23,
+    "IS": 26,
+    "IT": 27,
+    "JO": 30,
+    "KW": 30,
+    "KZ": 20,
+    "LB": 28,
+    "LC": 32,
+    "LI": 21,
+    "LT": 20,
+    "LU": 20,
+    "LV": 21,
+    "LY": 25,
+    "MC": 27,
+    "MD": 24,
+    "ME": 22,
+    "MK": 19,
+    "MR": 27,
+    "MT": 31,
+    "MU": 30,
+    "NL": 18,
+    "NO": 15,
+    "PK": 24,
+    "PL": 28,
+    "PS": 29,
+    "PT": 25,
+    "QA": 29,
+    "RO": 24,
+    "RS": 22,
+    "SA": 24,
+    "SE": 24,
+    "SI": 19,
+    "SK": 24,
+    "SM": 27,
+    "TN": 24,
+    "TR": 26,
+    "UA": 29,
+    "VA": 22,
+    "VG": 24,
+    "XK": 20,
+}
+
+# ISO 3779 VIN transliteration (I, O, Q are not used).
+_VIN_TRANSLIT = {
+    "A": 1,
+    "B": 2,
+    "C": 3,
+    "D": 4,
+    "E": 5,
+    "F": 6,
+    "G": 7,
+    "H": 8,
+    "J": 1,
+    "K": 2,
+    "L": 3,
+    "M": 4,
+    "N": 5,
+    "P": 7,
+    "R": 9,
+    "S": 2,
+    "T": 3,
+    "U": 4,
+    "V": 5,
+    "W": 6,
+    "X": 7,
+    "Y": 8,
+    "Z": 9,
+}
+_VIN_WEIGHTS = (8, 7, 6, 5, 4, 3, 2, 10, 0, 9, 8, 7, 6, 5, 4, 3, 2)
+
+# Spanish DNI / NIE remainder -> letter.
+_DNI_LETTERS = "TRWAGMYFPDXBNJZSQVHLCKE"
+_NIE_PREFIX = {"X": "0", "Y": "1", "Z": "2"}
+
+# Chinese Resident Identity Card (GB 11643-1999).
+_CN_WEIGHTS = (7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2)
+_CN_CHECK = "10X98765432"
+
+# Verhoeff tables (Aadhaar).
+_VERHOEFF_D = (
+    (0, 1, 2, 3, 4, 5, 6, 7, 8, 9),
+    (1, 2, 3, 4, 0, 6, 7, 8, 9, 5),
+    (2, 3, 4, 0, 1, 7, 8, 9, 5, 6),
+    (3, 4, 0, 1, 2, 8, 9, 5, 6, 7),
+    (4, 0, 1, 2, 3, 9, 5, 6, 7, 8),
+    (5, 9, 8, 7, 6, 0, 4, 3, 2, 1),
+    (6, 5, 9, 8, 7, 1, 0, 4, 3, 2),
+    (7, 6, 5, 9, 8, 2, 1, 0, 4, 3),
+    (8, 7, 6, 5, 9, 3, 2, 1, 0, 4),
+    (9, 8, 7, 6, 5, 4, 3, 2, 1, 0),
+)
+_VERHOEFF_P = (
+    (0, 1, 2, 3, 4, 5, 6, 7, 8, 9),
+    (1, 5, 7, 6, 2, 8, 3, 0, 9, 4),
+    (5, 8, 0, 3, 7, 9, 6, 1, 4, 2),
+    (8, 9, 1, 6, 0, 4, 3, 5, 2, 7),
+    (9, 4, 5, 3, 1, 2, 6, 8, 7, 0),
+    (4, 2, 8, 6, 5, 7, 3, 9, 0, 1),
+    (2, 7, 9, 3, 8, 0, 6, 4, 1, 5),
+    (7, 0, 4, 6, 9, 1, 3, 2, 5, 8),
+)
+
+# Italian codice fiscale: odd positions (1-based) and even positions.
+_CF_ODD = {
+    "0": 1,
+    "1": 0,
+    "2": 5,
+    "3": 7,
+    "4": 9,
+    "5": 13,
+    "6": 15,
+    "7": 17,
+    "8": 19,
+    "9": 21,
+    "A": 1,
+    "B": 0,
+    "C": 5,
+    "D": 7,
+    "E": 9,
+    "F": 13,
+    "G": 15,
+    "H": 17,
+    "I": 19,
+    "J": 21,
+    "K": 2,
+    "L": 4,
+    "M": 18,
+    "N": 20,
+    "O": 11,
+    "P": 3,
+    "Q": 6,
+    "R": 8,
+    "S": 12,
+    "T": 14,
+    "U": 16,
+    "V": 10,
+    "W": 22,
+    "X": 25,
+    "Y": 24,
+    "Z": 23,
+}
+_CF_EVEN = {
+    **{str(i): i for i in range(10)},
+    **{chr(ord("A") + i): i for i in range(26)},
+}
+
+
+def _digits_only(text: str) -> str:
+    return "".join(ch for ch in text if ch.isdigit())
+
+
+def _alnum_upper(text: str) -> str:
+    return "".join(ch for ch in text.upper() if ch.isalnum())
+
+
+def luhn_ok(digits: str) -> bool:
+    """Return True if ``digits`` (0-9 only) passes the Luhn check."""
+    if not digits or not digits.isdigit():
+        return False
+    total = 0
+    # Double every second digit from the right.
+    reverse = digits[::-1]
+    for i, ch in enumerate(reverse):
+        n = ord(ch) - 48
+        if i % 2 == 1:
+            n *= 2
+            if n > 9:
+                n -= 9
+        total += n
+    return total % 10 == 0
+
+
+def verhoeff_ok(digits: str) -> bool:
+    """Return True if ``digits`` (0-9 only) passes the Verhoeff check."""
+    if not digits or not digits.isdigit():
+        return False
+    checksum = 0
+    for i, ch in enumerate(reversed(digits)):
+        checksum = _VERHOEFF_D[checksum][_VERHOEFF_P[i % 8][ord(ch) - 48]]
+    return checksum == 0
+
+
+def validate_credit_card(text: str) -> bool:
+    digits = _digits_only(text)
+    if not 13 <= len(digits) <= 19:
+        return False
+    return luhn_ok(digits)
+
+
+def validate_npi(text: str) -> bool:
+    # CMS: Luhn over the prefix 80840 + the 10-digit NPI.
+    digits = _digits_only(text)
+    if len(digits) != 10:
+        return False
+    return luhn_ok("80840" + digits)
+
+
+def validate_sin_ca(text: str) -> bool:
+    digits = _digits_only(text)
+    if len(digits) != 9:
+        return False
+    return luhn_ok(digits)
+
+
+def validate_iban(text: str) -> bool:
+    compact = _alnum_upper(text)
+    if len(compact) < 5 or not compact[:2].isalpha() or not compact[2:4].isdigit():
+        return False
+    expected = _IBAN_LENGTHS.get(compact[:2])
+    if expected is None or len(compact) != expected:
+        return False
+    rearranged = compact[4:] + compact[:4]
+    numeric = []
+    for ch in rearranged:
+        if ch.isdigit():
+            numeric.append(ch)
+        else:
+            numeric.append(str(ord(ch) - 55))  # A=10 ... Z=35
+    return int("".join(numeric)) % 97 == 1
+
+
+def validate_vin(text: str) -> bool:
+    vin = _alnum_upper(text)
+    if len(vin) != 17:
+        return False
+    total = 0
+    for i, ch in enumerate(vin):
+        if ch.isdigit():
+            value = ord(ch) - 48
+        else:
+            value = _VIN_TRANSLIT.get(ch)
+            if value is None:
+                return False
+        total += value * _VIN_WEIGHTS[i]
+    remainder = total % 11
+    expected = "X" if remainder == 10 else str(remainder)
+    return vin[8] == expected
+
+
+def validate_dni_es(text: str) -> bool:
+    compact = _alnum_upper(text)
+    if len(compact) != 9 or not compact[:8].isdigit() or not compact[8].isalpha():
+        return False
+    return compact[8] == _DNI_LETTERS[int(compact[:8]) % 23]
+
+
+def validate_nie_es(text: str) -> bool:
+    compact = _alnum_upper(text)
+    if len(compact) != 9 or compact[0] not in _NIE_PREFIX:
+        return False
+    return validate_dni_es(_NIE_PREFIX[compact[0]] + compact[1:])
+
+
+def validate_resident_id_cn(text: str) -> bool:
+    compact = _alnum_upper(text)
+    if len(compact) != 18 or not compact[:17].isdigit():
+        return False
+    total = sum((ord(compact[i]) - 48) * _CN_WEIGHTS[i] for i in range(17))
+    return compact[17] == _CN_CHECK[total % 11]
+
+
+def validate_aadhaar_in(text: str) -> bool:
+    digits = _digits_only(text)
+    if len(digits) != 12 or digits[0] in "01":
+        return False
+    return verhoeff_ok(digits)
+
+
+def validate_cpf_br(text: str) -> bool:
+    digits = _digits_only(text)
+    if len(digits) != 11 or len(set(digits)) == 1:
+        return False
+
+    def _cpf_digit(body: str, start_weight: int) -> str:
+        total = sum((ord(ch) - 48) * (start_weight - i) for i, ch in enumerate(body))
+        remainder = total % 11
+        return "0" if remainder < 2 else str(11 - remainder)
+
+    if digits[9] != _cpf_digit(digits[:9], 10):
+        return False
+    return digits[10] == _cpf_digit(digits[:10], 11)
+
+
+def validate_codice_fiscale_it(text: str) -> bool:
+    compact = _alnum_upper(text)
+    if len(compact) != 16:
+        return False
+    total = 0
+    for i, ch in enumerate(compact[:15]):
+        table = _CF_ODD if i % 2 == 0 else _CF_EVEN
+        value = table.get(ch)
+        if value is None:
+            return False
+        total += value
+    return compact[15] == chr(ord("A") + (total % 26))
+
+
+def validate_pesel_pl(text: str) -> bool:
+    digits = _digits_only(text)
+    if len(digits) != 11:
+        return False
+    weights = (1, 3, 7, 9, 1, 3, 7, 9, 1, 3)
+    total = sum((ord(digits[i]) - 48) * weights[i] for i in range(10))
+    check = (10 - (total % 10)) % 10
+    return digits[10] == str(check)
+
+
+def validate_rtn_us(text: str) -> bool:
+    """ABA routing number: weights 3, 7, 1 and a zero mod-10 total."""
+    digits = _digits_only(text)
+    if len(digits) != 9:
+        return False
+    prefix = int(digits[:2])
+    if not (prefix <= 12 or 21 <= prefix <= 32 or 61 <= prefix <= 72 or prefix == 80):
+        return False
+    weights = (3, 7, 1, 3, 7, 1, 3, 7, 1)
+    total = sum((ord(digits[i]) - 48) * weights[i] for i in range(9))
+    return total % 10 == 0
+
+
+def validate_cusip(text: str) -> bool:
+    """CUSIP Modulus 10 double-add-double check digit (CGS / ANSI X9.6)."""
+    compact = _alnum_upper(text)
+    if len(compact) != 9 or not compact[8].isdigit():
+        return False
+    total = 0
+    for i, ch in enumerate(compact[:8]):
+        if ch.isdigit():
+            value = ord(ch) - 48
+        elif "A" <= ch <= "Z":
+            value = ord(ch) - ord("A") + 10
+        else:
+            return False
+        if i % 2 == 1:
+            value *= 2
+        total += value // 10 + value % 10
+    check = (10 - (total % 10)) % 10
+    return compact[8] == str(check)
+
+
+def validate_phn_bc(text: str) -> bool:
+    """BC Personal Health Number: leading 9 and the Teleplan MOD-11 digit."""
+    digits = _digits_only(text)
+    if len(digits) != 10 or digits[0] != "9":
+        return False
+    weights = (2, 4, 8, 5, 10, 9, 7, 3)
+    total = sum((ord(digits[i + 1]) - 48) * weights[i] for i in range(8))
+    remainder = total % 11
+    expected = 0 if remainder == 0 else 11 - remainder
+    if expected == 10:
+        return False
+    return digits[9] == str(expected)
+
+
+def validate_clabe_mx(text: str) -> bool:
+    """CLABE control digit: cyclic weights 3, 7, 1 on the first 17 digits."""
+    digits = _digits_only(text)
+    if len(digits) != 18:
+        return False
+    weights = (3, 7, 1)
+    total = 0
+    for i, ch in enumerate(digits[:17]):
+        total += ((ord(ch) - 48) * weights[i % 3]) % 10
+    check = (10 - (total % 10)) % 10
+    return digits[17] == str(check)
+
+
+ValidatorFn = Callable[[str], bool]
+
+# Keys must match entity TYPEs emitted by the regex stage (upper-case).
+CHECKSUM_VALIDATORS: Dict[str, ValidatorFn] = {
+    "CREDIT_CARD": validate_credit_card,
+    "MEDICAL_NPI_US": validate_npi,
+    "SIN_CA": validate_sin_ca,
+    "IBAN": validate_iban,
+    "VIN": validate_vin,
+    "DNI_ES": validate_dni_es,
+    "NIE_ES": validate_nie_es,
+    "RESIDENT_ID_CN": validate_resident_id_cn,
+    "AADHAAR_IN": validate_aadhaar_in,
+    "CPF_BR": validate_cpf_br,
+    "CODICE_FISCALE_IT": validate_codice_fiscale_it,
+    "PESEL_PL": validate_pesel_pl,
+    "RTN_US": validate_rtn_us,
+    "CUSIP_NNA": validate_cusip,
+    "PHN_BC_CA": validate_phn_bc,
+    "CLABE_MX": validate_clabe_mx,
+}
+
+# These shapes are common digit runs. A failed check is dropped instead of
+# kept as TYPE_LIKE, which is what the other validators do.
+STRICT_CHECKSUMS = frozenset(
+    {
+        "RTN_US",
+        "CUSIP_NNA",
+        "PHN_BC_CA",
+        "CLABE_MX",
+    }
+)
+
+
+def has_checksum(entity_type: str) -> bool:
+    """Return True if this type has a registered extra-digit check."""
+    return entity_type.upper() in CHECKSUM_VALIDATORS
+
+
+def strict_checksum(entity_type: str) -> bool:
+    """Return True when a failed check should drop the hit."""
+    return entity_type.upper() in STRICT_CHECKSUMS
+
+
+def passes_checksum(entity_type: str, text: str) -> bool:
+    """Return True if ``text`` has no check, or if its check succeeds."""
+    validator = CHECKSUM_VALIDATORS.get(entity_type.upper())
+    if validator is None:
+        return True
+    return validator(text)

id_extract/countries/__init__.py

@@ -0,0 +1 @@
+"""Bundled country plugins. Universal patterns always load."""

id_extract/countries/ar.py

@@ -0,0 +1,7 @@
+"""National-ID patterns for AR."""
+
+CODE = "AR"
+
+PATTERNS = {
+    "DNI_AR": "\\b\\d{8}\\b",
+}

id_extract/countries/at.py

@@ -0,0 +1,7 @@
+"""National-ID patterns for AT."""
+
+CODE = "AT"
+
+PATTERNS = {
+    "SVNR_AT": "\\b\\d{10}\\b",
+}

id_extract/countries/au.py

@@ -0,0 +1,9 @@
+"""National-ID patterns for AU."""
+
+CODE = "AU"
+
+PATTERNS = {
+    "TFN_AU": "\\b\\d{3}\\s?\\d{3}\\s?\\d{3}\\b",
+    "ABN_AU": "\\b\\d{2}\\s?\\d{3}\\s?\\d{3}\\s?\\d{3}\\b",
+    "DRIVERS_LICENSE_AU": "\\b[A-Z0-9]{8,10}\\b",
+}

id_extract/countries/be.py

@@ -0,0 +1,7 @@
+"""National-ID patterns for BE."""
+
+CODE = "BE"
+
+PATTERNS = {
+    "NISS_BE": "\\b\\d{2}\\.\\d{2}\\.\\d{2}-\\d{3}\\.\\d{2}\\b|\\b\\d{11}\\b",
+}

id_extract/countries/br.py

@@ -0,0 +1,9 @@
+"""National-ID patterns for BR."""
+
+CODE = "BR"
+
+PATTERNS = {
+    "CPF_BR": "\\b\\d{3}\\.?\\d{3}\\.?\\d{3}-?\\d{2}\\b",
+    "CNPJ_BR": "\\b\\d{2}\\.?\\d{3}\\.?\\d{3}/?\\d{4}-?\\d{2}\\b",
+    "RG_BR": "\\b\\d{2}\\.?\\d{3}\\.?\\d{3}-?[0-9X]\\b",
+}

id_extract/countries/ca.py

@@ -0,0 +1,15 @@
+"""National-ID patterns for CA."""
+
+CODE = "CA"
+
+PATTERNS = {
+    "SIN_CA": "\\b\\d{3}-\\d{3}-\\d{3}\\b",
+    "DRIVERS_LICENSE_CA": "\\b[A-Z]\\d{4,5}-\\d{5,6}-\\d{5}\\b|\\b[A-Z0-9]{5,15}\\b",
+    # CRA program account: 9-digit BN + program letters + 4-digit reference.
+    "PROGRAM_ACCOUNT_CA": "\\b\\d{9}\\s?(?:RT|RP|RC|RM|RZ|RR|RG)\\s?\\d{4}\\b",
+    "DIN_CA": "\\bDIN\\s?\\d{8}\\b",
+    "NPN_CA": "\\bNPN\\s?\\d{8}\\b",
+    "DIN_HM_CA": "\\bDIN-HM\\s?\\d{8}\\b",
+    # IRCC prints the 10-digit UCI as NN-NNNN-NNNN.
+    "UCI_CA": "\\b\\d{2}-\\d{4}-\\d{4}\\b",
+}

id_extract/countries/ch.py

@@ -0,0 +1,8 @@
+"""National-ID patterns for CH."""
+
+CODE = "CH"
+
+PATTERNS = {
+    "AHV_CH": "\\b756\\.\\d{4}\\.\\d{4}\\.\\d{2}\\b|\\b756\\d{10}\\b",
+    "VAT_CH": "\\bCHE\\d{9}(?:MWST|TVA|IVA)?\\b",
+}

id_extract/countries/cn.py

@@ -0,0 +1,9 @@
+"""National-ID patterns for CN."""
+
+CODE = "CN"
+
+PATTERNS = {
+    "RESIDENT_ID_CN": "\\b\\d{17}[\\dXx]\\b",
+    "UNIFIED_SOCIAL_CREDIT_CODE_CN": "\\b[A-Z0-9]{18}\\b",
+    "PASSPORT_CN": "\\bE\\d{8}\\b|\\bG\\d{8}\\b|\\bS\\d{8}\\b",
+}

id_extract/countries/de.py

@@ -0,0 +1,10 @@
+"""National-ID patterns for DE."""
+
+CODE = "DE"
+
+PATTERNS = {
+    "STEUER_ID_DE": "\\b\\d{11}\\b",
+    "VAT_DE": "\\bDE\\d{9}\\b",
+    "PERSONALAUSWEIS_DE": "\\b[A-Z0-9]{9,10}\\b",
+    "DRIVERS_LICENSE_DE": "\\b[A-Z0-9]{11,12}\\b",
+}

id_extract/countries/dk.py

@@ -0,0 +1,7 @@
+"""National-ID patterns for DK."""
+
+CODE = "DK"
+
+PATTERNS = {
+    "CPR_DK": "\\b\\d{6}-\\d{4}\\b",
+}

id_extract/countries/es.py

@@ -0,0 +1,11 @@
+"""National-ID patterns for ES."""
+
+CODE = "ES"
+
+PATTERNS = {
+    "DNI_ES": "\\b\\d{8}[A-HJ-NP-TV-Z]\\b",
+    "NIE_ES": "\\b[XYZ]\\d{7}[A-HJ-NP-TV-Z]\\b",
+    "CIF_ES": "\\b[A-HJ-NP-S]\\d{7}[A-J0-9]\\b",
+    "VAT_ES": "\\bES[A-Z0-9]\\d{7}[A-Z0-9]\\b",
+    "DRIVERS_LICENSE_ES": "\\b[A-Z0-9]{9,10}\\b",
+}

id_extract/countries/fi.py

@@ -0,0 +1,7 @@
+"""National-ID patterns for FI."""
+
+CODE = "FI"
+
+PATTERNS = {
+    "HETU_FI": "\\b\\d{6}[+\\-A]\\d{3}[0-9A-Z]\\b",
+}

id_extract/countries/fr.py

@@ -0,0 +1,10 @@
+"""National-ID patterns for FR."""
+
+CODE = "FR"
+
+PATTERNS = {
+    "INSEE_FR": "\\b[12]\\d{12,14}\\b",
+    "VAT_FR": "\\bFR[A-HJ-NP-Z0-9]{2}\\d{9}\\b",
+    "DRIVERS_LICENSE_FR": "\\b[A-Z0-9]{12}\\b",
+    "PASSPORT_FR": "\\b\\d{2}[A-Z]{2}\\d{5}\\b",
+}

id_extract/countries/gb.py

@@ -0,0 +1,10 @@
+"""National-ID patterns for GB."""
+
+CODE = "GB"
+
+PATTERNS = {
+    "NINO_GB": "\\b[A-CEGHJ-PR-TW-Z]{1}[A-CEGHJ-NPR-TW-Z]{1}\\d{6}[A-DFM]?\\b",
+    "DRIVERS_LICENSE_GB": "\\b[A-Z9]{5}\\d{6}[A-Z9]{2}\\d[A-Z]{2}\\b",
+    "VAT_GB": "\\bGB\\d{9}\\b|\\bGB\\d{12}\\b|\\bGBGD\\d{3}\\b|\\bGBHA\\d{3}\\b",
+    "COMPANIES_HOUSE_GB": "\\b(?:SC|NI|OC|SO)?\\d{6,8}\\b",
+}

id_extract/countries/gr.py

@@ -0,0 +1,7 @@
+"""National-ID patterns for GR."""
+
+CODE = "GR"
+
+PATTERNS = {
+    "AMKA_GR": "\\b\\d{11}\\b",
+}

id_extract/countries/hk.py

@@ -0,0 +1,7 @@
+"""National-ID patterns for HK."""
+
+CODE = "HK"
+
+PATTERNS = {
+    "HKID_HK": "\\b[A-Z]{1,2}\\d{6}[0-9A]\\b",
+}

id_extract/countries/id.py

@@ -0,0 +1,7 @@
+"""National-ID patterns for ID."""
+
+CODE = "ID"
+
+PATTERNS = {
+    "NIK_ID": "\\b\\d{16}\\b",
+}

id_extract/countries/ie.py

@@ -0,0 +1,7 @@
+"""National-ID patterns for IE."""
+
+CODE = "IE"
+
+PATTERNS = {
+    "PPS_IE": "\\b\\d{7}[A-W]\\b",
+}

id_extract/countries/il.py

@@ -0,0 +1,7 @@
+"""National-ID patterns for IL."""
+
+CODE = "IL"
+
+PATTERNS = {
+    "ID_IL": "\\b\\d{9}\\b",
+}