Multi-Drug Interaction Checker

import requests
import asyncio
from itertools import combinations
from typing import List, Dict

LEMMA_API_KEY = "your_api_key"

class InteractionChecker:
    """
    Multi-drug interaction checker for polypharmacy patients.
    Checks all pairwise interactions with FDA evidence.
    """
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.lemma.la/v1"
    
    async def check_all_interactions(self, medications: List[str]) -> Dict:
        """
        Check all pairwise drug interactions.
        Returns: prioritized interaction report with FDA evidence.
        """
        # Generate all drug pairs
        drug_pairs = list(combinations(medications, 2))
        print(f"Checking {len(drug_pairs)} drug pairs...")
        
        # Query all pairs in parallel
        tasks = [
            self._check_pair(drug1, drug2)
            for drug1, drug2 in drug_pairs
        ]
        results = await asyncio.gather(*tasks)
        
        # Filter and prioritize interactions
        interactions = [r for r in results if r is not None]
        interactions.sort(key=lambda x: self._severity_score(x['severity']), reverse=True)
        
        return {
            "total_pairs_checked": len(drug_pairs),
            "interactions_found": len(interactions),
            "interactions": interactions,
            "summary": self._generate_summary(interactions)
        }
    
    async def _check_pair(self, drug1: str, drug2: str) -> Dict:
        """Check if two drugs interact using Reasoning API."""
        response = requests.post(
            f"{self.base_url}/graph",
            headers={
                "x-api-key": self.api_key,
                "Content-Type": "application/json"
            },
            json={
                "question": f"Does {drug1} interact with {drug2}?"
            }
        )
        
        response_data = response.json()
        data = response_data.get('data', response_data)
        
        if data.get('results'):
            result = data['results'][0]
            return {
                "drug1": drug1,
                "drug2": drug2,
                "severity": result['relationship']['severity'],
                "condition": result['relationship']['condition'],
                "mechanism": result['relationship'].get('mechanism', 'Not specified'),
                "evidence": result['evidence'],
                "recommendation": self._generate_recommendation(
                    result['relationship']['severity'],
                    result['relationship']['condition']
                )
            }
        return None
    
    def _severity_score(self, severity: str) -> int:
        """Convert severity to numeric score for prioritization."""
        scores = {
            "life_threatening": 4,
            "serious": 3,
            "moderate": 2,
            "mild": 1
        }
        return scores.get(severity, 0)
    
    def _generate_recommendation(self, severity: str, condition: str) -> str:
        """Generate clinical recommendation based on interaction."""
        if severity == "life_threatening":
            return "CONTRAINDICATED - Do not use together"
        elif severity == "serious":
            return "Use with caution - Monitor closely and consider alternatives"
        elif severity == "moderate":
            return "Monitor patient - Adjust doses if needed"
        else:
            return "Be aware - Inform patient of potential interaction"
    
    def _generate_summary(self, interactions: List[Dict]) -> Dict:
        """Generate summary statistics by severity."""
        summary = {
            "life_threatening": 0,
            "serious": 0,
            "moderate": 0,
            "mild": 0
        }
        
        for interaction in interactions:
            severity = interaction['severity']
            if severity in summary:
                summary[severity] += 1
        
        return summary
    
    def generate_report(self, results: Dict, patient_info: Dict = None) -> str:
        """
        Generate human-readable interaction report.
        """
        report = []
        report.append("=" * 60)
        report.append("DRUG INTERACTION ANALYSIS REPORT")
        report.append("=" * 60)
        
        if patient_info:
            report.append(f"\nPatient: {patient_info.get('name', 'Unknown')}")
            report.append(f"Age: {patient_info.get('age', 'Unknown')}")
        
        report.append(f"\nTotal pairs checked: {results['total_pairs_checked']}")
        report.append(f"Interactions found: {results['interactions_found']}")
        
        summary = results['summary']
        report.append(f"\nSeverity Breakdown:")
        report.append(f"  Life-threatening: {summary['life_threatening']}")
        report.append(f"  Serious: {summary['serious']}")
        report.append(f"  Moderate: {summary['moderate']}")
        report.append(f"  Mild: {summary['mild']}")
        
        if results['interactions']:
            report.append(f"\n{'=' * 60}")
            report.append("DETAILED INTERACTIONS")
            report.append("=" * 60)
            
            for i, interaction in enumerate(results['interactions'], 1):
                report.append(f"\n{i}. {interaction['drug1']} + {interaction['drug2']}")
                report.append(f"   Severity: {interaction['severity'].upper()}")
                report.append(f"   Condition: {interaction['condition']}")
                report.append(f"   Recommendation: {interaction['recommendation']}")
                
                if interaction['evidence']:
                    report.append(f"   FDA Evidence:")
                    for evidence in interaction['evidence'][:2]:  # Show first 2 pieces
                        report.append(f"     - {evidence['text'][:100]}...")
                        report.append(f"       [fp:{evidence['fingerprint'][:30]}...]")
        
        return "\n".join(report)

# Example usage
async def main():
    checker = InteractionChecker(LEMMA_API_KEY)
    
    patient_medications = [
        "warfarin", "aspirin", "metformin", "lisinopril",
        "atorvastatin", "omeprazole", "levothyroxine",
        "amlodipine", "furosemide", "gabapentin",
        "albuterol", "ibuprofen"
    ]
    
    print(f"Analyzing {len(patient_medications)} medications...")
    results = await checker.check_all_interactions(patient_medications)
    
    # Generate report
    report = checker.generate_report(
        results,
        patient_info={"name": "Patient #12345", "age": 72}
    )
    
    print(report)
    
    # Save fingerprints for audit trail
    with open("interaction_audit_trail.json", "w") as f:
        json.dump({
            "timestamp": datetime.now().isoformat(),
            "medications": patient_medications,
            "interactions": results['interactions']
        }, f, indent=2)

# Run
asyncio.run(main())