💊 Pharmacy & Drug Discovery

# Pharmacogenomics System - Neuro-Symbolic Drug Dosing

class PersonalizedDosing:
    def __init__(self):
        self.metabolism_model = self._load_neural_model()  # Predicts metabolism
        self.pharmacokinetic_rules = self._define_pk_rules()
        self.safety_kg = self._build_safety_kg()

    def _define_pk_rules(self):
        """Pharmacokinetic (PK) rules for drug metabolism"""
        return {
            'warfarin': {
                'normal_dose': 5.0,  # mg/day
                'genetic_factors': {
                    'CYP2C9_slow': 0.5,      # 50% of normal dose
                    'CYP2C9_intermediate': 0.75,
                    'CYP2C9_normal': 1.0,
                    'CYP2C9_fast': 1.5,      # 150% of normal dose
                },
                'age_adjustment': lambda age: 0.8 if age > 70 else 1.0,
                'kidney_adjustment': lambda GFR: 0.9 if GFR < 60 else 1.0,
            },
            'metformin': {
                'normal_dose': 1000,  # mg/day
                'genetic_factors': {
                    'OCT1_inactive': 0.5,
                    'OCT1_reduced': 0.75,
                    'OCT1_normal': 1.0,
                },
                'kidney_adjustment': lambda GFR: 0 if GFR < 30 else (0.5 if GFR < 45 else 1.0),
            }
        }

    def recommend_dose(self, patient, drug_name):
        """
        Recommend personalized drug dose based on:
        - Patient genetics
        - Kidney/liver function
        - Age
        - Drug interactions
        """
        rules = self.pharmacokinetic_rules.get(drug_name)
        if not rules:
            return {'error': f'No dosing rules for {drug_name}'}

        # Start with normal dose
        dose = rules['normal_dose']

        # Step 1: Adjust for genetics (neural prediction)
        genetic_phenotype = self.metabolism_model.predict(patient['genotype'])
        # genetic_phenotype is e.g., 'CYP2C9_slow'

        dose *= rules['genetic_factors'][genetic_phenotype]

        # Step 2: Apply age adjustment (symbolic rule)
        dose *= rules['age_adjustment'](patient['age'])

        # Step 3: Apply kidney function adjustment (symbolic rule)
        dose *= rules['kidney_adjustment'](patient['GFR'])

        # Step 4: Check for interactions (symbolic knowledge graph)
        interactions = self.safety_kg.get_interactions(drug_name, patient['other_meds'])
        if interactions:
            dose *= 0.75  # Reduce dose if interactions present
            interaction_notes = [f"Interaction with {med}" for med in interactions]
        else:
            interaction_notes = []

        return {
            'recommended_dose': round(dose, 1),
            'unit': rules.get('unit', 'mg/day'),
            'reasoning': {
                'genetic_phenotype': genetic_phenotype,
                'age_adjusted': f'Age > 70' if patient['age'] > 70 else 'Age normal',
                'kidney_adjusted': f'GFR = {patient["GFR"]}' if patient['GFR'] < 60 else 'Normal',
                'interactions': interaction_notes
            },
            'safety_checks': self._safety_check(dose, drug_name)
        }

    def _safety_check(self, dose, drug):
        """Verify dose is within safe range"""
        safe_ranges = {
            'warfarin': (1.0, 10.0),
            'metformin': (500, 2550),
        }
        min_dose, max_dose = safe_ranges.get(drug, (0, 1000000))
        return {
            'safe': min_dose <= dose <= max_dose,
            'range': f'{min_dose}-{max_dose}',
            'warning': f'Dose exceeds safe range!' if dose > max_dose else None
        }

# Usage
system = PersonalizedDosing()

patient = {
    'age': 75,
    'genotype': {'CYP2C9': 'rs1057910_T/T'},  # Slow metabolizer
    'GFR': 45,  # Kidney function
    'other_meds': ['aspirin', 'ibuprofen']
}

recommendation = system.recommend_dose(patient, 'warfarin')
print(f"Recommended dose: {recommendation['recommended_dose']} mg/day")
print(f"Reason: {recommendation['reasoning']}")