dpdp-scrub 0.0.1__py3-none-any.whl

dpdp_scrub/__init__.py

@@ -0,0 +1,23 @@
+"""dpdp-scrub: detect, validate, and redact Indian PII.
+
+Self-hosted, checksum-validated, DPDP-ready. The LLM never sees the real value;
+your systems still do.
+"""
+
+__version__ = "0.0.1"
+
+from . import validators
+from .detectors import detect
+from .scrubber import Scrubber, ScrubResult
+from .spans import Span
+from .vault import MemoryVault
+
+__all__ = [
+    "validators",
+    "detect",
+    "Scrubber",
+    "ScrubResult",
+    "MemoryVault",
+    "Span",
+    "__version__",
+]

dpdp_scrub/data.py

@@ -0,0 +1,41 @@
+"""Reference data for detectors.
+
+These are public identifiers of payment infrastructure (PSP handles), not PII.
+Community-maintainable: adding a new UPI handle is a one-line PR.
+"""
+
+# Known UPI PSP handles (the part after '@' in a VPA). Not exhaustive —
+# curated from NPCI's ecosystem. The handle list is what separates a UPI ID
+# from an email-shaped string, so keep entries lowercase and dot-free.
+UPI_PSP_HANDLES = frozenset(
+    {
+        # PhonePe
+        "ybl", "ibl", "axl",
+        # Google Pay
+        "okaxis", "okhdfcbank", "okicici", "oksbi",
+        # Paytm
+        "paytm", "ptyes", "ptaxis", "pthdfc", "ptsbi",
+        # Amazon Pay
+        "apl", "yapl", "rapl",
+        # WhatsApp Pay
+        "waaxis", "wahdfcbank", "waicici", "wasbi",
+        # Bank / app handles
+        "upi", "sbi", "hdfcbank", "icici", "axisbank", "barodampay",
+        "fbl", "idfcbank", "indus", "kotak", "dbs", "yesbank", "rbl",
+        "aubank", "bandhan", "federal", "uboi", "cnrb", "pnb", "boi",
+        # Apps
+        "freecharge", "mobikwik", "airtel", "jio", "slice", "jupiteraxis",
+        "naviaxis", "niyoicici", "tapicici", "timecosmos", "zoicici",
+    }
+)
+
+# RTO state/UT codes for vehicle registration plates, plus the BH (Bharat)
+# series. Includes legacy codes still on the road (OR, UA, TS).
+VEHICLE_STATE_CODES = frozenset(
+    {
+        "AN", "AP", "AR", "AS", "BR", "CG", "CH", "DD", "DL", "DN", "GA",
+        "GJ", "HP", "HR", "JH", "JK", "KA", "KL", "LA", "LD", "MH", "ML",
+        "MN", "MP", "MZ", "NL", "OD", "OR", "PB", "PY", "RJ", "SK", "TN",
+        "TR", "TS", "TG", "UK", "UA", "UP", "WB",
+    }
+)

dpdp_scrub/detectors.py

@@ -0,0 +1,311 @@
+"""Text-level detection: find candidate identifiers in running text, normalize
+separators, validate with checksums, and emit typed Spans.
+
+Detection is two-stage by design:
+  1. A deliberately permissive regex finds candidates in text (spaces/hyphens
+     allowed, because humans write "2345 6789 0124").
+  2. The normalized candidate must pass the entity's validator before a Span
+     is emitted. Regex finds; checksums decide.
+
+Overlapping spans are resolved by confidence, then length (a Luhn-valid
+16-digit card beats the 12-digit Aadhaar candidate hiding inside it unless
+the Aadhaar checksum actually passes and the card's doesn't).
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Callable, NamedTuple
+
+from .data import UPI_PSP_HANDLES, VEHICLE_STATE_CODES
+from .spans import Span
+from .validators import luhn, gstin, pan, verhoeff
+
+
+def _upi_handle_known(vpa: str) -> bool:
+    return vpa.split("@", 1)[1].lower() in UPI_PSP_HANDLES
+
+
+def _vehicle_state_known(reg: str) -> bool:
+    # BH-series plates start with a 2-digit year instead of a state code.
+    return reg[:2] in VEHICLE_STATE_CODES or (reg[:2].isdigit() and reg[2:4] == "BH")
+
+
+def _always(_: str) -> bool:
+    return True
+
+
+def _digits(s: str) -> str:
+    return re.sub(r"[ \-]", "", s)
+
+
+def _upper(s: str) -> str:
+    return s.upper()
+
+
+class _Detector(NamedTuple):
+    entity: str
+    pattern: re.Pattern
+    normalize: Callable[[str], str]
+    validate: Callable[[str], bool]
+    confidence: float
+
+
+class _CtxRule(NamedTuple):
+    """Context evidence for entities without checksums. Negative dominates positive."""
+
+    positive: frozenset
+    negative: frozenset
+    boost: float = 0.30
+    penalty: float = 0.30
+    window: int = 40  # chars on each side of the span
+    # Checksummed entities set this: their own name nearby ("aadhaar") is
+    # definitive and beats distant negative words ("...pe invoice bana dena").
+    positive_first: bool = False
+
+
+_CTX_RULES: dict[str, _CtxRule] = {
+    # Even Verhoeff can be passed by luck (~10% of random 12-digit strings),
+    # so strong non-ID context must be able to sink an Aadhaar candidate
+    # below the default threshold (0.99 - 0.55 = 0.44 < 0.5).
+    "AADHAAR": _CtxRule(
+        positive=frozenset("aadhaar aadhar adhar uid uidai kyc आधार".split()),
+        negative=frozenset(
+            "order txn transaction invoice ref reference awb tracking docket "
+            "batch lot qty amount bill".split()
+        ),
+        boost=0.0,
+        penalty=0.55,
+        positive_first=True,
+    ),
+    "PHONE_IN": _CtxRule(
+        positive=frozenset(
+            "call phone mobile mob whatsapp wa contact number num no sms msg "
+            "message baat sampark helpline care फोन मोबाइल नंबर".split()
+        ),
+        negative=frozenset(
+            "order txn transaction invoice ref reference qty quantity amount "
+            "bill id account acc a/c awb tracking docket".split()
+        ),
+    ),
+    "PASSPORT_IN": _CtxRule(
+        positive=frozenset("passport पासपोर्ट visa".split()),
+        negative=frozenset("order txn invoice ref batch lot model part".split()),
+    ),
+    "VOTER_ID": _CtxRule(
+        positive=frozenset("voter epic election मतदाता".split()),
+        negative=frozenset("order txn invoice ref batch lot model part".split()),
+        boost=0.25,
+    ),
+    # The three context-REQUIRED entities: base 0.30 sits below the default
+    # threshold, so they only surface when nearby words earn it.
+    "BANK_ACCOUNT": _CtxRule(
+        positive=frozenset(
+            "a/c ac acc account accno khata bank ifsc neft rtgs imps savings "
+            "current sb ca खाता बैंक".split()
+        ),
+        negative=frozenset("order txn invoice ref awb tracking docket qty".split()),
+        boost=0.45,
+    ),
+    "EPF_UAN": _CtxRule(
+        positive=frozenset("uan pf epf epfo provident यूएएन".split()),
+        negative=frozenset(),
+        boost=0.50,
+    ),
+    "ABHA": _CtxRule(
+        positive=frozenset("abha health ayushman आभा स्वास्थ्य".split()),
+        negative=frozenset(),
+        boost=0.50,
+    ),
+}
+
+_TOKEN_RE = re.compile(r"[a-z0-9/]+|[ऀ-ॿ]+")
+
+
+def _context_adjust(text: str, start: int, end: int, entity: str, base: float) -> float:
+    rule = _CTX_RULES.get(entity)
+    if rule is None:
+        return base
+    lo, hi = max(0, start - rule.window), min(len(text), end + rule.window)
+    tokens = set(_TOKEN_RE.findall(text[lo:hi].lower()))
+    if rule.positive_first and tokens & rule.positive:
+        return min(0.99, base + rule.boost)
+    if tokens & rule.negative:
+        return max(0.0, base - rule.penalty)
+    if tokens & rule.positive:
+        return min(0.99, base + rule.boost)
+    return base
+
+
+# NOTE on lookarounds: (?<![\d]) / (?![\d]) stop us matching inside longer
+# digit runs (a 12-digit slice of a 16-digit number written without spaces).
+# Spaced collisions (card "4111 1111 1111 1111" containing an Aadhaar-shaped
+# prefix) are handled by validation + overlap resolution instead.
+
+_DETECTORS: list[_Detector] = [
+    _Detector(
+        entity="AADHAAR",
+        pattern=re.compile(r"(?<!\d)(\d{4}[ \-]?\d{4}[ \-]?\d{4})(?!\d)"),
+        normalize=_digits,
+        validate=verhoeff.validate_aadhaar,
+        confidence=0.99,  # Verhoeff-validated
+    ),
+    _Detector(
+        entity="AADHAAR_VID",
+        pattern=re.compile(r"(?<!\d)(\d{4}[ \-]?\d{4}[ \-]?\d{4}[ \-]?\d{4})(?!\d)"),
+        normalize=_digits,
+        validate=verhoeff.validate_vid,
+        confidence=0.99,
+    ),
+    _Detector(
+        entity="CREDIT_CARD",
+        pattern=re.compile(r"(?<!\d)(\d(?:[ \-]?\d){12,18})(?!\d)"),
+        normalize=_digits,
+        validate=luhn.validate_card,
+        confidence=0.95,  # Luhn is weaker than Verhoeff (10% random pass, no length lock)
+    ),
+    _Detector(
+        entity="GSTIN",
+        pattern=re.compile(
+            r"(?<![A-Za-z0-9])(\d{2}[A-Za-z]{5}\d{4}[A-Za-z][1-9A-Za-z][Zz][0-9A-Za-z])(?![A-Za-z0-9])"
+        ),
+        normalize=_upper,
+        validate=gstin.validate,
+        confidence=0.99,  # mod-36 check char + embedded PAN + state code
+    ),
+    _Detector(
+        entity="PAN",
+        pattern=re.compile(r"(?<![A-Za-z0-9])([A-Za-z]{5}\d{4}[A-Za-z])(?![A-Za-z0-9])"),
+        normalize=_upper,
+        validate=pan.validate,
+        confidence=0.85,  # structural only — PAN's check letter isn't public
+    ),
+    _Detector(
+        entity="UPI_ID",
+        # username@handle, where the handle has no dot. The PSP handle list is
+        # what separates a real VPA from an email-shaped string.
+        pattern=re.compile(r"(?<![A-Za-z0-9.@_\-])([A-Za-z0-9._\-]{2,256}@[A-Za-z]{2,64})(?![A-Za-z0-9.@])"),
+        normalize=str.lower,
+        validate=_upi_handle_known,
+        confidence=0.92,  # handle verified against known PSP list
+    ),
+    _Detector(
+        entity="EMAIL",
+        pattern=re.compile(
+            r"(?<![A-Za-z0-9.@_\-])([A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,})(?![A-Za-z0-9.@])"
+        ),
+        normalize=str.lower,
+        validate=_always,
+        confidence=0.90,
+    ),
+    _Detector(
+        entity="PHONE_IN",
+        # Indian mobile: 10 digits starting 6-9, optional +91/0 prefix.
+        # (?![\d@]) stops us flagging the phone-shaped username of a UPI VPA.
+        pattern=re.compile(r"(?<![\d])((?:\+91[ \-]?|0)?[6-9]\d{9})(?![\d@])"),
+        normalize=_digits,
+        validate=_always,
+        confidence=0.70,  # no checksum exists; context scoring will adjust later
+    ),
+    _Detector(
+        entity="IFSC",
+        # 4-letter bank code + '0' + 6-char branch code.
+        pattern=re.compile(r"(?<![A-Za-z0-9])([A-Za-z]{4}0[A-Za-z0-9]{6})(?![A-Za-z0-9])"),
+        normalize=_upper,
+        validate=_always,
+        confidence=0.80,  # structural; RBI bank-code list lands with the data files
+    ),
+    _Detector(
+        entity="VOTER_ID",
+        # EPIC: 3 letters + 7 digits.
+        pattern=re.compile(r"(?<![A-Za-z0-9])([A-Za-z]{3}\d{7})(?![A-Za-z0-9])"),
+        normalize=_upper,
+        validate=_always,
+        confidence=0.70,  # structural only; context engine will refine
+    ),
+    _Detector(
+        entity="PASSPORT_IN",
+        # 1 letter + 7 digits — deliberately conservative confidence: the
+        # shape is generic, so this one leans on the context engine most.
+        pattern=re.compile(r"(?<![A-Za-z0-9])([A-Za-z]\d{7})(?![A-Za-z0-9])"),
+        normalize=_upper,
+        validate=_always,
+        confidence=0.60,
+    ),
+    _Detector(
+        entity="BANK_ACCOUNT",
+        # 9-18 solid digits, NO checksum exists — context-required (base 0.30).
+        pattern=re.compile(r"(?<!\d)(\d{9,18})(?!\d)"),
+        normalize=_digits,
+        validate=_always,
+        confidence=0.30,
+    ),
+    _Detector(
+        entity="EPF_UAN",
+        # 12 digits, same shape as Aadhaar but no public checksum — context-required.
+        pattern=re.compile(r"(?<!\d)(\d{12})(?!\d)"),
+        normalize=_digits,
+        validate=_always,
+        confidence=0.30,
+    ),
+    _Detector(
+        entity="ABHA",
+        # 14-digit health ID, often written 91-XXXX-XXXX-XXXX — context-required.
+        pattern=re.compile(r"(?<!\d)(\d{2}[ \-]?\d{4}[ \-]?\d{4}[ \-]?\d{4})(?!\d)"),
+        normalize=_digits,
+        validate=_always,
+        confidence=0.30,
+    ),
+    _Detector(
+        entity="VEHICLE_REG",
+        # Standard: SS RR L(LL) NNNN (MH 12 AB 1234). BH series: YY BH NNNN L(L).
+        pattern=re.compile(
+            r"(?<![A-Za-z0-9])"
+            r"([A-Za-z]{2}[ \-]?\d{1,2}[ \-]?[A-Za-z]{1,3}[ \-]?\d{4}"
+            r"|\d{2}[ \-]?[Bb][Hh][ \-]?\d{4}[ \-]?[A-Za-z]{1,2})"
+            r"(?![A-Za-z0-9])"
+        ),
+        normalize=lambda s: re.sub(r"[ \-]", "", s).upper(),
+        validate=_vehicle_state_known,
+        confidence=0.85,  # state/RTO code verified against reference list
+    ),
+]
+
+
+def _resolve_overlaps(spans: list[Span]) -> list[Span]:
+    """Greedy resolution: highest confidence wins, then longest, then leftmost."""
+    ordered = sorted(spans, key=lambda s: (-s.confidence, -len(s), s.start))
+    kept: list[Span] = []
+    for span in ordered:
+        if not any(span.overlaps(k) for k in kept):
+            kept.append(span)
+    return sorted(kept, key=lambda s: s.start)
+
+
+def detect(text: str, min_confidence: float = 0.5) -> list[Span]:
+    """Detect validated PII spans in `text`, sorted by position.
+
+    `min_confidence` is the recall-vs-precision dial: context-required
+    entities (bank account, UAN, ABHA) start below the default threshold
+    and only surface when nearby words earn them a boost.
+    """
+    candidates: list[Span] = []
+    for det in _DETECTORS:
+        for m in det.pattern.finditer(text):
+            raw = m.group(1)
+            normalized = det.normalize(raw)
+            if not det.validate(normalized):
+                continue
+            conf = _context_adjust(text, m.start(1), m.end(1), det.entity, det.confidence)
+            if conf >= min_confidence:
+                candidates.append(
+                    Span(
+                        entity=det.entity,
+                        start=m.start(1),
+                        end=m.end(1),
+                        raw=raw,
+                        normalized=normalized,
+                        confidence=conf,
+                    )
+                )
+    return _resolve_overlaps(candidates)

dpdp_scrub/integrations.py

@@ -0,0 +1,73 @@
+"""Framework adapters. v1: LiteLLM.
+
+Usage (LiteLLM proxy config.yaml):
+    litellm_settings:
+      callbacks: dpdp_scrub.integrations.litellm_scrub_hook
+
+Or in code:
+    import litellm
+    from dpdp_scrub.integrations import LiteLLMScrubHook
+    litellm.callbacks = [LiteLLMScrubHook()]
+
+Every outbound message is scrubbed before the provider sees it; successful
+responses are rehydrated on the way back (same session, keyed by call id or
+metadata["dpdp_session"]).
+"""
+
+from __future__ import annotations
+
+import uuid
+
+from .scrubber import Scrubber
+
+try:  # litellm is optional; the hook class degrades to a plain object base.
+    from litellm.integrations.custom_logger import CustomLogger as _Base
+except ImportError:  # pragma: no cover
+    _Base = object
+
+
+class LiteLLMScrubHook(_Base):
+    """LiteLLM CustomLogger that scrubs prompts and rehydrates responses."""
+
+    def __init__(self, scrubber: Scrubber | None = None, rehydrate_responses: bool = True):
+        self.scrubber = scrubber or Scrubber()
+        self.rehydrate_responses = rehydrate_responses
+
+    def _session(self, data: dict) -> str:
+        meta = data.setdefault("metadata", {}) if isinstance(data, dict) else {}
+        if "dpdp_session" not in meta:
+            meta["dpdp_session"] = data.get("litellm_call_id") or uuid.uuid4().hex
+        return meta["dpdp_session"]
+
+    def scrub_request(self, data: dict) -> dict:
+        """Scrub every string message content in a completion request dict."""
+        session = self._session(data)
+        for msg in data.get("messages", []) or []:
+            content = msg.get("content")
+            if isinstance(content, str):
+                msg["content"] = self.scrubber.scrub(content, session_id=session).text
+        return data
+
+    def rehydrate_response(self, data: dict, response) -> None:
+        """Rehydrate placeholder text in a ModelResponse, in place."""
+        session = self._session(data)
+        try:
+            for choice in getattr(response, "choices", []) or []:
+                message = getattr(choice, "message", None)
+                if message is not None and isinstance(getattr(message, "content", None), str):
+                    message.content = self.scrubber.rehydrate(message.content, session)
+        except Exception:  # never let privacy plumbing break the response path
+            pass
+
+    # --- LiteLLM proxy hook surface ---
+
+    async def async_pre_call_hook(self, user_api_key_dict, cache, data, call_type):  # noqa: D401
+        return self.scrub_request(data)
+
+    async def async_post_call_success_hook(self, data, user_api_key_dict, response):
+        if self.rehydrate_responses:
+            self.rehydrate_response(data, response)
+        return response
+
+
+litellm_scrub_hook = LiteLLMScrubHook()

dpdp_scrub/policies.py

@@ -0,0 +1,27 @@
+"""Named policy profiles — compliance goals expressed as per-entity actions.
+
+Users think "make this DPDP-safe", not "tokenize entity #7". A profile is a
+dict of action overrides applied on top of DEFAULT_ACTIONS; "__all__" sets a
+baseline for every entity first.
+"""
+
+from __future__ import annotations
+
+PROFILES: dict[str, dict[str, str]] = {
+    # The default: reversible tokens, UIDAI/RBI-format masks, ABHA redacted.
+    "dpdp-strict": {},
+    # Detect and audit-log everything, change nothing. The zero-risk first
+    # week of a rollout: turn it on, read the report, then tighten.
+    "audit-only": {"__all__": "ignore"},
+    # Only the identifiers with an existing legal masking mandate; the rest
+    # pass through. For teams that need Aadhaar/card hygiene and nothing else.
+    "uidai-mask": {
+        "__all__": "ignore",
+        "AADHAAR": "mask",
+        "AADHAAR_VID": "mask",
+        "CREDIT_CARD": "mask",
+    },
+    # Nothing survives, nothing is reversible. For datasets leaving forever
+    # (fine-tuning exports, data shares).
+    "max-redact": {"__all__": "redact"},
+}

dpdp_scrub/scrubber.py

@@ -0,0 +1,158 @@
+"""The scrub -> LLM -> rehydrate loop.
+
+  scrub():     replace detected PII with placeholders (tokenize), partial
+               masks (mask), or removal (redact), per entity policy.
+  rehydrate(): swap placeholders back to real values — only ever called on
+               authorized surfaces, inside the adopter's boundary.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import time
+import uuid
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from .detectors import detect
+from .policies import PROFILES
+from .spans import Span
+from .vault import MemoryVault
+
+# Per-entity default actions. "mask" keeps a legally-sanctioned partial view
+# (UIDAI's own masked-Aadhaar format; RBI-style last-4 for cards); everything
+# else tokenizes reversibly via the vault.
+DEFAULT_ACTIONS: dict[str, str] = {
+    "AADHAAR": "mask",
+    "AADHAAR_VID": "mask",
+    "CREDIT_CARD": "mask",
+    "PAN": "tokenize",
+    "GSTIN": "tokenize",
+    "UPI_ID": "tokenize",
+    "EMAIL": "tokenize",
+    "PHONE_IN": "tokenize",
+    "IFSC": "tokenize",
+    "VOTER_ID": "tokenize",
+    "PASSPORT_IN": "tokenize",
+    "VEHICLE_REG": "tokenize",
+    "BANK_ACCOUNT": "tokenize",
+    "EPF_UAN": "tokenize",
+    "ABHA": "redact",  # health IDs: highest sensitivity, no partial view
+}
+
+_PLACEHOLDER_RE = re.compile(r"<[A-Z_]+_\d+>")
+
+
+def _mask(entity: str, normalized: str) -> str:
+    if entity in ("AADHAAR", "AADHAAR_VID"):
+        # UIDAI masked-Aadhaar format: only the last 4 digits visible.
+        return "XXXX XXXX " + normalized[-4:]
+    if entity == "CREDIT_CARD":
+        return "X" * (len(normalized) - 4) + normalized[-4:]
+    # Generic fallback: keep last 4.
+    return "X" * max(0, len(normalized) - 4) + normalized[-4:]
+
+
+@dataclass
+class ScrubResult:
+    text: str
+    spans: list[Span]
+    session_id: str
+    original: str = field(repr=False, default="")
+
+
+class Scrubber:
+    """Detects and transforms Indian PII; holds the vault for rehydration."""
+
+    def __init__(
+        self,
+        policy: str = "dpdp-strict",
+        actions: dict[str, str] | None = None,
+        vault: MemoryVault | None = None,
+        min_confidence: float = 0.5,
+        audit_log: str | Path | None = None,
+    ) -> None:
+        if policy not in PROFILES:
+            raise ValueError(f"unknown policy {policy!r}; available: {sorted(PROFILES)}")
+        profile = dict(PROFILES[policy])
+        baseline = profile.pop("__all__", None)
+        merged = (
+            {e: baseline for e in DEFAULT_ACTIONS} if baseline else dict(DEFAULT_ACTIONS)
+        )
+        merged.update(profile)
+        merged.update(actions or {})
+        self.policy = policy
+        self.actions = merged
+        self.vault = vault or MemoryVault()
+        self.min_confidence = min_confidence
+        self.audit_log = Path(audit_log) if audit_log else None
+
+    def _audit(self, session_id: str, spans: list[Span]) -> None:
+        """Append one JSONL line per detection. Never logs raw values."""
+        if self.audit_log is None or not spans:
+            return
+        with self.audit_log.open("a", encoding="utf-8") as f:
+            for s in spans:
+                f.write(
+                    json.dumps(
+                        {
+                            "ts": time.strftime("%Y-%m-%dT%H:%M:%S%z"),
+                            "session": session_id,
+                            "entity": s.entity,
+                            "action": self.actions.get(s.entity, "tokenize"),
+                            "confidence": round(s.confidence, 2),
+                            "start": s.start,
+                            "end": s.end,
+                            "policy": self.policy,
+                        }
+                    )
+                    + "\n"
+                )
+
+    def scrub(self, text: str, session_id: str | None = None) -> ScrubResult:
+        session_id = session_id or uuid.uuid4().hex
+        spans = detect(text, min_confidence=self.min_confidence)
+        out = text
+        # Replace right-to-left so earlier offsets stay valid.
+        for s in sorted(spans, key=lambda x: -x.start):
+            action = self.actions.get(s.entity, "tokenize")
+            if action == "ignore":
+                continue
+            if action == "redact":
+                replacement = f"[{s.entity} REDACTED]"
+            elif action == "mask":
+                replacement = _mask(s.entity, s.normalized)
+            else:  # tokenize
+                replacement = self.vault.placeholder_for(session_id, s.entity, s.normalized)
+            out = out[: s.start] + replacement + out[s.end :]
+        self._audit(session_id, spans)
+        return ScrubResult(text=out, spans=spans, session_id=session_id, original=text)
+
+    def scrub_json(self, payload, session_id: str | None = None):
+        """Recursively scrub every string value in a dict/list payload.
+
+        Keys are left untouched; only values are scrubbed. Returns
+        (scrubbed_payload, session_id) so multi-field payloads share one vault
+        session and placeholder numbering stays consistent across fields.
+        """
+        session_id = session_id or uuid.uuid4().hex
+
+        def _walk(node):
+            if isinstance(node, str):
+                return self.scrub(node, session_id=session_id).text
+            if isinstance(node, dict):
+                return {k: _walk(v) for k, v in node.items()}
+            if isinstance(node, list):
+                return [_walk(v) for v in node]
+            return node
+
+        return _walk(payload), session_id
+
+    def rehydrate(self, text: str, session_id: str) -> str:
+        """Swap placeholders back to real values (authorized surfaces only)."""
+
+        def _sub(m: re.Match) -> str:
+            return self.vault.resolve(session_id, m.group(0)) or m.group(0)
+
+        return _PLACEHOLDER_RE.sub(_sub, text)

dpdp_scrub/spans.py

@@ -0,0 +1,29 @@
+"""The typed span — the unit of output for every detector."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Span:
+    """A detected PII occurrence in the original text.
+
+    `start`/`end` index the ORIGINAL text (end exclusive), so callers can
+    slice, replace, or highlight without re-searching. `raw` is the exact
+    matched substring including separators; `normalized` is the cleaned
+    value that passed validation (digits/uppercase only).
+    """
+
+    entity: str
+    start: int
+    end: int
+    raw: str
+    normalized: str
+    confidence: float
+
+    def __len__(self) -> int:
+        return self.end - self.start
+
+    def overlaps(self, other: "Span") -> bool:
+        return self.start < other.end and other.start < self.end

dpdp_scrub/validators/__init__.py

@@ -0,0 +1,28 @@
+"""Checksum and structural validators for Indian identifiers.
+
+These are pure functions with zero dependencies — the trust foundation of
+dpdp-scrub. Every detector consults its validator before flagging a span.
+"""
+
+from .verhoeff import validate_aadhaar, validate_vid
+from .verhoeff import validate as validate_verhoeff
+from .verhoeff import generate_check_digit as verhoeff_check_digit
+from .luhn import validate_card
+from .luhn import validate as validate_luhn
+from .gstin import validate as validate_gstin
+from .gstin import check_character as gstin_check_character
+from .pan import validate as validate_pan
+from .pan import holder_type as pan_holder_type
+
+__all__ = [
+    "validate_aadhaar",
+    "validate_vid",
+    "validate_verhoeff",
+    "verhoeff_check_digit",
+    "validate_card",
+    "validate_luhn",
+    "validate_gstin",
+    "gstin_check_character",
+    "validate_pan",
+    "pan_holder_type",
+]

dpdp_scrub/validators/gstin.py

@@ -0,0 +1,48 @@
+"""GSTIN validation — 15-character Goods and Services Tax Identification Number.
+
+Structure: SSPPPPPPPPPPENZ C
+  - chars 1-2  (SS): state code, 01-38 (or 97 for "other territory" / 99 for centre jurisdiction)
+  - chars 3-12 (P*): the holder's PAN
+  - char  13   (E) : entity/registration number within the state (1-9, A-Z)
+  - char  14   (N) : 'Z' by default (reserved)
+  - char  15   (C) : mod-36 check character (public algorithm)
+
+The embedded PAN plus the check character makes GSTIN one of the most
+validate-able identifiers in the catalog.
+"""
+
+from __future__ import annotations
+
+import re
+
+from . import pan as _pan
+
+_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+# 01-38 are states/UTs; 97 = other territory, 99 = centre jurisdiction.
+_VALID_STATE_CODES = {f"{i:02d}" for i in range(1, 39)} | {"97", "99"}
+
+_GSTIN_RE = re.compile(r"^\d{2}[A-Z]{5}\d{4}[A-Z][1-9A-Z]Z[0-9A-Z]$")
+
+
+def check_character(gstin14: str) -> str:
+    """Compute the mod-36 check character for the first 14 characters of a GSTIN."""
+    total = 0
+    for i, ch in enumerate(gstin14):
+        code = _CHARS.index(ch)
+        factor = 2 if i % 2 == 1 else 1
+        addend = factor * code
+        total += addend // 36 + addend % 36
+    return _CHARS[(36 - total % 36) % 36]
+
+
+def validate(gstin: str) -> bool:
+    """Full GSTIN validation: format + state code + embedded PAN structure + checksum."""
+    gstin = gstin.upper()
+    if not _GSTIN_RE.match(gstin):
+        return False
+    if gstin[:2] not in _VALID_STATE_CODES:
+        return False
+    if not _pan.validate(gstin[2:12]):
+        return False
+    return check_character(gstin[:14]) == gstin[14]

dpdp_scrub/validators/luhn.py

@@ -0,0 +1,31 @@
+"""Luhn checksum — used by payment card numbers (13-19 digits).
+
+RBI card-masking policy relies on knowing a digit run really is a card number;
+Luhn validation is the first gate before any card span is flagged.
+"""
+
+from __future__ import annotations
+
+
+def validate(number: str) -> bool:
+    """Return True if `number` (digits only) passes the Luhn checksum."""
+    if not number.isdigit():
+        return False
+    total = 0
+    # Double every second digit from the right (excluding the check digit).
+    for i, digit in enumerate(reversed(number)):
+        d = int(digit)
+        if i % 2 == 1:
+            d *= 2
+            if d > 9:
+                d -= 9
+        total += d
+    return total % 10 == 0
+
+
+def validate_card(number: str) -> bool:
+    """Validate a payment card number: 13-19 digits, Luhn-valid.
+
+    Accepts digits only — strip spaces/hyphens before calling.
+    """
+    return 13 <= len(number) <= 19 and validate(number)

dpdp_scrub/validators/pan.py

@@ -0,0 +1,47 @@
+"""PAN (Permanent Account Number) structural validation.
+
+Format: AAAHT1234C
+  - chars 1-3: alphabetic series (A-Z)
+  - char  4  : holder type — P (person), C (company), H (HUF), F (firm), A (AOP),
+               T (trust), B (BOI), L (local authority), J (artificial juridical
+               person), G (government)
+  - char  5  : first letter of holder's surname (individuals) or entity name
+  - chars 6-9: sequential digits
+  - char  10 : alphabetic check letter (algorithm not publicly documented, so we
+               validate structure only)
+
+The 4th-character holder-type rule rejects ~62% of random 5-letter prefixes that
+a bare [A-Z]{5}\\d{4}[A-Z] regex would accept.
+"""
+
+from __future__ import annotations
+
+import re
+
+_PAN_RE = re.compile(r"^[A-Z]{3}[PCHFATBLJG][A-Z]\d{4}[A-Z]$")
+
+_HOLDER_TYPES = {
+    "P": "person",
+    "C": "company",
+    "H": "hindu_undivided_family",
+    "F": "firm",
+    "A": "association_of_persons",
+    "T": "trust",
+    "B": "body_of_individuals",
+    "L": "local_authority",
+    "J": "artificial_juridical_person",
+    "G": "government",
+}
+
+
+def validate(pan: str) -> bool:
+    """Return True if `pan` is structurally a valid PAN (incl. holder-type rule)."""
+    return bool(_PAN_RE.match(pan.upper()))
+
+
+def holder_type(pan: str) -> str | None:
+    """Return the holder type encoded in a valid PAN's 4th character, else None."""
+    pan = pan.upper()
+    if not validate(pan):
+        return None
+    return _HOLDER_TYPES[pan[3]]

dpdp_scrub/validators/verhoeff.py

@@ -0,0 +1,71 @@
+"""Verhoeff checksum — used by UIDAI for Aadhaar (12 digits) and Virtual ID (16 digits).
+
+The Verhoeff scheme catches all single-digit errors and adjacent transpositions,
+which is why a random 12-digit number has only a ~10% chance of passing. Combined
+with the first-digit rule (Aadhaar never starts with 0 or 1), this kills the vast
+majority of false positives from order IDs, invoice numbers, etc.
+"""
+
+from __future__ import annotations
+
+# Dihedral group D5 multiplication table
+_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),
+)
+
+# Permutation table
+_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),
+)
+
+# Multiplicative inverse table
+_INV = (0, 4, 3, 2, 1, 5, 6, 7, 8, 9)
+
+
+def validate(number: str) -> bool:
+    """Return True if `number` (digits only) passes the Verhoeff checksum."""
+    if not number.isdigit():
+        return False
+    c = 0
+    for i, digit in enumerate(reversed(number)):
+        c = _D[c][_P[i % 8][int(digit)]]
+    return c == 0
+
+
+def generate_check_digit(number: str) -> str:
+    """Return the Verhoeff check digit for `number` (digits only, without check digit)."""
+    if not number.isdigit():
+        raise ValueError("Verhoeff check digit requires a numeric string")
+    c = 0
+    for i, digit in enumerate(reversed(number)):
+        c = _D[c][_P[(i + 1) % 8][int(digit)]]
+    return str(_INV[c])
+
+
+def validate_aadhaar(number: str) -> bool:
+    """Validate an Aadhaar number: 12 digits, first digit 2-9, Verhoeff-valid.
+
+    Accepts digits only — strip spaces/hyphens before calling.
+    """
+    return len(number) == 12 and number[0] not in "01" and validate(number)
+
+
+def validate_vid(number: str) -> bool:
+    """Validate an Aadhaar Virtual ID: 16 digits, first digit 2-9, Verhoeff-valid."""
+    return len(number) == 16 and number[0] not in "01" and validate(number)

dpdp_scrub/vault.py

@@ -0,0 +1,94 @@
+"""Session-scoped placeholder vault.
+
+The vault is Ring 0 of the trust model: it maps <ENTITY_n> placeholders back
+to real values, per session, inside the adopter's own infrastructure. This
+module ships the in-memory backend; the interface is deliberately tiny so a
+Redis/KMS backend is a drop-in (v1.5).
+"""
+
+from __future__ import annotations
+
+
+class MemoryVault:
+    """In-memory vault — for development and single-process apps.
+
+    Guarantees within a session:
+      - the same value always gets the same placeholder (multi-turn consistency)
+      - placeholders are numbered per entity type: <PHONE_IN_1>, <PHONE_IN_2>...
+    """
+
+    def __init__(self) -> None:
+        # session_id -> {placeholder -> value}
+        self._forward: dict[str, dict[str, str]] = {}
+        # session_id -> {(entity, value) -> placeholder}
+        self._reverse: dict[str, dict[tuple, str]] = {}
+
+    def placeholder_for(self, session_id: str, entity: str, value: str) -> str:
+        """Return the stable placeholder for `value`, minting one if new."""
+        fwd = self._forward.setdefault(session_id, {})
+        rev = self._reverse.setdefault(session_id, {})
+        key = (entity, value)
+        if key in rev:
+            return rev[key]
+        n = sum(1 for (e, _) in rev if e == entity) + 1
+        placeholder = f"<{entity}_{n}>"
+        rev[key] = placeholder
+        fwd[placeholder] = value
+        return placeholder
+
+    def resolve(self, session_id: str, placeholder: str) -> str | None:
+        """Resolve one placeholder back to its real value (None if unknown)."""
+        return self._forward.get(session_id, {}).get(placeholder)
+
+    def mappings(self, session_id: str) -> dict[str, str]:
+        """All placeholder->value mappings for a session (for authorized surfaces)."""
+        return dict(self._forward.get(session_id, {}))
+
+    def drop(self, session_id: str) -> None:
+        """Forget a session — after this, its placeholders are unresolvable forever."""
+        self._forward.pop(session_id, None)
+        self._reverse.pop(session_id, None)
+
+
+class RedisVault:
+    """Redis-backed vault: shared across processes/VMs inside your boundary.
+
+    Same interface as MemoryVault. Keys are namespaced `dpdp:*:{session}` and
+    every write refreshes the session TTL — expired sessions become
+    permanently unresolvable (retroactive redaction).
+
+    Requires `redis` (pip install redis) unless a client is injected.
+    """
+
+    def __init__(self, url: str = "redis://localhost:6379", ttl: int = 86400, client=None):
+        if client is None:
+            import redis  # lazy: optional dependency
+
+            client = redis.Redis.from_url(url, decode_responses=True)
+        self.r = client
+        self.ttl = ttl
+
+    def _keys(self, session_id: str) -> tuple[str, str, str]:
+        return (f"dpdp:fwd:{session_id}", f"dpdp:rev:{session_id}", f"dpdp:cnt:{session_id}")
+
+    def placeholder_for(self, session_id: str, entity: str, value: str) -> str:
+        fwd, rev, cnt = self._keys(session_id)
+        existing = self.r.hget(rev, f"{entity}|{value}")
+        if existing:
+            return existing
+        n = self.r.hincrby(cnt, entity, 1)
+        placeholder = f"<{entity}_{n}>"
+        self.r.hset(rev, f"{entity}|{value}", placeholder)
+        self.r.hset(fwd, placeholder, value)
+        for k in (fwd, rev, cnt):
+            self.r.expire(k, self.ttl)
+        return placeholder
+
+    def resolve(self, session_id: str, placeholder: str):
+        return self.r.hget(self._keys(session_id)[0], placeholder)
+
+    def mappings(self, session_id: str) -> dict:
+        return self.r.hgetall(self._keys(session_id)[0])
+
+    def drop(self, session_id: str) -> None:
+        self.r.delete(*self._keys(session_id))

dpdp_scrub-0.0.1.dist-info/METADATA

@@ -0,0 +1,164 @@
+Metadata-Version: 2.4
+Name: dpdp-scrub
+Version: 0.0.1
+Summary: Detect, validate, and redact Indian PII (Aadhaar, PAN, GSTIN, UPI, and more) — self-hosted, checksum-validated, DPDP-ready.
+Author: Palkush Dave
+License: MIT
+Keywords: pii,dpdp,aadhaar,pan,gstin,privacy,redaction,india
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security
+Classifier: Topic :: Text Processing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"
+Requires-Dist: mypy>=1.10; extra == "dev"
+Dynamic: license-file
+
+# dpdp-scrub
+
+**Detect, validate, and redact Indian PII before it reaches an LLM — self-hosted, checksum-validated, DPDP-ready.**
+
+Your org keeps the keys; the LLM gets the placeholders.
+
+```
+IN  : Sir aadhaar 2345 6789 0124 hai, call karo 9876543210 pe, PAN ABCPE1234F
+LLM : Sir aadhaar XXXX XXXX 0124 hai, call karo <PHONE_IN_1> pe, PAN <PAN_1>
+BACK: Done! 9876543210 pe call schedule ho gaya.        ← rehydrated, agent-side
+```
+
+## Why this exists
+
+Every Indian company wiring LLMs into support, sales, and ops is streaming
+Aadhaar numbers, PANs, GSTINs, UPI IDs, and phone numbers to third-party model
+providers — and copying them into logs, vector DBs, and fine-tuning sets.
+The DPDP Act's substantive obligations become enforceable in **May 2027**
+(penalties up to ₹250 crore); UIDAI's Aadhaar-masking rules and RBI's card
+rules already apply.
+
+The redaction loop itself is well-established engineering (Presidio, Google
+DLP). What didn't exist is **eyes that can see Indian PII** — validated,
+context-aware, and open. Google Cloud DLP ships 3 Indian infoTypes, AWS
+Comprehend 4, Presidio 6. dpdp-scrub detects **15**, most with mathematical
+or reference-data validation:
+
+| Entity | Validation |
+|---|---|
+| Aadhaar / Aadhaar VID | **Verhoeff checksum** + first-digit rule |
+| GSTIN | **mod-36 check character** + embedded-PAN structure + state code |
+| Credit/debit card | **Luhn checksum** |
+| PAN | holder-type structure rule |
+| UPI ID | handle verified against **known PSP list** (`@ybl`, `@oksbi`, …) |
+| IFSC, phone, email, voter ID, passport | structural + context scoring |
+| Vehicle registration | state/RTO code verified against reference list (incl. BH series) |
+| Bank account, EPF UAN, ABHA | **context-required** (surface only with evidence like "A/c", "UAN") |
+
+The context engine is what separates a phone number from an order ID:
+
+```
+order 9876543210 ka status batao   →  nothing        (suppressed by "order")
+call karo 9876543210 pe            →  PHONE_IN 0.99  (boosted by "call")
+mera a/c 34512345678901 hai        →  BANK_ACCOUNT   (earned by "a/c")
+code 34512345678901 likha hai      →  nothing
+```
+
+## Quick start
+
+```python
+from dpdp_scrub import Scrubber
+
+s = Scrubber()
+
+result = s.scrub("mera PAN ABCPE1234F hai, call 9876543210", session_id="ticket-42")
+result.text    # "mera PAN <PAN_1> hai, call <PHONE_IN_1>"
+result.spans   # typed spans: entity, offsets, confidence
+
+reply = call_your_llm(result.text)          # provider never sees real values
+s.rehydrate(reply, "ticket-42")             # real values restored, your side only
+```
+
+Detection only:
+
+```python
+from dpdp_scrub import detect
+detect("payment 9876543210@ybl pe karo")
+# [Span(entity='UPI_ID', start=8, end=22, ..., confidence=0.92)]
+```
+
+Zero runtime dependencies. Python 3.9+.
+
+## Trust model
+
+```
+Ring 0: the vault (your Redis/memory)   — real values, session-scoped, droppable
+Ring 1: your org's services             — placeholders + scoped right to resolve
+Ring 2: LLM providers, logs, vector DBs — placeholders only, no resolution path
+```
+
+- Same value → same placeholder within a session (multi-turn consistency).
+- `vault.drop(session)` makes every old copy of its placeholders permanently
+  unresolvable — retroactive redaction for logs you already wrote.
+- No cloud, no telemetry, no phoning home. This is a library, not a service:
+  **your data never leaves your infrastructure.**
+
+Per-entity actions are policy: `tokenize` (reversible), `mask` (UIDAI-format
+`XXXX XXXX 0124` for Aadhaar, last-4 for cards), `redact` (ABHA health IDs by
+default), `ignore`.
+
+## Benchmark
+
+IndicPII-Bench v0 (in `bench/`): 500 synthetic messages — Hinglish, English,
+Devanagari, OCR-noise spacing, multi-entity — with 20% traps (order IDs,
+invoice refs, phones-in-txn-context). Presidio runs at its best
+configuration — its IN_* recognizers explicitly registered (they are shipped
+but **not loaded by default**). F1, value-level matching:
+
+| entity | dpdp-scrub | presidio |
+|---|---|---|
+| AADHAAR | **1.000** | 1.000 |
+| GSTIN | **1.000** | 0.971 |
+| PAN | **1.000** | 0.383 |
+| PHONE_IN | **1.000** | 0.602 |
+| UPI_ID | **1.000** | 0.000 |
+| IFSC | **1.000** | 0.000 |
+| EMAIL | **1.000** | 1.000 |
+| **OVERALL** | **1.000** | 0.595 |
+| trap false positives | **0/100** | 200/100 |
+
+Honest caveats: this is our own v0 corpus (templated, synthetic, Hinglish-
+heavy) — a perfect self-score mainly means the corpus is still too easy, and
+it will get harder (Devanagari, OCR noise, multi-entity). Presidio was not
+built for code-mixed text; the 107 trap FPs come from it having no context
+suppression (e.g. any 10-digit number near "txn" flags as phone). Reproduce:
+`python3 bench/compare.py 500`.
+
+## Status
+
+Pre-alpha, moving fast. Built so far: 15 entities, checksum validators,
+context-scoring engine, scrub/rehydrate loop with session vault — 86 tests,
+all synthetic data. Roadmap:
+
+- [ ] YAML policy profiles (`dpdp-strict`, `uidai-mask`, `audit-only`) + audit log
+- [ ] `scrub_json()` for structured payloads
+- [ ] Redis vault backend
+- [ ] LiteLLM / LangChain / Presidio adapters
+- [ ] **IndicPII-Bench** — a public benchmark for Indian PII detection
+- [ ] Indic-script & code-mixed NER for names/addresses (AI4Bharat IndicNER)
+
+## Contributing
+
+The reference-data files are designed for one-line PRs: new UPI PSP handles,
+RTO codes, context words (English/Hindi/regional). Entity requests welcome —
+include format, any checksum, and public documentation.
+
+All test data must be synthetic (checksum-generated) or published samples.
+Never commit real PII, including your own.
+
+## License
+
+MIT

dpdp_scrub-0.0.1.dist-info/RECORD

@@ -0,0 +1,18 @@
+dpdp_scrub/__init__.py,sha256=0T-0xwvdAVIGBCpvo4jJsiZJ13HXiH-xo2tOsA--ULw,474
+dpdp_scrub/data.py,sha256=1lgU0gZBosNpUpWlMQhlh4tzefJ9ggzG8ElXbfXBQ-Y,1623
+dpdp_scrub/detectors.py,sha256=mpbOkzsaqjtCuDB7xIZhgl3jkPtOgr8AxBZCwQRJBmw,11477
+dpdp_scrub/integrations.py,sha256=HcdfwL25FmPUoa4MoUss_1cqSXm1_YBMyKe-Em60IVg,2771
+dpdp_scrub/policies.py,sha256=_0Ri-Aanpob0Tv1nBMSz5GhohFAYjodnCVocy07JRhA,1092
+dpdp_scrub/scrubber.py,sha256=l1LI1K3yPiQtaJUNNSQ1fl29cKlgBtzY6URzbWredkk,5835
+dpdp_scrub/spans.py,sha256=Fb-FpSjWQodee8ojqMS4IZdSOlrnIya2nYmp85WslGc,796
+dpdp_scrub/vault.py,sha256=SAi_dMbMmTUiY94nLSXOu91LKVV-Vzn_N9pJVLJgByI,3741
+dpdp_scrub/validators/__init__.py,sha256=6i-LgwVTCpY-aewSzbSKD_uu_3HBSISoa-97Xwqhizg,910
+dpdp_scrub/validators/gstin.py,sha256=1g7JSjCSAdm7ZL8-_SLL896rT-J9xFLHqAKuALpLESo,1644
+dpdp_scrub/validators/luhn.py,sha256=HmMm2vTT-0ZfFWH2A7Sn3zE2ebi18R3smliFnbyw-XI,946
+dpdp_scrub/validators/pan.py,sha256=ew3FLmUlt6SdBOoVq_bcaftoul8IupzSVD3ctAunzJg,1473
+dpdp_scrub/validators/verhoeff.py,sha256=GQUrQqNI7OOriPZhdHm5bZYiO9H-1B1a7pxx4OKqNck,2375
+dpdp_scrub-0.0.1.dist-info/licenses/LICENSE,sha256=Fp2GhwIZEQFhUP1MpwzNmF_4I84jgX54mRFu5L7mQVI,1080
+dpdp_scrub-0.0.1.dist-info/METADATA,sha256=RO_akrpTIxOxDuZ9OJfHxG7iF5tKpSt8G3Q2SctPAcI,6437
+dpdp_scrub-0.0.1.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+dpdp_scrub-0.0.1.dist-info/top_level.txt,sha256=0ZIhxqrTZ1Q4xdhcWEF2nEWkcPSQAMAF9cxAnDJgyvQ,11
+dpdp_scrub-0.0.1.dist-info/RECORD,,

dpdp_scrub-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dpdp_scrub-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dpdp-scrub contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dpdp_scrub-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+dpdp_scrub