Update app.py

app.py

@@ -1,70 +1,65 @@
 import gradio as gr
 import pandas as pd
 import os
+import pubchempy as pcp
 
 # Load your labeled dataset with exact column names
 def load_drug_interaction_dataset():
     """Load your labeled drug interaction dataset with exact column names"""
     try:
-        # Your exact dataset filename
         dataset_path = 'merged_cleaned_dataset.csv'
-        
         print(f"Looking for dataset: {dataset_path}")
         print("Files in directory:", os.listdir('.'))
         
         if not os.path.exists(dataset_path):
             print(f"Dataset file {dataset_path} not found!")
-            return create_fallback_database()
+            return {}, create_fallback_database()  # Return empty dict and fallback if file missing
         
-        # Load the dataset with your exact column names
         print(f"Loading dataset from: {dataset_path}")
         df = pd.read_csv(dataset_path)
         print(f"Dataset columns: {df.columns.tolist()}")
         print(f"Dataset shape: {df.shape}")
-        print(f"First few rows:\n{df.head()}")
+        print(f"First few rows:\n{df.head().to_string()}")
         
-        # Create interaction dictionary using your exact column names
         interaction_db = {}
         count = 0
         
-        for _, row in df.iterrows():
+        for index, row in df.iterrows():
             try:
-                # Use your exact column names
                 drug1 = str(row['Drug 1_normalized']).lower().strip()
                 drug2 = str(row['Drug 2_normalized']).lower().strip()
                 severity = str(row['severity']).strip()
                 
-                # Skip empty entries or invalid data
                 if (not all([drug1, drug2, severity]) or 
                     drug1 == 'nan' or drug2 == 'nan' or 
                     severity == 'nan' or severity.lower() == 'none'):
                     continue
                 
-                # Clean up severity labels
                 severity = severity.capitalize()
                 if severity == 'No interaction':
                     severity = 'No Interaction'
                 
-                # Add both orders to the dictionary
                 interaction_db[(drug1, drug2)] = severity
-                interaction_db[(drug2, drug1)] = severity  # Add reverse order
+                interaction_db[(drug2, drug1)] = severity
                 count += 1
+                if drug1 == 'warfarin' and drug2 == 'aspirin':
+                    print(f"Found Warfarin, Aspirin at row {index} with severity: {severity}")
                 
             except Exception as e:
-                print(f"Error processing row {_}: {e}")
+                print(f"Error processing row {index}: {e}")
                 continue
         
         print(f"✅ Successfully loaded {count} drug interactions from dataset")
         print(f"Sample interactions: {list(interaction_db.items())[:5]}")
-        return interaction_db
+        return interaction_db, create_fallback_database()
         
     except Exception as e:
         print(f"Error loading dataset: {e}")
-        return create_fallback_database()
+        return {}, create_fallback_database()
 
 def create_fallback_database():
-    """Fallback database if dataset loading fails - FIXED STRUCTURE"""
-    print("Using fallback database")
+    """Fallback database for missing drug pairs"""
+    print("Initializing fallback database")
     return {
         ('warfarin', 'aspirin'): 'Severe',
         ('aspirin', 'warfarin'): 'Severe',
@@ -72,99 +67,52 @@ def create_fallback_database():
         ('ibuprofen', 'warfarin'): 'Severe',
         ('simvastatin', 'clarithromycin'): 'Severe',
         ('clarithromycin', 'simvastatin'): 'Severe',
-        ('clopidogrel', 'omeprazole'): 'Severe',
-        ('omeprazole', 'clopidogrel'): 'Severe',
-        ('methotrexate', 'naproxen'): 'Severe',
-        ('naproxen', 'methotrexate'): 'Severe',
-        ('lithium', 'ibuprofen'): 'Severe',
-        ('ibuprofen', 'lithium'): 'Severe',
-        ('ssri', 'maoi'): 'Severe',
-        ('maoi', 'ssri'): 'Severe',
-        ('simvastatin', 'verapamil'): 'Severe',
-        ('verapamil', 'simvastatin'): 'Severe',
-        ('warfarin', 'fluconazole'): 'Severe',
-        ('fluconazole', 'warfarin'): 'Severe',
-        ('digoxin', 'verapamil'): 'Severe',
-        ('verapamil', 'digoxin'): 'Severe',
-        
-        # Moderate interactions
         ('digoxin', 'quinine'): 'Moderate',
         ('quinine', 'digoxin'): 'Moderate',
-        ('lisinopril', 'ibuprofen'): 'Moderate',
-        ('ibuprofen', 'lisinopril'): 'Moderate',
-        ('metformin', 'alcohol'): 'Moderate',
-        ('alcohol', 'metformin'): 'Moderate',
-        ('levothyroxine', 'calcium'): 'Moderate',
-        ('calcium', 'levothyroxine'): 'Moderate',
-        ('atorvastatin', 'orange juice'): 'Moderate',
-        ('orange juice', 'atorvastatin'): 'Moderate',
-        ('phenytoin', 'warfarin'): 'Moderate',
-        ('warfarin', 'phenytoin'): 'Moderate',
-        ('theophylline', 'ciprofloxacin'): 'Moderate',
-        ('ciprofloxacin', 'theophylline'): 'Moderate',
-        ('warfarin', 'acetaminophen'): 'Moderate',
-        ('acetaminophen', 'warfarin'): 'Moderate',
-        ('metoprolol', 'verapamil'): 'Moderate',
-        ('verapamil', 'metoprolol'): 'Moderate',
-        ('spironolactone', 'digoxin'): 'Moderate',
-        ('digoxin', 'spironolactone'): 'Moderate',
-        
-        # Mild interactions
         ('metformin', 'ibuprofen'): 'Mild',
         ('ibuprofen', 'metformin'): 'Mild',
-        ('omeprazole', 'calcium'): 'Mild',
-        ('calcium', 'omeprazole'): 'Mild',
-        ('vitamin d', 'calcium'): 'Mild',
-        ('calcium', 'vitamin d'): 'Mild',
-        ('aspirin', 'vitamin c'): 'Mild',
-        ('vitamin c', 'aspirin'): 'Mild',
-        ('atorvastatin', 'vitamin d'): 'Mild',
-        ('vitamin d', 'atorvastatin'): 'Mild',
-        ('metformin', 'vitamin b12'): 'Mild',
-        ('vitamin b12', 'metformin'): 'Mild',
-        ('omeprazole', 'vitamin b12'): 'Mild',
-        ('vitamin b12', 'omeprazole'): 'Mild',
-        ('aspirin', 'ginger'): 'Mild',
-        ('ginger', 'aspirin'): 'Mild',
-        ('warfarin', 'green tea'): 'Mild',
-        ('green tea', 'warfarin'): 'Mild',
-        ('levothyroxine', 'iron'): 'Mild',
-        ('iron', 'levothyroxine'): 'Mild',
-        
-        # No interactions
         ('vitamin c', 'vitamin d'): 'No Interaction',
         ('vitamin d', 'vitamin c'): 'No Interaction',
-        ('calcium', 'vitamin d'): 'No Interaction',
-        ('vitamin d', 'calcium'): 'No Interaction',
-        ('omeprazole', 'vitamin d'): 'No Interaction',
-        ('vitamin d', 'omeprazole'): 'No Interaction',
-        ('metformin', 'vitamin d'): 'No Interaction',
-        ('vitamin d', 'metformin'): 'No Interaction',
-        ('aspirin', 'vitamin e'): 'No Interaction',
-        ('vitamin e', 'aspirin'): 'No Interaction',
-        ('atorvastatin', 'coenzyme q10'): 'No Interaction',
-        ('coenzyme q10', 'atorvastatin'): 'No Interaction',
-        ('levothyroxine', 'vitamin d'): 'No Interaction',
-        ('vitamin d', 'levothyroxine'): 'No Interaction',
-        ('metoprolol', 'magnesium'): 'No Interaction',
-        ('magnesium', 'metoprolol'): 'No Interaction',
-        ('lisinopril', 'potassium'): 'No Interaction',
-        ('potassium', 'lisinopril'): 'No Interaction',
-        ('simvastatin', 'vitamin e'): 'No Interaction',
-        ('vitamin e', 'simvastatin'): 'No Interaction',
     }
 
-# Load your dataset
-print("Loading drug interaction dataset...")
-interaction_db = load_drug_interaction_dataset()
+# Function to fetch drug features from PubChem
+def get_pubchem_features(drug_name):
+    try:
+        compounds = pcp.get_compounds(drug_name, 'name')
+        if not compounds:
+            return None
+        compound = compounds[0]  # Take the first match
+        return {
+            'molecular_weight': compound.molecular_weight,
+            'xlogp': compound.xlogp if compound.xlogp else 0,
+            'tpsa': compound.tpsa if compound.tpsa else 0,
+            'h_bond_donor_count': compound.h_bond_donor_count,
+            'h_bond_acceptor_count': compound.h_bond_acceptor_count
+        }
+    except Exception as e:
+        print(f"Error fetching PubChem data for {drug_name}: {e}")
+        return None
+
+# Simple prediction based on PubChem features (placeholder logic)
+def predict_from_features(drug1_features, drug2_features):
+    if not drug1_features or not drug2_features:
+        return "❓ **NO DATA AVAILABLE**: Unable to fetch features for prediction."
+    
+    # Placeholder: Compare molecular weight difference and XLogP similarity
+    weight_diff = abs(drug1_features['molecular_weight'] - drug2_features['xlogp'])
+    if weight_diff > 200:  # Arbitrary threshold for severe interaction
+        return "🚨 **SEVERE INTERACTION**: Predicted based on feature difference.\n⚠️ Consult healthcare provider immediately."
+    elif weight_diff > 100:
+        return "⚠️ **MODERATE INTERACTION**: Predicted based on feature difference.\n📋 Requires monitoring."
+    else:
+        return "✅ **NO INTERACTION**: Predicted based on feature similarity.\n🟢 Appears safe to use together."
 
-def predict_interaction(drug_names):
-    """Predict interaction between two drugs using your labeled dataset"""
+def predict_interaction(drug_names, dataset_db, fallback_db):
+    """Predict interaction between two drugs using dataset, fallback, and PubChem"""
     try:
         if not drug_names or ',' not in drug_names:
             return "❌ Please enter two drug names separated by a comma (e.g., 'Warfarin, Aspirin')"
         
-        # Split the input
         drugs = [drug.strip() for drug in drug_names.split(',')]
         if len(drugs) != 2:
             return "❌ Please enter exactly two drug names separated by a comma"
@@ -172,11 +120,9 @@ def predict_interaction(drug_names):
         drug1, drug2 = drugs[0].lower(), drugs[1].lower()
         print(f"Looking up: '{drug1}' + '{drug2}'")
         
-        # Check if this interaction exists in your dataset
-        prediction = interaction_db.get((drug1, drug2))
-        
+        # Check dataset first
+        prediction = dataset_db.get((drug1, drug2))
         if prediction:
-            # Add appropriate emoji and formatting based on severity
             if prediction.lower() == 'severe':
                 return f"🚨 **SEVERE INTERACTION**: {prediction}\n⚠️ This combination may be life-threatening. Consult healthcare provider immediately."
             elif prediction.lower() == 'moderate':
@@ -187,30 +133,44 @@ def predict_interaction(drug_names):
                 return f"✅ **NO INTERACTION**: {prediction}\n🟢 These drugs appear to be safe to use together."
             else:
                 return f"📊 **INTERACTION LEVEL**: {prediction}"
-        else:
-            # Log all available keys for debugging
-            print(f"Keys in interaction_db: {list(interaction_db.keys())[:10]}... (total {len(interaction_db)})")
-            
-            # Check if either drug exists in the database
-            drug1_exists = any(d1 == drug1 or d2 == drug1 for d1, d2 in interaction_db.keys())
-            drug2_exists = any(d1 == drug2 or d2 == drug2 for d1, d2 in interaction_db.keys())
-            
-            if not drug1_exists and not drug2_exists:
-                return f"❓ **UNKNOWN DRUGS**: Neither '{drugs[0]}' nor '{drugs[1]}' found in database.\n💡 Try checking spelling or use generic names."
-            elif not drug1_exists:
-                return f"❓ **UNKNOWN DRUG**: '{drugs[0]}' not found in database.\n💡 Try checking spelling or use generic name."
-            elif not drug2_exists:
-                return f"❓ **UNKNOWN DRUG**: '{drugs[1]}' not found in database.\n💡 Try checking spelling or use generic name."
+        
+        # Check fallback database if not in dataset
+        fallback_prediction = fallback_db.get((drug1, drug2))
+        if fallback_prediction:
+            if fallback_prediction.lower() == 'severe':
+                return f"🚨 **SEVERE INTERACTION**: {fallback_prediction} (from fallback)\n⚠️ This combination may be life-threatening. Consult healthcare provider immediately."
+            elif fallback_prediction.lower() == 'moderate':
+                return f"⚠️ **MODERATE INTERACTION**: {fallback_prediction} (from fallback)\n📋 Requires monitoring. Consult healthcare provider."
+            elif fallback_prediction.lower() == 'mild':
+                return f"⚡ **MILD INTERACTION**: {fallback_prediction} (from fallback)\n💡 Minimal clinical significance but monitor for effects."
+            elif 'no interaction' in fallback_prediction.lower():
+                return f"✅ **NO INTERACTION**: {fallback_prediction} (from fallback)\n🟢 These drugs appear to be safe to use together."
             else:
-                return f"❓ **NO DATA AVAILABLE**: No interaction data found for '{drugs[0]}' and '{drugs[1]}'.\n💡 Consult healthcare provider for guidance."
+                return f"📊 **INTERACTION LEVEL**: {fallback_prediction} (from fallback)"
+        
+        # If not in fallback, fetch PubChem features and predict
+        drug1_features = get_pubchem_features(drug1)
+        drug2_features = get_pubchem_features(drug2)
+        if drug1_features and drug2_features:
+            return predict_from_features(drug1_features, drug2_features)
+        else:
+            found_drugs = set()
+            for d1, d2 in {**dataset_db, **fallback_db}.keys():
+                found_drugs.add(d1)
+                found_drugs.add(d2)
+            return f"❓ **NO DATA AVAILABLE**: No interaction data for '{drugs[0]}' and '{drugs[1]}'.\n💡 Known drugs: {sorted(list(found_drugs))[:5]}... Consult healthcare provider."
         
     except Exception as e:
         return f"❌ Error: {str(e)}"
 
+# Load your dataset and fallback
+print("Loading drug interaction dataset...")
+dataset_db, fallback_db = load_drug_interaction_dataset()
+
 # Create interface
 with gr.Blocks(title="Drug Interaction Predictor", theme=gr.themes.Soft()) as demo:
     gr.Markdown("# 💊 Drug Interaction Predictor")
-    gr.Markdown("**Predict potential drug interactions using clinical data**")
+    gr.Markdown("**Predict potential drug interactions using clinical data and PubChem**")
     
     with gr.Row():
         with gr.Column():
@@ -231,14 +191,16 @@ with gr.Blocks(title="Drug Interaction Predictor", theme=gr.themes.Soft()) as de
             )
     
     # Show dataset info and debugging
-    gr.Markdown(f"*📊 Dataset loaded with {len(interaction_db)} drug pair interactions*")
+    gr.Markdown(f"*📊 Dataset loaded with {len(dataset_db)} drug pair interactions*")
+    gr.Markdown(f"*📋 Fallback database contains {len(fallback_db)} drug pair interactions*")
     
     # Add a debug section to show what's actually in the database
-    sample_pairs = list(interaction_db.items())[:10]
-    debug_info = "Sample database entries:\n" + "\n".join([f"• {k}: {v}" for k, v in sample_pairs])
+    sample_dataset_pairs = list(dataset_db.items())[:5]
+    sample_fallback_pairs = list(fallback_db.items())[:5]
+    debug_info = "Sample dataset entries:\n" + "\n".join([f"• {k}: {v}" for k, v in sample_dataset_pairs]) + "\n\nSample fallback entries:\n" + "\n".join([f"• {k}: {v}" for k, v in sample_fallback_pairs])
     gr.Markdown(f"```\n{debug_info}\n```")
     
-    # Examples from your dataset
+    # Examples from your dataset and fallback
     gr.Examples(
         examples=[
             "Warfarin, Aspirin",
@@ -251,7 +213,7 @@ with gr.Blocks(title="Drug Interaction Predictor", theme=gr.themes.Soft()) as de
         label="🧪 Try these examples:"
     )
     
-    predict_btn.click(predict_interaction, drug_input, output)
+    predict_btn.click(fn=lambda x: predict_interaction(x, dataset_db, fallback_db), inputs=drug_input, outputs=output)
     
     # Add disclaimer
     gr.Markdown("""