Update app.py

app.py

@@ -12,6 +12,95 @@ try:
 except ImportError:
     print("Warning: pubchempy not found. PubChem feature extraction will be skipped.")
 
+# Active compound mapping for traditional drugs
+DRUG_ACTIVE_COMPOUNDS = {
+    'kanna': 'mesembrine',
+    'sceletium tortuosum': 'mesembrine',
+    'st johns wort': 'hyperforin',
+    'st john\'s wort': 'hyperforin',
+    'hypericum perforatum': 'hyperforin',
+    'yohimbe': 'yohimbine',
+    'pausinystalia johimbe': 'yohimbine',
+    'kola nut': 'caffeine',
+    'cola nitida': 'caffeine',
+    'khat': 'cathinone',
+    'catha edulis': 'cathinone',
+    'kava': 'kavain',
+    'piper methysticum': 'kavain',
+    'valerian': 'valerenic acid',
+    'valeriana officinalis': 'valerenic acid',
+    'ashwagandha': 'withanoside iv',
+    'withania somnifera': 'withanoside iv',
+    'cannabis': 'thc',
+    'cannabis sativa': 'thc',
+    'licorice': 'glycyrrhizin',
+    'glycyrrhiza glabra': 'glycyrrhizin',
+    'rauvolfia': 'reserpine',
+    'rauvolfia serpentina': 'reserpine',
+    'turmeric': 'curcumin',
+    'curcuma longa': 'curcumin',
+    'ginger': 'gingerol',
+    'zingiber officinale': 'gingerol',
+    'garlic': 'allicin',
+    'allium sativum': 'allicin',
+    'feverfew': 'parthenolide',
+    'tanacetum parthenium': 'parthenolide',
+    'senna': 'sennoside a',
+    'cassia angustifolia': 'sennoside a',
+    'aloe ferox': 'aloin',
+    'ephedra': 'ephedrine',
+    'ephedra sinica': 'ephedrine',
+    'willow bark': 'salicin',
+    'salix alba': 'salicin',
+    'echinacea': 'cichoric acid',
+    'echinacea purpurea': 'cichoric acid',
+    'ginkgo': 'ginkgolide',
+    'ginkgo biloba': 'ginkgolide',
+    'ginseng': 'ginsenoside',
+    'panax ginseng': 'ginsenoside',
+    'green tea': 'epigallocatechin gallate',
+    'camellia sinensis': 'epigallocatechin gallate'
+}
+
+def extract_active_compound(drug_name):
+    """
+    Extract active compound from traditional drug name using mapping or PubChem
+    This function works in the background - user doesn't see this process
+    """
+    drug_lower = drug_name.lower().strip()
+    
+    # First check our predefined mapping
+    if drug_lower in DRUG_ACTIVE_COMPOUNDS:
+        active_compound = DRUG_ACTIVE_COMPOUNDS[drug_lower]
+        print(f"Found active compound for {drug_name}: {active_compound}")
+        return active_compound
+    
+    # If not in mapping and PubChem is available, try to get synonyms/related compounds
+    if PUBCHEM_AVAILABLE:
+        try:
+            compounds = pcp.get_compounds(drug_name, 'name')
+            if compounds:
+                compound = compounds[0]
+                # Try to get the main active ingredient name
+                synonyms = compound.synonyms if hasattr(compound, 'synonyms') else []
+                if synonyms:
+                    # Look for common active compound patterns in synonyms
+                    for synonym in synonyms[:10]:  # Check first 10 synonyms
+                        syn_lower = synonym.lower()
+                        if any(pattern in syn_lower for pattern in ['acid', 'ine', 'ol', 'ide', 'ate']):
+                            print(f"Found potential active compound for {drug_name}: {synonym}")
+                            return synonym.lower()
+                
+                # If no suitable synonym found, return the canonical name
+                if hasattr(compound, 'iupac_name') and compound.iupac_name:
+                    return compound.iupac_name.lower()
+                    
+        except Exception as e:
+            print(f"Error extracting active compound for {drug_name}: {e}")
+    
+    # If all else fails, return the original drug name (it might already be an active compound)
+    return drug_lower
+
 # Load your labeled dataset with exact column names
 def load_drug_interaction_dataset():
     """Load your labeled drug interaction dataset with exact column names"""
@@ -71,7 +160,15 @@ def create_fallback_database():
     print("Initializing fallback database")
     return {
         ('warfarin', 'aspirin'): 'Severe',
-        ('aspirin', 'warfarin'): 'Severe',
+        ('cathinone', 'yohimbine'): 'Severe',
+        ('codeine', 'hyperforin'): 'Severe',
+        ('glycyrrhizin', 'digitoxin'): 'Severe',
+        ('digoxin', 'glycyrrhizin'): 'Severe',
+        ('yohimbine', 'reserpine'): 'Severe',
+        ('ephedrine', 'yohimbine'): 'Severe',
+        ('ephedrine', 'cathinone'): 'Severe',
+        ('sennoside a', 'aloin'): 'Severe',
+        ('glycyrrhizin', 'sennoside a'): 'Severe',
         ('warfarin', 'ibuprofen'): 'Severe',
         ('ibuprofen', 'warfarin'): 'Severe',
         ('simvastatin', 'clarithromycin'): 'Severe',
@@ -90,8 +187,32 @@ def create_fallback_database():
         ('fluconazole', 'warfarin'): 'Severe',
         ('digoxin', 'verapamil'): 'Severe',
         ('verapamil', 'digoxin'): 'Severe',
+        ('amodiaquine', 'acebutolol'): 'Severe',
+        ('amodiaquine', 'artemether'): 'Severe',
+        ('amodiaquine', 'atenolol'): 'Severe',
+        ('amodiaquine', 'carvedilol'): 'Severe',
+        ('amodiaquine', 'efavirenz'): 'Severe',
+        ('amodiaquine', 'betaxolol'): 'Severe',
+        ('amodiaquine', 'bisoprolol'): 'Severe',
+        ('amodiaquine', 'metoprolol'): 'Severe',
+        ('amodiaquine', 'propranolol'): 'Severe',
+        ('amodiaquine', 'rifampicin'): 'Severe',
         
         # Moderate interactions
+        ('hyperforin', 'mesembrine'): 'Moderate',
+        ('kavain', 'valerenic acid'): 'Moderate',
+        ('kavain', 'withanoside iv'): 'Moderate',
+        ('thc', 'mesembrine'): 'Moderate',
+        ('thc', 'valerenic acid'): 'Moderate',
+        ('hyperforin', 'morphine'): 'Moderate',
+        ('allicin', 'gingerol'): 'Moderate',
+        ('parthenolide', 'curcumin'): 'Moderate',
+        ('yohimbine', 'caffeine'): 'Moderate',
+        ('amodiaquine', 'amitriptyline'): 'Moderate',
+        ('amodiaquine', 'candesartan'): 'Moderate',
+        ('amodiaquine', 'fluoxetine'): 'Moderate',
+        ('amodiaquine', 'haloperidol'): 'Moderate',
+        ('amodiaquine', 'chloroquine'): 'Moderate',
         ('digoxin', 'quinine'): 'Moderate',
         ('quinine', 'digoxin'): 'Moderate',
         ('lisinopril', 'ibuprofen'): 'Moderate',
@@ -114,8 +235,10 @@ def create_fallback_database():
         ('digoxin', 'spironolactone'): 'Moderate',
         
         # Mild interactions
+        ('amodiaquine', 'amlodipine'): 'Mild',
+        ('amodiaquine', 'carbamazepine'): 'Mild',
         ('metformin', 'ibuprofen'): 'Mild',
-        ('ibuprofen', 'metformin'): 'Mild',
+        ('curcumin', 'gingerol'): 'Mild',
         ('omeprazole', 'calcium'): 'Mild',
         ('calcium', 'omeprazole'): 'Mild',
         ('vitamin d', 'calcium'): 'Mild',
@@ -128,10 +251,10 @@ def create_fallback_database():
         ('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',
+        ('aspirin', 'gingerol'): 'Mild',
+        ('gingerol', 'aspirin'): 'Mild',
+        ('warfarin', 'epigallocatechin gallate'): 'Mild',
+        ('epigallocatechin gallate', 'warfarin'): 'Mild',
         ('levothyroxine', 'iron'): 'Mild',
         ('iron', 'levothyroxine'): 'Mild',
         
@@ -172,9 +295,7 @@ def get_pubchem_features(drug_name):
             'xlogp': compound.xlogp if compound.xlogp else 0,
             'tpsa': compound.tpsa if compound.tpsa else 0,
             'canonical_smiles': compound.canonical_smiles,
-            'canonical_smiles_2': compound.canonical_smiles_2,
-            'molecular_formula': compound.molecular_formula,
-            'molecular_formula_2': compound.molecular_formula_2
+            'molecular_formula': compound.molecular_formula
         }
     except Exception as e:
         print(f"Error fetching PubChem data for {drug_name}: {e}")
@@ -198,40 +319,55 @@ 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 "Error"
+            return "Error: Please enter two drugs separated by comma"
         
         drugs = [drug.strip() for drug in drug_names.split(',')]
         if len(drugs) != 2:
-            return "Error"
+            return "Error: Please enter exactly two drugs"
+        
+        drug1_original, drug2_original = drugs[0], drugs[1]
+        
+        # Extract active compounds in the background (user doesn't see this)
+        drug1_active = extract_active_compound(drug1_original)
+        drug2_active = extract_active_compound(drug2_original)
         
-        drug1, drug2 = drugs[0].lower(), drugs[1].lower()
-        print(f"Looking up: '{drug1}' + '{drug2}'")
+        print(f"Background extraction: '{drug1_original}' -> '{drug1_active}', '{drug2_original}' -> '{drug2_active}'")
 
         # Validate drug names
-        if len(drug1) < 2 or len(drug2) < 2:  # Minimum length check for invalid inputs
-            return "Error"
+        if len(drug1_active) < 2 or len(drug2_active) < 2:
+            return "Error: Invalid drug names"
 
-        # Check dataset first
-        prediction = dataset_db.get((drug1, drug2))
+        # Check dataset first using active compounds
+        prediction = dataset_db.get((drug1_active, drug2_active))
         if prediction:
             return prediction
         
-        # Check fallback database if not in dataset
-        fallback_prediction = fallback_db.get((drug1, drug2))
+        # Check fallback database using active compounds
+        fallback_prediction = fallback_db.get((drug1_active, drug2_active))
         if fallback_prediction:
             return fallback_prediction
         
-        # If not in fallback, fetch PubChem features and predict if available
-        drug1_features = get_pubchem_features(drug1)
-        drug2_features = get_pubchem_features(drug2)
+        # If not in databases, try original drug names as backup
+        prediction = dataset_db.get((drug1_original.lower(), drug2_original.lower()))
+        if prediction:
+            return prediction
+            
+        fallback_prediction = fallback_db.get((drug1_original.lower(), drug2_original.lower()))
+        if fallback_prediction:
+            return fallback_prediction
+        
+        # If still not found, fetch PubChem features and predict if available
+        drug1_features = get_pubchem_features(drug1_active)
+        drug2_features = get_pubchem_features(drug2_active)
         if drug1_features and drug2_features:
             return predict_from_features(drug1_features, drug2_features)
         else:
             # Balanced random choice for completely unknown drugs
             return random.choice(['Moderate', 'Mild'])
         
-    except Exception:
-        return "Error"
+    except Exception as e:
+        print(f"Error in prediction: {e}")
+        return "Error: Unable to process request"
 
 # Load your dataset and fallback
 print("Loading drug interaction dataset...")
@@ -240,31 +376,39 @@ dataset_db, fallback_db = load_drug_interaction_dataset()
 # Create interface
 with gr.Blocks(title="Drug Interaction Predictor") as demo:
     gr.Markdown("# Drug Interaction Predictor")
+    gr.Markdown("Enter two drug names (traditional or modern) to predict their interaction severity. Active compounds are automatically extracted in the background.")
     
     with gr.Row():
         with gr.Column():
             drug_input = gr.Textbox(
                 label="Enter two drug names (separated by comma)",
-                placeholder="e.g., Warfarin, Aspirin",
+                placeholder="e.g., Warfarin, Aspirin or St John's Wort, Morphine",
                 lines=2
             )
             
-            predict_btn = gr.Button("Predict Interaction")
+            predict_btn = gr.Button("Predict Interaction", variant="primary")
         
         with gr.Column():
             output = gr.Textbox(
                 label="Interaction Prediction", 
-                lines=1,
+                lines=2,
                 interactive=False
             )
     
     predict_btn.click(fn=lambda x: predict_interaction(x, dataset_db, fallback_db), inputs=drug_input, outputs=output)
     
-    # Add disclaimer
-    #gr.Markdown("""
-    #---
-    #**Disclaimer**: This tool is for educational purposes only. Always consult with healthcare professionals before making any medical decisions.
-    #""")
+    # Add examples
+    gr.Examples(
+        examples=[
+            ["Warfarin, Aspirin"],
+            ["St John's Wort, Morphine"],
+            ["Yohimbe, Khat"],
+            ["Cannabis, Valerian"],
+            ["Turmeric, Ginger"],
+            ["Kava, Ashwagandha"]
+        ],
+        inputs=drug_input
+    )
 
 if __name__ == "__main__":
     demo.launch()