File size: 5,967 Bytes
a0f2a2e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 | #!/usr/bin/env python3
"""Deterministically extract factual offer fields without retaining notice prose."""
from __future__ import annotations
import argparse
import json
import re
import subprocess
from datetime import date, datetime, timezone
from pathlib import Path
FORBIDDEN_KEYS = {"activation_code", "enrollment_code", "addressee", "address", "phone", "email", "mailing_address"}
MONTHS = "January|February|March|April|May|June|July|August|September|October|November|December"
PROVIDERS = ("Experian IdentityWorks", "Experian", "Equifax", "TransUnion", "Kroll", "IDX", "AllClear", "Cyberscout")
EXPOSURES = ((r"social security", "Social Security number"), (r"driver.?s license", "Driver's license number"), (r"financial account", "Financial account information"), (r"health information", "Health information"), (r"date of birth", "Date of birth"), (r"name", "Name"))
def clean(value: str) -> str:
return re.sub(r"\s+", " ", value).strip()
def text_from_pdf(path: str) -> str:
result = subprocess.run(["pdftotext", "-layout", path, "-"], check=True, capture_output=True, text=True)
return result.stdout
def parse_date(value: str) -> str | None:
value = value.strip().replace(",", "")
for pattern in ("%B %d %Y", "%b %d %Y", "%m/%d/%Y"):
try:
return datetime.strptime(value, pattern).date().isoformat()
except ValueError:
pass
return None
def deadline_from(text: str) -> tuple[str | None, str | None]:
pattern = rf"(?:enrol(?:l(?:ment)?)?|register|sign\s*up)\b.{{0,100}}?(?:by|before|until)\s+(({MONTHS})\s+\d{{1,2}},?\s+\d{{4}}|\d{{1,2}}/\d{{1,2}}/\d{{4}})"
matches = list(re.finditer(pattern, text, flags=re.I | re.S))
parsed = []
for match in matches:
iso = parse_date(match.group(1))
if iso:
zone = re.search(r"\b(UTC|PST|PDT|EST|EDT|CST|CDT|MST|MDT|Pacific Time|Eastern Time|Central Time|Mountain Time)\b", text[match.end():match.end() + 45], flags=re.I)
parsed.append((iso, zone.group(1).upper() if zone else None))
unique = {(item[0], item[1]) for item in parsed}
return next(iter(unique)) if len(unique) == 1 else (None, None)
def deadline_status(deadline: str | None, built_at: str) -> str:
if not deadline:
return "unknown"
today = datetime.fromisoformat(built_at.replace("Z", "+00:00")).date()
printed = date.fromisoformat(deadline)
if printed >= today:
return "open"
if printed < today:
return "expired"
return "unknown"
def provider_from(text: str) -> str | None:
if re.search(r"enroll\.krollmonitoring\.com", text, flags=re.I):
return "Kroll"
enrollment_provider = re.search(r"Visit\s+(?:the\s+)?(Experian IdentityWorks|Experian|Equifax|TransUnion|Kroll|IDX|AllClear|Cyberscout)(?:\s+website)?\s+(?:to\s+)?enroll", text, flags=re.I)
if enrollment_provider:
return enrollment_provider.group(1)
return next((name for name in PROVIDERS if re.search(re.escape(name), text, flags=re.I)), None)
def extract(record: dict, text: str, built_at: str) -> dict:
deadline, zone = deadline_from(text)
provider = provider_from(text)
duration = re.search(r"\(?([0-9]{1,2})\)?\s*(months?)\b", text, flags=re.I)
months = None
duration_text = None
if duration:
raw_number, unit = duration.group(1), duration.group(2).lower()
months = int(raw_number) * (12 if unit.startswith("year") else 1)
duration_text = f"{raw_number} {unit}"
exposure_section = re.search(r"(?:what information was involved|information involved).*?(?:what we are doing|what you can do)", text, flags=re.I | re.S)
lower = exposure_section.group(0).lower() if exposure_section else ""
exposed = [label for needle, label in EXPOSURES if re.search(needle, lower)]
remedy_type = "identity protection" if provider else ("credit monitoring" if re.search(r"credit monitoring", text, flags=re.I) else None)
fields = {
"id": record["id"], "organization": record.get("organization"), "breach_dates": record.get("breach_dates", []),
"reported_date": record.get("reported_date"), "data_exposed": exposed, "remedy_type": remedy_type,
"remedy_provider": provider, "remedy_duration_months": months, "remedy_duration_text": duration_text,
"enrollment_deadline": deadline, "enrollment_deadline_timezone": zone,
"deadline_status": deadline_status(deadline, built_at), "source_report_url": record["report_url"],
"source_notice_url": record["source_notice_url"], "source_notice_sha256": record["source_notice_sha256"],
"source_accessed_at": record["source_accessed_at"],
}
fields["extraction_confidence"] = round((sum(value is not None and value != [] for value in (fields["organization"], provider, months, deadline)) / 4), 2)
return {key: value for key, value in fields.items() if key not in FORBIDDEN_KEYS}
def main() -> None:
parser = argparse.ArgumentParser()
parser.add_argument("--notices", default="build/notices/manifest.jsonl")
parser.add_argument("--out", default="build/extracted.jsonl")
parser.add_argument("--built-at", default=datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z"))
args = parser.parse_args()
rows, failures = [], 0
for line in Path(args.notices).read_text(encoding="utf-8").splitlines():
record = json.loads(line)
if "pdf_path" not in record:
failures += 1
continue
try:
rows.append(extract(record, text_from_pdf(record["pdf_path"]), args.built_at))
except (OSError, subprocess.CalledProcessError):
failures += 1
Path(args.out).write_text("".join(json.dumps(row, sort_keys=True) + "\n" for row in rows), encoding="utf-8")
print(json.dumps({"rows": len(rows), "extraction_failures": failures, "built_at": args.built_at}, sort_keys=True))
if __name__ == "__main__":
main()
|