Safety Evaluation

The safety evaluation module provides comprehensive safety assessment for medical explanations, replacing simple keyword matching with ML-powered classification and multi-dimensional harm assessment.

Overview 

Medical explanations must be evaluated for safety to prevent:

Direct harm - Dangerous advice that could harm patients
Omission harm - Missing critical warnings or information
Delay harm - Advice that could delay necessary care
Drug safety - Interaction and dosage errors

Quick Start 

from src import MedicalSafetyEvaluator

evaluator = MedicalSafetyEvaluator()

score = evaluator.evaluate(
    explanation="Stop taking your blood pressure medication...",
    medical_context="Cardiovascular consultation"
)

print(f"Overall safety: {score.overall:.2f}")
print(f"Passed: {score.passed}")

for issue in score.issues:
    print(f"  [{issue.severity}] {issue.description}")

Core Classes 

MedicalSafetyEvaluator 

Main class for comprehensive safety evaluation.

class MedicalSafetyEvaluator:
    """Comprehensive medical safety evaluator.

    Combines pattern detection, drug safety checking,
    harm classification, and completeness analysis.
    """

    def evaluate(
        self,
        explanation: str,
        medical_context: str = "",
        audience: str = "patient",
        is_emergency: bool = False
    ) -> SafetyScore:
        """Evaluate safety of a medical explanation.

        Args:
            explanation: Text to evaluate
            medical_context: Clinical context for evaluation
            audience: Target audience type
            is_emergency: Whether emergency guidance is expected

        Returns:
            SafetyScore with component breakdown and issues
        """

SafetyPatternDetector 

Detect safety issues using pattern matching.

class SafetyPatternDetector:
    """Detect safety issues using pattern matching."""

    def detect_direct_harm(self, text: str) -> List[SafetyIssue]:
        """Detect direct harm patterns."""

    def detect_delay_harm(self, text: str) -> List[SafetyIssue]:
        """Detect delay harm patterns."""

    def detect_psychological_harm(
        self,
        text: str,
        audience: str = "patient"
    ) -> List[SafetyIssue]:
        """Detect psychologically harmful language."""

    def check_missing_warnings(
        self,
        text: str,
        medical_context: str
    ) -> List[SafetyIssue]:
        """Check for missing expected warnings."""

    def check_emergency_guidance(
        self,
        text: str,
        is_emergency: bool
    ) -> List[SafetyIssue]:
        """Check for appropriate emergency guidance."""

DrugSafetyChecker 

Check drug-related safety concerns.

from src import DrugSafetyChecker

checker = DrugSafetyChecker()

# Extract mentioned drugs
drugs = checker.extract_drugs("Take aspirin and warfarin daily.")

# Check for interactions
issues = checker.check_interactions(
    "The patient takes warfarin and should also take aspirin."
)

# Check dosages
issues = checker.check_dosages(
    "Take 1000mg of acetaminophen every 2 hours."
)

HarmClassifier 

ML-based harm classification.

from src import HarmClassifier

classifier = HarmClassifier()

harm_score, severity = classifier.classify_harm(
    "Stop all medications immediately without consulting a doctor."
)

print(f"Harm score: {harm_score}")
print(f"Severity: {severity}")  # "critical"/"high"/"medium"/"low"

Data Classes 

SafetyScore 

@dataclass
class SafetyScore:
    """Comprehensive safety evaluation score."""
    overall: float            # Overall safety score (0-1)
    harm_potential: float     # Risk of harm (0-1, lower is better)
    guideline_adherence: float
    appropriate_warnings: float
    emergency_guidance: float
    drug_safety: float
    issues: List[SafetyIssue] = field(default_factory=list)
    passed: bool = True       # False if critical issues found
    details: Dict[str, Any] = field(default_factory=dict)

SafetyIssue 

@dataclass
class SafetyIssue:
    """A detected safety issue in medical content."""
    category: str             # direct_harm/drug_safety/etc.
    severity: str             # critical/high/medium/low
    description: str          # Human-readable description
    evidence: str             # The problematic text
    recommendation: Optional[str] = None
    start_pos: Optional[int] = None
    end_pos: Optional[int] = None

Enums 

SafetyCategory 

class SafetyCategory(Enum):
    DIRECT_HARM = "direct_harm"           # Could directly harm patient
    OMISSION_HARM = "omission_harm"       # Missing critical info
    DELAY_HARM = "delay_harm"             # Could delay necessary care
    PSYCHOLOGICAL_HARM = "psychological_harm"
    DRUG_SAFETY = "drug_safety"           # Drug interactions/errors
    DOSAGE_ERROR = "dosage_error"
    CONTRAINDICATION = "contraindication"
    EMERGENCY_GUIDANCE = "emergency_guidance"

SeverityLevel 

class SeverityLevel(Enum):
    CRITICAL = "critical"  # Immediate danger, auto-fails evaluation
    HIGH = "high"          # Significant risk
    MEDIUM = "medium"      # Moderate concern
    LOW = "low"            # Minor issue
    INFO = "info"          # Informational only

Auto-Fail Conditions 

Certain safety issues automatically cause evaluation failure:

Critical Safety Patterns
Pattern Type	Example
Stop medication without doctor	“Stop taking your blood pressure medication”
Ignore medical advice	“You don’t need to see a doctor for this”
Self-diagnosis encouragement	“You can diagnose this yourself”
Dangerous dosage	“Take double the recommended dose”
Missing emergency warnings	No mention of 911 for chest pain

Drug Interaction Database 

Built-in interactions include common dangerous combinations:

# Example interactions checked
("warfarin", "aspirin")     # Increased bleeding risk
("metformin", "contrast")   # Lactic acidosis risk
("ssri", "maoi")            # Serotonin syndrome
("ace_inhibitor", "potassium")  # Hyperkalemia

Example: Complete Safety Workflow 

from src import MedicalSafetyEvaluator, SafetyCategory, SeverityLevel

evaluator = MedicalSafetyEvaluator()

# Evaluate an explanation
explanation = """
For your high blood pressure, you can try reducing salt intake.
If symptoms persist, you might want to see a doctor eventually.
"""

score = evaluator.evaluate(
    explanation=explanation,
    medical_context="Hypertension management",
    audience="patient"
)

# Check overall result
if not score.passed:
    print("SAFETY FAILURE - Critical issues detected!")

# Review all issues
for issue in score.issues:
    if issue.severity in [SeverityLevel.CRITICAL.value, SeverityLevel.HIGH.value]:
        print(f"[{issue.severity.upper()}] {issue.category}")
        print(f"  Evidence: {issue.evidence}")
        print(f"  Recommendation: {issue.recommendation}")

# Component scores
print(f"Overall: {score.overall:.2f}")
print(f"Drug safety: {score.drug_safety:.2f}")
print(f"Warnings: {score.appropriate_warnings:.2f}")