maskflow-pack-india 0.1.0__tar.gz

maskflow_pack_india-0.1.0/.gitignore

@@ -0,0 +1,15 @@
+__pycache__/
+*.py[cod]
+.venv/
+venv/
+.env
+node_modules/
+dist/
+build/
+*.egg-info/
+.DS_Store
+.pytest_cache/
+.idea/
+.coverage
+.mypy_cache/
+.ruff_cache/

maskflow_pack_india-0.1.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.5
+Name: maskflow-pack-india
+Version: 0.1.0
+Summary: MaskFlow's Indian PII recognizers (Aadhaar, PAN, GSTIN, IFSC, UPI VPA)
+License: MIT
+Requires-Python: >=3.10
+Requires-Dist: maskflow-core<0.5,>=0.4.0

maskflow_pack_india-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "maskflow-pack-india"
+version = "0.1.0"
+description = "MaskFlow's Indian PII recognizers (Aadhaar, PAN, GSTIN, IFSC, UPI VPA)"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+dependencies = [
+    # register_pattern()'s validator/context_keywords kwargs are all this
+    # pack needs -- no NER, so no maskflow-core[nlp] extra required (keeps
+    # this pack spaCy-free and its own import cost near zero).
+    "maskflow-core>=0.4.0,<0.5",
+]
+
+[tool.uv.sources]
+maskflow-core = { workspace = true }
+
+[tool.uv]
+package = true
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/maskflow_pack_india"]

maskflow_pack_india-0.1.0/src/maskflow_pack_india/__init__.py

@@ -0,0 +1,147 @@
+"""Registers MaskFlow's India-specific recognizers (AADHAAR, AADHAAR_MASKED,
+PAN, GSTIN, IFSC, UPI_VPA) against maskflow-core on import. Importing this
+package is the side effect that makes detect()/mask()/unmask() aware of
+these types -- see maskflow_core.registry.register_pattern.
+
+Context keywords are positive-only (English, Hindi/Devanagari, and Hinglish
+transliterations) -- maskflow-core's context.apply_context_boost() has no
+negative-context mechanism yet (CLAUDE.md's confidence formula documents one
+as a target, but it isn't implemented in core), so "example/test/dummy"-style
+suppression is out of scope for this pack until core grows that hook.
+"""
+
+from maskflow_core.registry import register_pattern
+
+from . import patterns
+
+register_pattern(
+    "AADHAAR",
+    patterns.AADHAAR_RE,
+    0.5,
+    validator=patterns.validate_aadhaar,
+    context_keywords=(
+        "aadhaar",
+        "aadhar",
+        "adhaar",
+        "uidai",
+        "aadhaar number",
+        "aadhaar no",
+        "aadhar no",
+        "aadhaar card",
+        "uid number",
+        "आधार",
+        "आधार कार्ड",
+        "आधार संख्या",
+    ),
+)
+register_pattern(
+    "AADHAAR",
+    patterns.AADHAAR_VID_RE,
+    0.5,
+    validator=patterns.validate_aadhaar,
+    context_keywords=(
+        "vid",
+        "virtual id",
+        "aadhaar vid",
+        "aadhaar",
+        "aadhar",
+        "uidai",
+        "आधार",
+        "वर्चुअल आईडी",
+    ),
+)
+register_pattern(
+    "AADHAAR_MASKED",
+    patterns.AADHAAR_MASKED_RE,
+    # No validator possible (8 of 12 digits are gone) -- 0.45 starts BELOW
+    # detection.py's DEFAULT_MIN_CONFIDENCE (0.5), same design as pack-intl's
+    # SSN_PLAIN: an unvalidated, structurally-ambiguous match should need a
+    # nearby keyword to clear the bar, not pass on shape alone.
+    0.45,
+    context_keywords=(
+        "aadhaar",
+        "aadhar",
+        "adhaar",
+        "uidai",
+        "masked aadhaar",
+        "aadhaar ending",
+        "आधार",
+    ),
+)
+
+register_pattern(
+    "PAN",
+    patterns.PAN_RE,
+    0.6,
+    validator=patterns.validate_pan,
+    context_keywords=(
+        "pan",
+        "pan card",
+        "pan number",
+        "pan no",
+        "permanent account number",
+        "पैन",
+        "पैन कार्ड",
+        "पैन नंबर",
+    ),
+)
+register_pattern(
+    "PAN",
+    patterns.PAN_EMBEDDED_IN_GSTIN_RE,
+    0.6,
+    validator=patterns.validate_pan,
+)
+
+register_pattern(
+    "GSTIN",
+    patterns.GSTIN_RE,
+    0.6,
+    validator=patterns.validate_gstin,
+    context_keywords=(
+        "gstin",
+        "gst number",
+        "gst no",
+        "gst reg",
+        "goods and services tax",
+        "gstin number",
+        "जीएसटी",
+        "जीएसटीआईएन",
+        "जीएसटी नंबर",
+    ),
+)
+
+register_pattern(
+    "IFSC",
+    patterns.IFSC_RE,
+    0.6,
+    validator=patterns.validate_ifsc,
+    context_keywords=(
+        "ifsc",
+        "ifsc code",
+        "branch code",
+        "bank branch",
+        "आईएफएससी",
+        "आईएफएससी कोड",
+    ),
+)
+
+register_pattern(
+    "UPI_VPA",
+    patterns.UPI_VPA_RE,
+    0.5,
+    validator=patterns.validate_upi_vpa,
+    context_keywords=(
+        "upi",
+        "upi id",
+        "vpa",
+        "pay to",
+        "gpay",
+        "google pay",
+        "phonepe",
+        "paytm",
+        "यूपीआई",
+        "यूपीआई आईडी",
+    ),
+)
+
+__all__: list[str] = []

maskflow_pack_india-0.1.0/src/maskflow_pack_india/checksums.py

@@ -0,0 +1,103 @@
+"""Verhoeff (AADHAAR) and GSTIN check-digit algorithms, isolated from regex/
+registration concerns so they can be unit-tested against published test
+vectors on their own (see tests/test_checksums.py).
+
+Neither algorithm is invented here -- both are the standard published
+constants/procedures (Verhoeff: Wikipedia "Verhoeff algorithm" / ISO
+reference tables; GSTIN: GSTN's published Luhn-mod-36 check-digit scheme,
+reimplemented independently by several open gstin-validator packages).
+"""
+
+from __future__ import annotations
+
+# ---------------------------------------------------------------------------
+# Verhoeff checksum -- dihedral group D5 multiplication/permutation tables.
+# ---------------------------------------------------------------------------
+
+_D5_MULT: tuple[tuple[int, ...], ...] = (
+    (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),
+)
+
+_D5_PERM: tuple[tuple[int, ...], ...] = (
+    (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),
+)
+
+_D5_INV: tuple[int, ...] = (0, 4, 3, 2, 1, 5, 6, 7, 8, 9)
+
+
+def verhoeff_is_valid(digits: str) -> bool:
+    """`digits` is the FULL number (AADHAAR UID or VID) including its
+    trailing Verhoeff check digit. Processed right-to-left; valid iff the
+    accumulator lands on 0. Caller is responsible for length/digit-only
+    checks -- this raises ValueError on a non-digit character rather than
+    silently misjudging it, since `int(ch)` would otherwise be the only
+    signal something was wrong."""
+    c = 0
+    for i, ch in enumerate(reversed(digits)):
+        c = _D5_MULT[c][_D5_PERM[i % 8][int(ch)]]
+    return c == 0
+
+
+def verhoeff_generate(digits: str) -> str:
+    """Given digits WITHOUT a check digit, return the check digit that makes
+    `verhoeff_is_valid(digits + check_digit)` True. Not used by the
+    recognizer itself (nothing needs to *produce* a checksum at detection
+    time) -- exists so tests/fixtures can build synthetic, checksum-valid
+    AADHAAR-shaped values without hand-computing them."""
+    c = 0
+    for i, ch in enumerate(reversed(digits)):
+        c = _D5_MULT[c][_D5_PERM[(i + 1) % 8][int(ch)]]
+    return str(_D5_INV[c])
+
+
+# ---------------------------------------------------------------------------
+# GSTIN checksum -- Luhn-mod-36 variant: alternating weights (2, 1, 2, 1, ...)
+# right-to-left over the 36-char alphanumeric alphabet, with base-36
+# digit-sum folding (the base-36 analogue of Luhn's "subtract 9 if > 9").
+# ---------------------------------------------------------------------------
+
+_GST_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+_GST_MOD = 36
+
+
+def gstin_checksum_char(first_14: str) -> str:
+    """Compute the 15th (check) character for the first 14 GSTIN characters."""
+    total = 0
+    factor = 2
+    for ch in reversed(first_14):
+        value = _GST_ALPHABET.index(ch)
+        product = factor * value
+        total += (product // _GST_MOD) + (product % _GST_MOD)
+        factor = 1 if factor == 2 else 2
+    check_value = (_GST_MOD - (total % _GST_MOD)) % _GST_MOD
+    return _GST_ALPHABET[check_value]
+
+
+def gstin_is_valid(gstin: str) -> bool:
+    """`gstin` is the full 15-character value. Caller is responsible for the
+    other structural checks (state code range, embedded-PAN shape, the
+    literal 'Z') -- this only verifies the 15th-character checksum."""
+    if len(gstin) != 15:
+        return False
+    try:
+        return gstin[14] == gstin_checksum_char(gstin[:14])
+    except ValueError:
+        # gstin[:14] contains a character outside _GST_ALPHABET (e.g.
+        # lowercase, punctuation) -- not a valid GSTIN shape, not a bug.
+        return False

maskflow_pack_india-0.1.0/src/maskflow_pack_india/data/ifsc_bank_codes.py

@@ -0,0 +1,95 @@
+"""Bundled RBI-assigned 4-letter bank codes -- the first 4 characters of an
+IFSC (e.g. "HDFC" in HDFC0001234). Curated, NOT exhaustive: it covers major
+scheduled commercial banks, small finance banks, and payments banks
+operating in India as of this file's last refresh. An IFSC whose bank code
+isn't in this set is treated as structurally invalid by validate_ifsc()
+(patterns.py) -- a false negative on an obscure/regional bank is preferred
+over inventing a checksum-like check IFSC doesn't actually have (there is no
+public per-character checksum on an IFSC; the bank-code lookup IS the
+structural check).
+
+Refresh procedure:
+  1. RBI publishes the authoritative IFSC master list (bank-wise, all
+     branches) at https://www.rbi.org.in -- search "IFSC master list" for
+     the current CSV/XLSX download.
+  2. Extract the unique set of 4-character bank-code prefixes (characters
+     0-3 of each IFSC in the list; character 4 is always '0').
+  3. Diff against IFSC_BANK_CODES below, add any new entries (bank mergers
+     retire old codes but never reuse them for a different bank -- safe to
+     leave retired codes in this set indefinitely).
+  4. Update the "last refreshed" date in this docstring.
+
+Last refreshed: 2026-08 (manually curated from public bank-merger and PSP
+records, not a direct RBI CSV import -- treat as a reasonable starting set,
+not a guarantee of completeness).
+"""
+
+from __future__ import annotations
+
+IFSC_BANK_CODES: frozenset[str] = frozenset(
+    {
+        # Public sector banks
+        "SBIN",  # State Bank of India
+        "PUNB",  # Punjab National Bank
+        "BKID",  # Bank of India
+        "CNRB",  # Canara Bank
+        "UBIN",  # Union Bank of India
+        "IOBA",  # Indian Overseas Bank
+        "IDIB",  # Indian Bank
+        "CBIN",  # Central Bank of India
+        "MAHB",  # Bank of Maharashtra
+        "UCBA",  # UCO Bank
+        "PSIB",  # Punjab & Sind Bank
+        "BARB",  # Bank of Baroda
+        # Merged/retired public sector codes (still valid on old branches --
+        # never reused for a different bank, see refresh procedure above)
+        "ORBC",  # Oriental Bank of Commerce (merged into PNB)
+        "ANDB",  # Andhra Bank (merged into Union Bank)
+        "CORP",  # Corporation Bank (merged into Union Bank)
+        "ALLA",  # Allahabad Bank (merged into Indian Bank)
+        "SYNB",  # Syndicate Bank (merged into Canara Bank)
+        "VIJB",  # Vijaya Bank (merged into Bank of Baroda)
+        # Major private sector banks
+        "HDFC",  # HDFC Bank
+        "ICIC",  # ICICI Bank
+        "UTIB",  # Axis Bank
+        "KKBK",  # Kotak Mahindra Bank
+        "YESB",  # Yes Bank
+        "INDB",  # IndusInd Bank
+        "IDFB",  # IDFC FIRST Bank
+        "RATN",  # RBL Bank
+        "FDRL",  # Federal Bank
+        "SIBL",  # South Indian Bank
+        "KVBL",  # Karur Vysya Bank
+        "TMBL",  # Tamilnad Mercantile Bank
+        "DCBB",  # DCB Bank
+        "CSBK",  # CSB Bank
+        "KARB",  # Karnataka Bank
+        "DBSS",  # DBS Bank India (incl. merged Lakshmi Vilas Bank branches)
+        "BDBL",  # Bandhan Bank
+        "JAKA",  # Jammu & Kashmir Bank
+        "NKGS",  # NKGSB Co-operative Bank
+        "SVCB",  # Shamrao Vithal Co-operative Bank
+        # Foreign banks operating in India
+        "CITI",  # Citibank
+        "HSBC",  # HSBC
+        "SCBL",  # Standard Chartered Bank
+        "DEUT",  # Deutsche Bank
+        "BOFA",  # Bank of America
+        # Small finance banks
+        "AUBL",  # AU Small Finance Bank
+        "EQBL",  # Equitas Small Finance Bank
+        "UJVN",  # Ujjivan Small Finance Bank
+        "ESFB",  # ESAF Small Finance Bank
+        "SURY",  # Suryoday Small Finance Bank
+        "UTKS",  # Utkarsh Small Finance Bank
+        "JSFB",  # Jana Small Finance Bank
+        # Payments banks
+        "PYTM",  # Paytm Payments Bank
+        "AIRP",  # Airtel Payments Bank
+        "FINO",  # Fino Payments Bank
+        "NSPB",  # NSDL Payments Bank
+        "IPOS",  # India Post Payments Bank
+        "JIOP",  # Jio Payments Bank
+    }
+)

maskflow_pack_india-0.1.0/src/maskflow_pack_india/data/upi_handles.py

@@ -0,0 +1,114 @@
+"""Bundled NPCI-issued UPI PSP handles -- the part of a VPA after '@' (e.g.
+"okhdfcbank" in name@okhdfcbank). Curated, NOT exhaustive: NPCI periodically
+approves new handles for new/rebranded PSPs. A handle not in this set is
+treated as NOT a UPI VPA by validate_upi_vpa() (patterns.py) -- deliberately
+conservative, since a handle-shaped string that happens to have a TLD-like
+look (e.g. "name@company") should fall through to nothing rather than being
+misclassified.
+
+Refresh procedure:
+  1. NPCI publishes the list of live PSP handles as part of its UPI
+     "member/handle" directory at https://www.npci.org.in -- cross-referenced
+     against each PSP's own published VPA format documentation (banks list
+     their own handles on their UPI help pages).
+  2. Add any newly observed handle (lowercase, no leading '@') to
+     UPI_PSP_HANDLES below.
+  3. Do not remove a retired handle -- old VPAs using it may still appear in
+     historical text even after NPCI stops issuing new ones.
+  4. Update the "last refreshed" date in this docstring.
+
+Last refreshed: 2026-08 (manually curated from public PSP/bank documentation,
+not a direct NPCI feed import -- treat as a reasonable starting set, not a
+guarantee of completeness).
+"""
+
+from __future__ import annotations
+
+UPI_PSP_HANDLES: frozenset[str] = frozenset(
+    {
+        # Google Pay (issued per linked bank)
+        "okhdfcbank",
+        "oksbi",
+        "okaxis",
+        "okicici",
+        "okbizaxis",
+        # PhonePe / Yes Bank
+        "ybl",
+        "yapl",
+        # Paytm
+        "paytm",
+        # Generic / NPCI-operated
+        "upi",
+        # IDBI Bank (legacy handle)
+        "ibl",
+        # Axis Bank (incl. merchant handle used by several PSPs)
+        "axl",
+        "axisbank",
+        # Amazon Pay
+        "apl",
+        "rapl",  # Amazon Pay via RBL Bank
+        # Federal Bank
+        "fbl",
+        "federal",
+        # IDFC FIRST Bank
+        "idfcbank",
+        # Jupiter (via Axis Bank)
+        "jupiteraxis",
+        # Kotak Mahindra Bank
+        "kotak",
+        # Yes Bank
+        "yesbank",
+        # State Bank of India
+        "sbi",
+        # ICICI Bank
+        "icici",
+        # HDFC Bank
+        "hdfcbank",
+        # IndusInd Bank
+        "indus",
+        # Canara Bank
+        "cnrb",
+        # DBS Bank India
+        "dbs",
+        # Bank of India
+        "boi",
+        # Central Bank of India
+        "cbin",
+        "centralbank",
+        # Punjab National Bank
+        "pnb",
+        # Union Bank of India
+        "unionbankofindia",
+        "unionbank",
+        # HSBC
+        "hsbc",
+        # Indian Bank
+        "indianbank",
+        # Indian Overseas Bank
+        "iob",
+        # Karur Vysya Bank
+        "kvb",
+        # Karnataka Bank
+        "karb",
+        # Bank of Baroda
+        "barodampay",
+        "baroda",
+        # Freecharge (via Axis Bank)
+        "freecharge",
+        # MobiKwik
+        "mobikwik",
+        # Airtel Payments Bank
+        "airtel",
+        # Jio Payments Bank
+        "jio",
+        # Slice
+        "slice",
+        # Aditya Birla Finance
+        "abfspay",
+        # WhatsApp Pay (issued per linked bank, "wa" prefix)
+        "waaxis",
+        "wahdfcbank",
+        "waicici",
+        "wasbi",
+    }
+)

maskflow_pack_india-0.1.0/src/maskflow_pack_india/patterns.py

@@ -0,0 +1,144 @@
+"""Regex patterns and structural/checksum validators for India-specific PII
+types. Each validator(value) -> float | None returns an adjusted confidence,
+or None to reject the match entirely -- see checksums.py for the Verhoeff
+(AADHAAR) and GSTIN check-digit algorithms these call into. __init__.py
+registers these against maskflow-core via register_pattern().
+"""
+
+from __future__ import annotations
+
+import re
+
+from .checksums import gstin_is_valid, verhoeff_is_valid
+from .data.ifsc_bank_codes import IFSC_BANK_CODES
+from .data.upi_handles import UPI_PSP_HANDLES
+
+# ---------------------------------------------------------------------------
+# AADHAAR -- 12-digit UID, 16-digit VID, and masked display forms.
+# ---------------------------------------------------------------------------
+
+# 12 digits, never starting 0/1 (UIDAI never issues those as a first digit).
+# group(1) is the whole matched run including separators -- detection.py's
+# _scan_pattern uses group(1) as the span whenever the regex has ANY group,
+# so the outer group must span the full value, not just a sub-piece of it.
+# group(2) is the separator, backreferenced via \2 so both gaps must match
+# (both spaced, both hyphenated, or both absent -- never mixed).
+AADHAAR_RE = re.compile(r"(?<!\d)([2-9]\d{3}([ -]?)\d{4}\2\d{4})(?!\d)")
+
+# 16-digit Virtual ID (VID) -- same first-digit rule and Verhoeff checksum,
+# one more group of 4 digits than the UID form.
+AADHAAR_VID_RE = re.compile(r"(?<!\d)([2-9]\d{3}([ -]?)\d{4}\2\d{4}\2\d{4})(?!\d)")
+
+# Masked display form banks/agencies show back to a user, e.g. "XXXX XXXX
+# 9012" or "xxxxxxxx9012" -- first 8 digits replaced with a mask character
+# (X or *), last 4 digits real. Unverifiable (8 of 12 digits are gone), so
+# this is registered as its own lower-confidence, unvalidated entity type
+# rather than fed through validate_aadhaar().
+AADHAAR_MASKED_RE = re.compile(r"(?<!\w)([xX*]{4}([ -]?)[xX*]{4}\2\d{4})(?!\w)")
+
+
+def validate_aadhaar(value: str) -> float | None:
+    digits = re.sub(r"[ -]", "", value)
+    if len(digits) not in (12, 16) or not digits.isdigit():
+        return None
+    # 0.9 base leaves room for the context boost (CONTEXT_KEYWORDS in
+    # __init__.py) to reach MAX_CONFIDENCE without a checksum-valid AADHAAR
+    # ever scoring below a checksum-valid but context-free match on some
+    # other overlapping type.
+    return 0.9 if verhoeff_is_valid(digits) else None
+
+
+# ---------------------------------------------------------------------------
+# PAN -- 5 letters + 4 digits + 1 letter, 4th letter constrained to a known
+# holder-category set. No public checksum exists for the final letter.
+# ---------------------------------------------------------------------------
+
+_PAN_FOURTH_CHAR_CATEGORIES = "PCHFATBLJG"
+
+# Standalone PAN: boundaries exclude alnum neighbors on both sides, so a PAN
+# embedded directly inside a longer alnum run (e.g. a GSTIN) does NOT match
+# here -- see PAN_EMBEDDED_IN_GSTIN_RE below for that case specifically.
+PAN_RE = re.compile(r"(?<![A-Za-z0-9])[A-Z]{5}[0-9]{4}[A-Z](?![A-Za-z0-9])")
+
+# The PAN embedded in a GSTIN's characters 3-12: preceded by the 2-digit
+# state code, followed by <entity_number><'Z'><checksum>. A valid GSTIN's
+# embedded PAN also surfaces as its own PAN candidate span this way;
+# spanset.py's CONTAINS resolution (CLAUDE.md design decision #1) then picks
+# the longer, equally-validated GSTIN span over the shorter contained PAN.
+PAN_EMBEDDED_IN_GSTIN_RE = re.compile(r"(?<=\d{2})[A-Z]{5}[0-9]{4}[A-Z](?=[0-9A-Z]Z[0-9A-Z])")
+
+
+def validate_pan(value: str) -> float | None:
+    if len(value) != 10:
+        return None
+    if value[3] not in _PAN_FOURTH_CHAR_CATEGORIES:
+        return None
+    # 0.85, not higher: this is a structural check (holder-category letter
+    # only), not a checksum -- PAN's final letter has no public checksum, so
+    # this can never be as confident as a Verhoeff- or mod-97-validated span.
+    return 0.85
+
+
+# ---------------------------------------------------------------------------
+# GSTIN -- 15 chars: state code (01-38) + PAN + entity number + 'Z' + base-36
+# checksum. Reuses validate_pan() for the embedded PAN's structural check.
+# ---------------------------------------------------------------------------
+
+GSTIN_RE = re.compile(r"\b\d{2}[A-Z]{5}\d{4}[A-Z][0-9A-Z]Z[0-9A-Z]\b")
+
+_MIN_STATE_CODE = 1
+_MAX_STATE_CODE = 38
+
+
+def validate_gstin(value: str) -> float | None:
+    if len(value) != 15:
+        return None
+    if not (_MIN_STATE_CODE <= int(value[:2]) <= _MAX_STATE_CODE):
+        return None
+    if validate_pan(value[2:12]) is None:
+        return None
+    if value[13] != "Z":
+        return None
+    return 0.95 if gstin_is_valid(value) else None
+
+
+# ---------------------------------------------------------------------------
+# IFSC -- 4-letter bank code + literal '0' + 6 alnum branch code. Bank code
+# validated against a bundled, periodically-refreshed RBI code list (see
+# data/ifsc_bank_codes.py) -- there is no per-character checksum on an IFSC,
+# the bank-code lookup IS the structural check.
+# ---------------------------------------------------------------------------
+
+IFSC_RE = re.compile(r"\b[A-Z]{4}0[A-Z0-9]{6}\b")
+
+
+def validate_ifsc(value: str) -> float | None:
+    if len(value) != 11 or value[4] != "0":
+        return None
+    if value[:4] not in IFSC_BANK_CODES:
+        return None
+    return 0.9
+
+
+# ---------------------------------------------------------------------------
+# UPI_VPA -- handle@psp, PSP validated against a bundled NPCI handle list
+# (see data/upi_handles.py). The trailing `(?!\.[A-Za-z])` keeps this from
+# matching the first label of a real multi-label domain (name@gmail.com):
+# the psp group is letters-only (no dot), so on "name@gmail.com" it can only
+# ever match up to "gmail" -- the lookahead then vetoes that because a
+# dot-then-letter follows, i.e. this is actually someone's email domain, not
+# a UPI handle. A handle NOT in the bundled list is rejected here (returns
+# None) rather than guessed at, so a general-purpose EMAIL recognizer (e.g.
+# maskflow-pack-intl's) gets first claim on anything that looks like mail.
+# ---------------------------------------------------------------------------
+
+UPI_VPA_RE = re.compile(r"\b[A-Za-z0-9.\-_]{2,256}@[A-Za-z]{2,64}(?!\.[A-Za-z])\b")
+
+
+def validate_upi_vpa(value: str) -> float | None:
+    handle, _, psp = value.partition("@")
+    if not handle or not psp:
+        return None
+    if psp.lower() not in UPI_PSP_HANDLES:
+        return None
+    return 0.95

maskflow_pack_india-0.1.0/tests/conftest.py

@@ -0,0 +1,5 @@
+from maskflow_core.testing import (  # noqa: F401 -- picked up as pytest hooks by name
+    pytest_collection_modifyitems,
+    pytest_configure,
+    pytest_exception_interact,
+)