scientific-writer 2.1.1__py3-none-any.whl → 2.2.2__py3-none-any.whl

scientific_writer/.claude/skills/clinical-reports/scripts/check_deidentification.py

@@ -0,0 +1,346 @@
+#!/usr/bin/env python3
+"""
+Check clinical reports for HIPAA identifiers that need removal.
+
+Scans text for 18 HIPAA identifiers and flags potential privacy violations.
+
+Usage:
+    python check_deidentification.py <input_file>
+    python check_deidentification.py <input_file> --output violations.json
+"""
+
+import argparse
+import json
+import re
+from pathlib import Path
+from typing import Dict, List
+
+
+# 18 HIPAA Identifiers patterns
+HIPAA_IDENTIFIERS = {
+    "1_names": {
+        "description": "Names (patient, family, providers)",
+        "patterns": [
+            r"\b(Dr\.|Mr\.|Mrs\.|Ms\.)\s+[A-Z][a-z]+",
+            r"\b[A-Z][a-z]+,\s+[A-Z][a-z]+\b",  # Last, First
+        ],
+        "severity": "HIGH"
+    },
+    "2_geographic": {
+        "description": "Geographic subdivisions smaller than state",
+        "patterns": [
+            r"\b\d+\s+[A-Z][a-z]+\s+(Street|St|Avenue|Ave|Road|Rd|Boulevard|Blvd|Lane|Ln|Drive|Dr)\b",
+            r"\b[A-Z][a-z]+,\s+[A-Z]{2}\s+\d{5}\b",  # City, ST ZIP
+        ],
+        "severity": "HIGH"
+    },
+    "3_dates": {
+        "description": "Dates (except year)",
+        "patterns": [
+            r"\b(0?[1-9]|1[0-2])/(0?[1-9]|[12][0-9]|3[01])/\d{4}\b",
+            r"\b(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[a-z]*\s+\d{1,2},\s+\d{4}\b",
+            r"\b\d{1,2}\s+(January|February|March|April|May|June|July|August|September|October|November|December)\s+\d{4}\b",
+        ],
+        "severity": "HIGH"
+    },
+    "4_telephone": {
+        "description": "Telephone numbers",
+        "patterns": [
+            r"\b\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b",
+            r"\b1-\d{3}-\d{3}-\d{4}\b",
+        ],
+        "severity": "HIGH"
+    },
+    "5_fax": {
+        "description": "Fax numbers",
+        "patterns": [
+            r"(?i)fax[:]\s*\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}",
+        ],
+        "severity": "HIGH"
+    },
+    "6_email": {
+        "description": "Email addresses",
+        "patterns": [
+            r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b",
+        ],
+        "severity": "HIGH"
+    },
+    "7_ssn": {
+        "description": "Social Security numbers",
+        "patterns": [
+            r"\b\d{3}-\d{2}-\d{4}\b",
+            r"\b\d{9}\b",
+        ],
+        "severity": "CRITICAL"
+    },
+    "8_mrn": {
+        "description": "Medical record numbers",
+        "patterns": [
+            r"(?i)(mrn|medical\s+record\s+(number|#))[:]\s*\d+",
+            r"(?i)patient\s+id[:]\s*\d+",
+        ],
+        "severity": "HIGH"
+    },
+    "9_health_plan": {
+        "description": "Health plan beneficiary numbers",
+        "patterns": [
+            r"(?i)(insurance|policy)\s+(number|#|id)[:]\s*[A-Z0-9]+",
+        ],
+        "severity": "HIGH"
+    },
+    "10_account": {
+        "description": "Account numbers",
+        "patterns": [
+            r"(?i)account\s+(number|#)[:]\s*\d+",
+        ],
+        "severity": "MEDIUM"
+    },
+    "11_license": {
+        "description": "Certificate/license numbers",
+        "patterns": [
+            r"(?i)(driver[']?s\s+license|DL)[:]\s*[A-Z0-9]+",
+        ],
+        "severity": "MEDIUM"
+    },
+    "12_vehicle": {
+        "description": "Vehicle identifiers",
+        "patterns": [
+            r"(?i)(license\s+plate|VIN)[:]\s*[A-Z0-9]+",
+        ],
+        "severity": "MEDIUM"
+    },
+    "13_device": {
+        "description": "Device identifiers and serial numbers",
+        "patterns": [
+            r"(?i)(serial|device)\s+(number|#)[:]\s*[A-Z0-9-]+",
+        ],
+        "severity": "MEDIUM"
+    },
+    "14_url": {
+        "description": "Web URLs",
+        "patterns": [
+            r"https?://[^\s]+",
+            r"www\.[^\s]+",
+        ],
+        "severity": "MEDIUM"
+    },
+    "15_ip": {
+        "description": "IP addresses",
+        "patterns": [
+            r"\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b",
+        ],
+        "severity": "HIGH"
+    },
+    "16_biometric": {
+        "description": "Biometric identifiers",
+        "patterns": [
+            r"(?i)(fingerprint|voiceprint|retinal\s+scan)",
+        ],
+        "severity": "CRITICAL"
+    },
+    "17_photos": {
+        "description": "Full-face photographs",
+        "patterns": [
+            r"(?i)(photograph|photo|image).*face",
+            r"\.(jpg|jpeg|png|gif)\b",
+        ],
+        "severity": "HIGH"
+    },
+    "18_unique": {
+        "description": "Any other unique identifying characteristic",
+        "patterns": [
+            r"(?i)(tattoo|birthmark|scar).*unique",
+        ],
+        "severity": "MEDIUM"
+    },
+}
+
+
+def check_identifiers(text: str) -> Dict:
+    """Check text for HIPAA identifiers."""
+    violations = {}
+    total_issues = 0
+    
+    for identifier_id, config in HIPAA_IDENTIFIERS.items():
+        matches = []
+        for pattern in config["patterns"]:
+            found = re.findall(pattern, text, re.IGNORECASE)
+            matches.extend(found)
+        
+        if matches:
+            # Remove duplicates, limit to first 5 examples
+            unique_matches = list(set(matches))[:5]
+            violations[identifier_id] = {
+                "description": config["description"],
+                "severity": config["severity"],
+                "count": len(matches),
+                "examples": unique_matches
+            }
+            total_issues += len(matches)
+    
+    return {
+        "total_violations": len(violations),
+        "total_instances": total_issues,
+        "violations": violations
+    }
+
+
+def check_age_compliance(text: str) -> Dict:
+    """Check if ages >89 are properly aggregated."""
+    age_pattern = r"\b(\d{2,3})\s*(?:year|yr)s?[\s-]?old\b"
+    ages = [int(age) for age in re.findall(age_pattern, text, re.IGNORECASE)]
+    
+    violations = [age for age in ages if age > 89]
+    
+    return {
+        "ages_over_89": len(violations),
+        "examples": violations[:5] if violations else [],
+        "compliant": len(violations) == 0
+    }
+
+
+def generate_report(filename: str) -> Dict:
+    """Generate de-identification compliance report."""
+    filepath = Path(filename)
+    
+    if not filepath.exists():
+        raise FileNotFoundError(f"File not found: {filename}")
+    
+    with open(filepath, 'r', encoding='utf-8') as f:
+        text = f.read()
+    
+    identifier_check = check_identifiers(text)
+    age_check = check_age_compliance(text)
+    
+    # Determine overall compliance
+    critical_violations = sum(
+        1 for v in identifier_check["violations"].values()
+        if v["severity"] == "CRITICAL"
+    )
+    high_violations = sum(
+        1 for v in identifier_check["violations"].values()
+        if v["severity"] == "HIGH"
+    )
+    
+    if critical_violations > 0 or high_violations >= 3:
+        status = "NON_COMPLIANT"
+    elif high_violations > 0 or not age_check["compliant"]:
+        status = "NEEDS_REVIEW"
+    else:
+        status = "COMPLIANT"
+    
+    report = {
+        "filename": str(filename),
+        "status": status,
+        "identifier_violations": identifier_check,
+        "age_compliance": age_check,
+        "recommendation": get_recommendation(status, identifier_check, age_check)
+    }
+    
+    return report
+
+
+def get_recommendation(status: str, identifiers: Dict, ages: Dict) -> str:
+    """Generate recommendation based on findings."""
+    if status == "COMPLIANT":
+        return "Document appears compliant. Perform final manual review before publication."
+    
+    recommendations = []
+    
+    if identifiers["total_violations"] > 0:
+        recommendations.append(
+            f"Remove or redact {identifiers['total_instances']} identified HIPAA identifiers."
+        )
+    
+    if not ages["compliant"]:
+        recommendations.append(
+            f"Aggregate {ages['ages_over_89']} age(s) >89 years to '90 or older' or '>89 years'."
+        )
+    
+    return " ".join(recommendations)
+
+
+def print_report(report: Dict):
+    """Print human-readable report."""
+    print("=" * 70)
+    print("HIPAA DE-IDENTIFICATION CHECK")
+    print(f"File: {report['filename']}")
+    print("=" * 70)
+    print()
+    
+    print(f"Overall Status: {report['status']}")
+    print()
+    
+    if report["identifier_violations"]["total_violations"] == 0:
+        print("✓ No HIPAA identifiers detected")
+    else:
+        print(f"⚠  Found {report['identifier_violations']['total_violations']} types of violations")
+        print(f"   Total instances: {report['identifier_violations']['total_instances']}")
+        print()
+        
+        print("Violations by type:")
+        print("-" * 70)
+        
+        for id_type, details in sorted(
+            report["identifier_violations"]["violations"].items(),
+            key=lambda x: {"CRITICAL": 0, "HIGH": 1, "MEDIUM": 2}[x[1]["severity"]]
+        ):
+            severity_symbol = "⚠⚠⚠" if details["severity"] == "CRITICAL" else "⚠⚠" if details["severity"] == "HIGH" else "⚠"
+            print(f"{severity_symbol} [{details['severity']:8}] {details['description']}")
+            print(f"   Count: {details['count']}")
+            print(f"   Examples:")
+            for example in details["examples"]:
+                print(f"     - {example}")
+            print()
+    
+    age_check = report["age_compliance"]
+    if age_check["compliant"]:
+        print("✓ Age reporting compliant (no ages >89 or properly aggregated)")
+    else:
+        print(f"⚠  Age compliance issue: {age_check['ages_over_89']} age(s) >89 detected")
+        print(f"   Ages must be aggregated to '90 or older' or '>89 years'")
+        print(f"   Ages found: {age_check['examples']}")
+    
+    print()
+    print("Recommendation:")
+    print(report["recommendation"])
+    print("=" * 70)
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(
+        description="Check clinical reports for HIPAA identifiers"
+    )
+    parser.add_argument("input_file", help="Path to clinical report file")
+    parser.add_argument("--output", "-o", help="Output JSON report to file")
+    parser.add_argument("--json", action="store_true", help="Output JSON to stdout")
+    
+    args = parser.parse_args()
+    
+    try:
+        report = generate_report(args.input_file)
+        
+        if args.json:
+            print(json.dumps(report, indent=2))
+        else:
+            print_report(report)
+        
+        if args.output:
+            with open(args.output, 'w') as f:
+                json.dump(report, f, indent=2)
+            print(f"\nJSON report saved to: {args.output}")
+        
+        # Exit with non-zero if violations found
+        exit_code = 0 if report["status"] == "COMPLIANT" else 1
+        return exit_code
+        
+    except Exception as e:
+        print(f"Error: {e}")
+        return 1
+
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(main())
+

scientific_writer/.claude/skills/clinical-reports/scripts/compliance_checker.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""
+Check clinical reports for regulatory compliance (HIPAA, GCP, FDA).
+
+Usage:
+    python compliance_checker.py <report_file>
+"""
+
+import argparse
+import json
+import re
+
+
+COMPLIANCE_CHECKS = {
+    "hipaa": {
+        "consent_statement": r"(?i)(informed\s+consent|written\s+consent).*obtained",
+        "deidentification": r"(?i)(de-identif|anonymi[sz])",
+    },
+    "gcp": {
+        "irb_approval": r"(?i)(IRB|IEC|ethics\s+committee).*approv",
+        "protocol_compliance": r"(?i)protocol",
+        "informed_consent": r"(?i)informed\s+consent",
+    },
+    "fda": {
+        "study_id": r"(?i)(IND|IDE|protocol)\s+(number|#)[:]\s*\S+",
+        "safety_reporting": r"(?i)(adverse\s+event|SAE)",
+    }
+}
+
+
+def check_compliance(filename: str) -> dict:
+    """Check regulatory compliance."""
+    with open(filename, 'r', encoding='utf-8') as f:
+        content = f.read()
+    
+    results = {}
+    for regulation, checks in COMPLIANCE_CHECKS.items():
+        reg_results = {}
+        for check_name, pattern in checks.items():
+            reg_results[check_name] = bool(re.search(pattern, content))
+        results[regulation] = reg_results
+    
+    return {"filename": filename, "compliance": results}
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(description="Check regulatory compliance")
+    parser.add_argument("input_file", help="Path to clinical report")
+    parser.add_argument("--json", action="store_true")
+    
+    args = parser.parse_args()
+    
+    try:
+        report = check_compliance(args.input_file)
+        
+        if args.json:
+            print(json.dumps(report, indent=2))
+        else:
+            print("\nRegulatory Compliance Check:\n")
+            for reg, checks in report["compliance"].items():
+                print(f"{reg.upper()}:")
+                for check, passed in checks.items():
+                    symbol = "✓" if passed else "✗"
+                    print(f"  {symbol} {check}")
+                print()
+        
+        return 0
+        
+    except Exception as e:
+        print(f"Error: {e}")
+        return 1
+
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(main())
+

scientific_writer/.claude/skills/clinical-reports/scripts/extract_clinical_data.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""
+Extract structured clinical data from reports.
+
+Usage:
+    python extract_clinical_data.py <report_file>
+"""
+
+import argparse
+import json
+import re
+
+
+def extract_vital_signs(content: str) -> dict:
+    """Extract vital signs."""
+    vitals = {}
+    patterns = {
+        "temperature": r"(?i)temp(?:erature)?[:]\s*([\d.]+)\s*°?F",
+        "bp": r"(?i)BP[:]\s*(\d+/\d+)",
+        "hr": r"(?i)HR[:]\s*(\d+)",
+        "rr": r"(?i)RR[:]\s*(\d+)",
+        "spo2": r"(?i)SpO2[:]\s*([\d.]+)%",
+    }
+    
+    for vital, pattern in patterns.items():
+        match = re.search(pattern, content)
+        if match:
+            vitals[vital] = match.group(1)
+    
+    return vitals
+
+
+def extract_demographics(content: str) -> dict:
+    """Extract patient demographics."""
+    demographics = {}
+    patterns = {
+        "age": r"(?i)(\d+)[\s-]year[\s-]old",
+        "sex": r"(?i)(male|female|M|F)",
+    }
+    
+    for demo, pattern in patterns.items():
+        match = re.search(pattern, content)
+        if match:
+            demographics[demo] = match.group(1)
+    
+    return demographics
+
+
+def extract_medications(content: str) -> list:
+    """Extract medication list."""
+    meds = []
+    # Simple pattern for common medication format
+    pattern = r"(?i)(\w+)\s+(\d+\s*mg)\s+(PO|IV|SC)\s+(daily|BID|TID|QID)"
+    matches = re.findall(pattern, content)
+    
+    for match in matches:
+        meds.append({
+            "drug": match[0],
+            "dose": match[1],
+            "route": match[2],
+            "frequency": match[3]
+        })
+    
+    return meds
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(description="Extract clinical data")
+    parser.add_argument("input_file", help="Path to clinical report")
+    parser.add_argument("--output", "-o", help="Output JSON file")
+    
+    args = parser.parse_args()
+    
+    try:
+        with open(args.input_file, 'r', encoding='utf-8') as f:
+            content = f.read()
+        
+        extracted_data = {
+            "demographics": extract_demographics(content),
+            "vital_signs": extract_vital_signs(content),
+            "medications": extract_medications(content),
+        }
+        
+        if args.output:
+            with open(args.output, 'w') as f:
+                json.dump(extracted_data, f, indent=2)
+            print(f"✓ Data extracted to: {args.output}")
+        else:
+            print(json.dumps(extracted_data, indent=2))
+        
+        return 0
+        
+    except Exception as e:
+        print(f"Error: {e}")
+        return 1
+
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(main())
+

scientific_writer/.claude/skills/clinical-reports/scripts/format_adverse_events.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""
+Format adverse event data into tables for clinical trial reports.
+
+Converts CSV or structured data into formatted AE summary tables.
+
+Usage:
+    python format_adverse_events.py <ae_data.csv>
+"""
+
+import argparse
+import csv
+from collections import defaultdict
+from pathlib import Path
+
+
+def format_ae_summary_table(data: list) -> str:
+    """Generate AE summary table in markdown format."""
+    # Group by treatment arm
+    arm_stats = defaultdict(lambda: {
+        'total': 0,
+        'any_ae': 0,
+        'related_ae': 0,
+        'sae': 0,
+        'deaths': 0,
+        'discontinuations': 0
+    })
+    
+    for row in data:
+        arm = row.get('treatment_arm', 'Unknown')
+        arm_stats[arm]['total'] += 1
+        
+        if row.get('any_ae', '').lower() == 'yes':
+            arm_stats[arm]['any_ae'] += 1
+        if row.get('related', '').lower() == 'yes':
+            arm_stats[arm]['related_ae'] += 1
+        if row.get('serious', '').lower() == 'yes':
+            arm_stats[arm]['sae'] += 1
+        if row.get('fatal', '').lower() == 'yes':
+            arm_stats[arm]['deaths'] += 1
+        if row.get('discontinuation', '').lower() == 'yes':
+            arm_stats[arm]['discontinuations'] += 1
+    
+    # Generate table
+    table = "| Category | " + " | ".join(arm_stats.keys()) + " |\n"
+    table += "|----------|" + "|".join(["--------"] * len(arm_stats)) + "|\n"
+    
+    categories = [
+        ('Total N', 'total'),
+        ('Any AE', 'any_ae'),
+        ('Treatment-related AE', 'related_ae'),
+        ('Serious AE', 'sae'),
+        ('Deaths', 'deaths'),
+        ('Discontinuation due to AE', 'discontinuations')
+    ]
+    
+    for cat_name, cat_key in categories:
+        row_data = [cat_name]
+        for arm_data in arm_stats.values():
+            count = arm_data[cat_key]
+            total = arm_data['total']
+            pct = (count / total * 100) if total > 0 and cat_key != 'total' else 0
+            value = f"{count}" if cat_key == 'total' else f"{count} ({pct:.1f}%)"
+            row_data.append(value)
+        table += "| " + " | ".join(row_data) + " |\n"
+    
+    return table
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(description="Format AE data into tables")
+    parser.add_argument("input_file", help="Path to AE data CSV")
+    parser.add_argument("--output", "-o", help="Output markdown file")
+    
+    args = parser.parse_args()
+    
+    try:
+        with open(args.input_file, 'r') as f:
+            reader = csv.DictReader(f)
+            data = list(reader)
+        
+        table = format_ae_summary_table(data)
+        
+        if args.output:
+            with open(args.output, 'w') as f:
+                f.write(table)
+            print(f"✓ Table saved to: {args.output}")
+        else:
+            print("\nAdverse Events Summary Table:\n")
+            print(table)
+        
+        return 0
+        
+    except Exception as e:
+        print(f"Error: {e}")
+        return 1
+
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(main())
+