maskflow-core 0.1.0__py3-none-any.whl

maskflow_core/__init__.py

@@ -0,0 +1,5 @@
+from .detection import detect
+from .entities import Finding, PIIType
+from .masking import MaskResult, mask, unmask
+
+__all__ = ["detect", "mask", "unmask", "Finding", "PIIType", "MaskResult"]

maskflow_core/context.py

@@ -0,0 +1,36 @@
+"""Keyword-proximity confidence boosting.
+
+Structural matches (email, credit card w/ Luhn, AWS keys, ...) are already
+high-confidence on their own. Ambiguous matches (a bare 9-digit number, a
+street-shaped line of text) need a nearby keyword to be trusted.
+"""
+from .entities import PIIType
+
+WINDOW = 40
+
+CONTEXT_KEYWORDS: dict[PIIType, tuple[str, ...]] = {
+    PIIType.SSN: ("ssn", "social security"),
+    PIIType.DATE_OF_BIRTH: ("dob", "date of birth", "born on", "birthdate"),
+    PIIType.ADDRESS: ("address", "lives at", "located at", "ship to", "mailing"),
+    PIIType.API_KEY: ("api key", "apikey", "secret", "token", "credential"),
+    PIIType.PHONE: ("phone", "call", "tel", "mobile", "cell", "contact"),
+    PIIType.CREDIT_CARD: ("card number", "credit card", "visa", "mastercard", "cc#"),
+    PIIType.PERSON_NAME: ("name is", "name:", "my name", "signed", "regards"),
+}
+
+BOOST = 0.4
+MAX_CONFIDENCE = 0.99
+
+
+def apply_context_boost(text: str, start: int, end: int, pii_type: PIIType, base_confidence: float) -> float:
+    keywords = CONTEXT_KEYWORDS.get(pii_type)
+    if not keywords:
+        return base_confidence
+
+    window_start = max(0, start - WINDOW)
+    window_end = min(len(text), end + WINDOW)
+    nearby = text[window_start:start].lower() + " " + text[end:window_end].lower()
+
+    if any(keyword in nearby for keyword in keywords):
+        return min(MAX_CONFIDENCE, base_confidence + BOOST)
+    return base_confidence

maskflow_core/detection.py

@@ -0,0 +1,55 @@
+"""Orchestrates the regex, context, and NER passes into one deduplicated finding list."""
+from .context import apply_context_boost
+from .entities import Finding, PIIType
+from .ner import detect_ner
+from .patterns import PATTERNS
+
+DEFAULT_MIN_CONFIDENCE = 0.5
+
+
+def _regex_pass(text: str) -> list[Finding]:
+    candidates: list[Finding] = []
+
+    for pii_type, rules in PATTERNS.items():
+        for regex, base_confidence, validator in rules:
+            for match in regex.finditer(text):
+                if match.re.groups:
+                    start, end = match.span(1)
+                    value = match.group(1)
+                else:
+                    start, end = match.span(0)
+                    value = match.group(0)
+
+                confidence = base_confidence
+                if validator is not None:
+                    adjusted = validator(value)
+                    if adjusted is None:
+                        continue
+                    confidence = adjusted
+
+                confidence = apply_context_boost(text, start, end, pii_type, confidence)
+                candidates.append(Finding(pii_type, value, start, end, round(confidence, 2)))
+
+    return candidates
+
+
+def _spans_overlap(a: Finding, b: Finding) -> bool:
+    return a.start < b.end and b.start < a.end
+
+
+def _merge_overlaps(candidates: list[Finding]) -> list[Finding]:
+    accepted: list[Finding] = []
+    for finding in sorted(candidates, key=lambda f: f.confidence, reverse=True):
+        if not any(_spans_overlap(finding, kept) for kept in accepted):
+            accepted.append(finding)
+    return sorted(accepted, key=lambda f: f.start)
+
+
+def detect(text: str, min_confidence: float = DEFAULT_MIN_CONFIDENCE) -> list[Finding]:
+    """Detect PII in `text`, returning non-overlapping Findings sorted by position."""
+    candidates = _regex_pass(text) + detect_ner(text)
+    merged = _merge_overlaps(candidates)
+    return [f for f in merged if f.confidence >= min_confidence]
+
+
+__all__ = ["detect", "Finding", "PIIType"]

maskflow_core/entities.py

@@ -0,0 +1,30 @@
+from dataclasses import dataclass
+from enum import Enum
+
+
+class PIIType(str, Enum):
+    EMAIL = "EMAIL"
+    PHONE = "PHONE"
+    SSN = "SSN"
+    CREDIT_CARD = "CREDIT_CARD"
+    IP_ADDRESS = "IP_ADDRESS"
+    AWS_KEY = "AWS_KEY"
+    API_KEY = "API_KEY"
+    JWT = "JWT"
+    IBAN = "IBAN"
+    ADDRESS = "ADDRESS"
+    PERSON_NAME = "PERSON_NAME"
+    DATE_OF_BIRTH = "DATE_OF_BIRTH"
+
+
+@dataclass(frozen=True)
+class Finding:
+    type: PIIType
+    value: str
+    start: int
+    end: int
+    confidence: float
+
+    @property
+    def span(self) -> tuple[int, int]:
+        return (self.start, self.end)

maskflow_core/masking.py

@@ -0,0 +1,39 @@
+"""Pure, stateless mask/unmask. No files, no DB -- the caller owns persistence of the mapping."""
+from typing import NamedTuple
+
+from .detection import DEFAULT_MIN_CONFIDENCE, detect
+
+
+class MaskResult(NamedTuple):
+    masked_text: str
+    mapping: dict[str, str]
+
+
+def mask(text: str, min_confidence: float = DEFAULT_MIN_CONFIDENCE) -> MaskResult:
+    """Replace detected PII with `<TYPE_n>` tokens, returning the masked text and a
+    {token: original_value} mapping the caller can use to unmask a later response."""
+    findings = detect(text, min_confidence=min_confidence)
+
+    mapping: dict[str, str] = {}
+    counters: dict[str, int] = {}
+    pieces: list[str] = []
+    cursor = 0
+
+    for finding in findings:  # detect() returns non-overlapping findings sorted by start
+        counters[finding.type.value] = counters.get(finding.type.value, 0) + 1
+        token = f"<{finding.type.value}_{counters[finding.type.value]}>"
+        mapping[token] = finding.value
+        pieces.append(text[cursor:finding.start])
+        pieces.append(token)
+        cursor = finding.end
+
+    pieces.append(text[cursor:])
+    return MaskResult("".join(pieces), mapping)
+
+
+def unmask(masked_text: str, mapping: dict[str, str]) -> str:
+    """Restore original values from a mapping produced by `mask()`."""
+    result = masked_text
+    for token, original in mapping.items():
+        result = result.replace(token, original)
+    return result

maskflow_core/ner.py

@@ -0,0 +1,49 @@
+"""spacy-based detection for entity types regex can't reliably catch: names and dates."""
+from functools import lru_cache
+
+import spacy
+
+from .context import apply_context_boost
+from .entities import Finding, PIIType
+
+MODEL_NAME = "en_core_web_sm"
+
+PERSON_BASE_CONFIDENCE = 0.75
+DATE_BASE_CONFIDENCE = 0.3
+DATE_OF_BIRTH_THRESHOLD = 0.6
+
+
+@lru_cache(maxsize=1)
+def _get_nlp():
+    try:
+        return spacy.load(MODEL_NAME)
+    except OSError as exc:
+        raise OSError(
+            f"spaCy model '{MODEL_NAME}' isn't installed. Run: "
+            f"python -m spacy download {MODEL_NAME}"
+        ) from exc
+
+
+def detect_ner(text: str) -> list[Finding]:
+    nlp = _get_nlp()
+    doc = nlp(text)
+    findings: list[Finding] = []
+
+    for ent in doc.ents:
+        if ent.label_ == "PERSON":
+            confidence = apply_context_boost(
+                text, ent.start_char, ent.end_char, PIIType.PERSON_NAME, PERSON_BASE_CONFIDENCE
+            )
+            findings.append(
+                Finding(PIIType.PERSON_NAME, ent.text, ent.start_char, ent.end_char, confidence)
+            )
+        elif ent.label_ == "DATE":
+            confidence = apply_context_boost(
+                text, ent.start_char, ent.end_char, PIIType.DATE_OF_BIRTH, DATE_BASE_CONFIDENCE
+            )
+            if confidence >= DATE_OF_BIRTH_THRESHOLD:
+                findings.append(
+                    Finding(PIIType.DATE_OF_BIRTH, ent.text, ent.start_char, ent.end_char, confidence)
+                )
+
+    return findings

maskflow_core/patterns.py

@@ -0,0 +1,123 @@
+"""Regex patterns and structural validators for each PII type.
+
+Each entry in PATTERNS maps a PIIType to (compiled_regex, base_confidence, validator).
+`validator(value) -> float | None` returns an adjusted confidence, or None to reject
+the match entirely (e.g. a 16-digit number that fails the Luhn check).
+"""
+import re
+
+from .entities import PIIType
+
+EMAIL_RE = re.compile(r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b")
+
+PHONE_RE = re.compile(
+    r"(?<!\d)(?:\+?\d{1,3}[-.\s]?)?\(?\d{3}\)?[-.\s]\d{3}[-.\s]\d{4}(?!\d)"
+)
+
+SSN_DASHED_RE = re.compile(r"(?<!\d)\d{3}-\d{2}-\d{4}(?!\d)")
+SSN_PLAIN_RE = re.compile(r"(?<!\d)\d{9}(?!\d)")
+
+CREDIT_CARD_RE = re.compile(
+    r"(?<!\d)(?:\d[ -]?){13,19}(?!\d)"
+)
+
+IPV4_RE = re.compile(
+    r"\b(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\b"
+)
+IPV6_RE = re.compile(r"\b(?:[A-Fa-f0-9]{1,4}:){7}[A-Fa-f0-9]{1,4}\b")
+
+AWS_KEY_RE = re.compile(r"\b(?:AKIA|ASIA)[0-9A-Z]{16}\b")
+
+API_KEY_RE = re.compile(
+    r"\b(?:sk-ant-[A-Za-z0-9_-]{20,}"
+    r"|sk-[A-Za-z0-9_-]{20,}"
+    r"|gh[pousr]_[A-Za-z0-9]{20,}"
+    r"|xox[baprs]-[A-Za-z0-9-]{10,}"
+    r"|AIza[A-Za-z0-9_-]{35})\b"
+)
+
+GENERIC_SECRET_ASSIGNMENT_RE = re.compile(
+    r"(?i)\b\w*(?:key|secret|token|password|credential)\w*"
+    r"\s*[:=]\s*['\"]?([A-Za-z0-9_\-/+]{16,})['\"]?"
+)
+
+JWT_RE = re.compile(
+    r"\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b"
+)
+
+IBAN_RE = re.compile(r"\b[A-Z]{2}\d{2}[A-Z0-9]{11,30}\b")
+
+ADDRESS_RE = re.compile(
+    r"\b\d{1,6}\s+(?:[A-Z][a-zA-Z]*\s){1,4}"
+    r"(?:Street|St|Avenue|Ave|Road|Rd|Boulevard|Blvd|Lane|Ln|"
+    r"Drive|Dr|Court|Ct|Way|Place|Pl|Terrace|Ter)\.?\b"
+    r"(?:,?\s+(?:Apt|Suite|Ste|Unit)\.?\s*#?\w+)?"
+)
+
+
+def luhn_is_valid(digits: str) -> bool:
+    digits = [int(d) for d in digits]
+    checksum = 0
+    parity = len(digits) % 2
+    for i, d in enumerate(digits):
+        if i % 2 == parity:
+            d *= 2
+            if d > 9:
+                d -= 9
+        checksum += d
+    return checksum % 10 == 0
+
+
+def _validate_credit_card(value: str) -> float | None:
+    digits = re.sub(r"[ -]", "", value)
+    if not (13 <= len(digits) <= 19) or not digits.isdigit():
+        return None
+    return 0.97 if luhn_is_valid(digits) else None
+
+
+def iban_is_valid(value: str) -> bool:
+    value = value.upper()
+    rearranged = value[4:] + value[:4]
+    converted = "".join(str(int(c, 36)) for c in rearranged)
+    try:
+        return int(converted) % 97 == 1
+    except ValueError:
+        return False
+
+
+def _validate_iban(value: str) -> float | None:
+    return 0.9 if iban_is_valid(value) else None
+
+
+def _validate_ssn_dashed(value: str) -> float | None:
+    area = value[:3]
+    if area in ("000", "666") or area.startswith("9"):
+        return None
+    return 0.95
+
+
+def _validate_ssn_plain(value: str) -> float | None:
+    # Bare 9-digit numbers are ambiguous (order IDs, phone numbers without
+    # formatting, etc.) -- start low, let context.py decide if it's really an SSN.
+    return 0.35
+
+
+# type -> (regex, base_confidence, validator)
+PATTERNS: dict[PIIType, list[tuple[re.Pattern, float, "callable | None"]]] = {
+    PIIType.EMAIL: [(EMAIL_RE, 0.95, None)],
+    PIIType.PHONE: [(PHONE_RE, 0.85, None)],
+    PIIType.SSN: [
+        (SSN_DASHED_RE, 0.95, _validate_ssn_dashed),
+        (SSN_PLAIN_RE, 0.35, _validate_ssn_plain),
+    ],
+    PIIType.CREDIT_CARD: [(CREDIT_CARD_RE, 0.9, _validate_credit_card)],
+    PIIType.IP_ADDRESS: [(IPV4_RE, 0.75, None), (IPV6_RE, 0.85, None)],
+    PIIType.AWS_KEY: [(AWS_KEY_RE, 0.97, None)],
+    PIIType.API_KEY: [
+        (API_KEY_RE, 0.95, None),
+        (GENERIC_SECRET_ASSIGNMENT_RE, 0.6, None),
+    ],
+    PIIType.JWT: [(JWT_RE, 0.9, None)],
+    PIIType.IBAN: [(IBAN_RE, 0.6, _validate_iban)],
+    PIIType.ADDRESS: [(ADDRESS_RE, 0.7, None)],
+}

maskflow_core-0.1.0.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: maskflow-core
+Version: 0.1.0
+Summary: PII detection and reversible masking engine for MaskFlow
+Requires-Python: >=3.9
+Requires-Dist: click>=8.0
+Requires-Dist: spacy<4,>=3.7
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'

maskflow_core-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+maskflow_core/__init__.py,sha256=7ycEq8WPMCAYBaJjU26XHOZzTsMljKyFrHsuqOS4j-U,191
+maskflow_core/context.py,sha256=pYHBoG1w5TQIegzXrPOx2izemI48K9pfEegvKMXgEag,1440
+maskflow_core/detection.py,sha256=pvqxmK3SVK-NcgUstXTm4KpmZyYGscU3wsulLeB73KY,2011
+maskflow_core/entities.py,sha256=MgH_T24nSDKWE2lRhSjNDt0Cza7l0yJvkjdHlmOGTAI,592
+maskflow_core/masking.py,sha256=YHu3j-4ZrC8eE5_yXFXXeis9OHDkWG0GBF78hRjqvYk,1431
+maskflow_core/ner.py,sha256=YXhyK5y2elvuPgDrfIeISiE6ikpaEQoIhdzlVYWb7NE,1507
+maskflow_core/patterns.py,sha256=hfJnTe4RVdXOB8peOs2a-QzvaRUEogg4S5Fv2Bf5PuE,3796
+maskflow_core-0.1.0.dist-info/METADATA,sha256=fPBuMqTJYlqNLVPmQRQWHyYN9T-aMxz_Z9n2lumzTa4,264
+maskflow_core-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+maskflow_core-0.1.0.dist-info/RECORD,,

maskflow_core-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any