Upload 32 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+saved_models/mm_dnn_model.keras filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,10 @@
+"""
+Entry point for HuggingFace Spaces - UAB Theme
+"""
+
+from sud_promise_uab_theme import create_interface
+
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch()
+

const_config.py

@@ -0,0 +1,22 @@
+"""
+Configuration Constants - ML Settings, Paths, App Metadata, Messages
+All configuration and system-level constants
+"""
+
+# ========================================
+# APPLICATION METADATA
+# ========================================
+
+APP_NAME = "SUD-PROMISE Drug Repositioning Assessment Platform"
+APP_VERSION = "3.3.0"
+INSTITUTION = "University of Alabama at Birmingham"
+
+# ========================================
+# FILE PATHS
+# ========================================
+
+DATA_DIR = "data1"
+MODEL_DIR = "saved_models"
+
+DRUGS_FILE = f"{DATA_DIR}/drugsInfo.csv"
+DISEASES_FILE = f"{DATA_DIR}/diseasesInfo.csv"

const_data.py

@@ -0,0 +1,176 @@
+"""
+Data Constants - SUD Categories, Drug/Project Templates, Synthetic Data Settings
+All data generation and template related constants
+"""
+
+# ========================================
+# SUD CATEGORIES (Used in generate_synthetic_data)
+# ========================================
+
+SUD_CATEGORY_DESCRIPTIONS = {
+    "Opioid-Related Disorders": "Addiction to opioids including prescription painkillers, heroin, and fentanyl",
+    "Alcohol Use Disorder": "Problematic pattern of alcohol use leading to clinically significant impairment",
+    "Stimulant Use Disorder": "Addiction to cocaine, methamphetamine, or prescription stimulants",
+    "Cannabis Use Disorder": "Problematic cannabis use with withdrawal and tolerance symptoms",
+    "Sedative/Hypnotic Disorder": "Dependence on benzodiazepines or other sedative medications",
+    "Nicotine Use Disorder": "Tobacco/nicotine dependence and addiction",
+}
+
+SUD_CATEGORY_COLORS = {
+    "Opioid-Related Disorders": "#1E6B52",
+    "Alcohol Use Disorder": "#008C95",
+    "Stimulant Use Disorder": "#5A9B7F",
+    "Cannabis Use Disorder": "#16533E",
+    "Sedative/Hypnotic Disorder": "#4A8B7A",
+    "Nicotine Use Disorder": "#2C7A64",
+}
+
+DISEASE_SEARCH_CONFIG = {
+    "Opioid-Related Disorders": {
+        "search_terms": ["Opioid-Related Disorders"],
+    },
+    "Alcohol Use Disorder": {
+        "search_terms": ["Alcoholism"],
+    },
+    "Stimulant Use Disorder": {
+        "search_terms": ["Stimulant Use Disorder"],
+    },
+    "Cannabis Use Disorder": {
+        "search_terms": ["Cannabis Use Disorder"],
+    },
+    "Nicotine Use Disorder": {
+        "search_terms": ["Tobacco Use Disorder"],
+    },
+    "Sedative/Hypnotic Disorder": {
+        "search_terms": ["Sedative/Hypnotic Disorder"],
+    },
+}
+
+# ========================================
+# DRUG TEMPLATES (Used in generate_synthetic_data)
+# ========================================
+
+DRUG_TEMPLATES = {
+    "Opioid-Related Disorders": [
+        ("Naltrexone", "Alcohol/opioid dependence", "μ-opioid receptor antagonist", "S5"),
+        ("Buprenorphine", "Opioid dependence", "Partial μ-opioid agonist", "S6"),
+        ("Lofexidine", "Hypertension", "α2-adrenergic agonist", "S4"),
+        ("Gabapentin", "Epilepsy, neuropathic pain", "GABA analog", "S4"),
+        ("Topiramate", "Epilepsy, migraine", "GABA modulator", "S3"),
+        ("Ondansetron", "Nausea/vomiting", "5-HT3 antagonist", "S2"),
+        ("Clonidine", "Hypertension", "α2-adrenergic agonist", "S3"),
+        ("Memantine", "Alzheimer's disease", "NMDA antagonist", "S2"),
+        ("Prazosin", "Hypertension", "α1-adrenergic antagonist", "S1"),
+        ("Mirtazapine", "Depression", "α2-adrenergic antagonist", "S2"),
+    ],
+    "Alcohol Use Disorder": [
+        ("Acamprosate", "Alcohol dependence", "NMDA antagonist", "S5"),
+        ("Naltrexone", "Opioid dependence", "μ-opioid antagonist", "S5"),
+        ("Baclofen", "Muscle spasticity", "GABA-B agonist", "S4"),
+        ("Topiramate", "Epilepsy", "GABA modulator", "S4"),
+        ("Varenicline", "Smoking cessation", "Nicotinic receptor agonist", "S3"),
+        ("Ondansetron", "Nausea/vomiting", "5-HT3 antagonist", "S3"),
+        ("Gabapentin", "Epilepsy", "GABA analog", "S2"),
+        ("Zonisamide", "Epilepsy", "Carbonic anhydrase inhibitor", "S1"),
+    ],
+    "Stimulant Use Disorder": [
+        ("Modafinil", "Narcolepsy", "Dopamine reuptake inhibitor", "S4"),
+        ("Bupropion", "Depression", "NDRI", "S4"),
+        ("Topiramate", "Epilepsy", "GABA modulator", "S3"),
+        ("N-acetylcysteine", "Acetaminophen overdose", "Antioxidant", "S3"),
+        ("Mirtazapine", "Depression", "α2-antagonist", "S2"),
+        ("Atomoxetine", "ADHD", "NRI", "S1"),
+    ],
+    "Cannabis Use Disorder": [
+        ("N-acetylcysteine", "Acetaminophen overdose", "Antioxidant", "S3"),
+        ("Gabapentin", "Epilepsy", "GABA analog", "S3"),
+        ("Zolpidem", "Insomnia", "GABA-A modulator", "S2"),
+        ("Dronabinol", "Nausea/vomiting", "CB1 agonist", "S2"),
+        ("Buspirone", "Anxiety", "5-HT1A agonist", "S1"),
+    ],
+    "Sedative/Hypnotic Disorder": [
+        ("Flumazenil", "Benzodiazepine overdose", "GABA-A antagonist", "S3"),
+        ("Gabapentin", "Epilepsy", "GABA analog", "S3"),
+        ("Pregabalin", "Neuropathic pain", "GABA analog", "S2"),
+    ],
+    "Nicotine Use Disorder": [
+        ("Varenicline", "Smoking cessation", "Nicotinic receptor agonist", "S6"),
+        ("Cytisine", "Smoking cessation (EU)", "Nicotinic receptor agonist", "S5"),
+        ("Bupropion", "Depression", "NDRI", "S5"),
+        ("Naltrexone", "Opioid dependence", "μ-opioid antagonist", "S4"),
+    ],
+}
+
+# ========================================
+# PROJECT TEMPLATES (Used in generate_synthetic_data)
+# ========================================
+
+PROJECT_TEMPLATES = [
+    {
+        "name": "NIDA Clinical Trial NCT02892123",
+        "type": "Clinical Trial",
+        "size_range": (150, 500),
+        "impact_range": (0.10, 0.20),
+        "summary": "Randomized controlled trial showing significant reduction in relapse rates"
+    },
+    {
+        "name": "Meta-Analysis Lee et al. 2024",
+        "type": "Meta-Analysis",
+        "size_range": (800, 3000),
+        "impact_range": (0.08, 0.15),
+        "summary": "Pooled analysis of multiple RCTs demonstrating efficacy across populations"
+    },
+    {
+        "name": "RWE Claims Database Analysis",
+        "type": "Real-World Evidence",
+        "size_range": (2000, 10000),
+        "impact_range": (0.05, 0.12),
+        "summary": "Insurance claims data showing real-world treatment adherence and outcomes"
+    },
+    {
+        "name": "Biomarker Validation Study",
+        "type": "Biomarker Study",
+        "size_range": (50, 200),
+        "impact_range": (0.06, 0.10),
+        "summary": "Identification of predictive biomarkers for treatment response"
+    },
+    {
+        "name": "Phase II Safety Trial",
+        "type": "Clinical Trial",
+        "size_range": (100, 300),
+        "impact_range": (0.07, 0.13),
+        "summary": "Safety and tolerability data in target SUD population"
+    },
+    {
+        "name": "Safety Concern Report FDA-2024",
+        "type": "Safety Analysis",
+        "size_range": (80, 250),
+        "impact_range": (-0.15, -0.08),
+        "summary": "Adverse event reports indicating potential safety concerns in target population"
+    },
+    {
+        "name": "Negative RCT Results Study",
+        "type": "Clinical Trial",
+        "size_range": (120, 400),
+        "impact_range": (-0.12, -0.06),
+        "summary": "Randomized trial showing no significant efficacy compared to placebo"
+    },
+]
+
+# ========================================
+# METRICS & ANALYTICS (Used in analytics functions)
+# ========================================
+
+AVERAGE_TIME_TO_IND = 12.7  # months
+CURRENT_IND_READY_COUNT = 2
+
+TIME_BINS_LABELS = ['6-9', '9-12', '12-15', '15-18', '18-21', '21-24', '24+']
+TIME_BINS_COUNTS = [10, 16, 25, 31, 39, 42, 49]
+
+QUARTERLY_DELIVERIES = [
+    {'quarter': 'Sep 2025', 'year': 2025, 'count': 0, 'cumulative': 0},
+    {'quarter': 'Jan 2026', 'year': 2026, 'count': 0.5, 'cumulative': 0.5},
+    {'quarter': 'Apr 2026', 'year': 2026, 'count': 0.3, 'cumulative': 0.8},
+    {'quarter': 'Jun 2026', 'year': 2026, 'count': 1.2, 'cumulative': 2.0},
+    {'quarter': 'Sep 2026', 'year': 2026, 'count': 0, 'cumulative': 2.0},
+]

const_ui.py

@@ -0,0 +1,114 @@
+"""
+UI Constants - Colors, Styling, Display Settings
+All visual/interface related constants
+"""
+
+# ========================================
+# COLOR PALETTE (Used throughout pipeline)
+# ========================================
+
+UAB_GREEN = "#1E6B52"
+UAB_DARK_GREEN = "#16533E"
+UAB_LIGHT_GREEN = "#5A9B7F"
+UAB_ACCENT_TEAL = "#008C95"
+UAB_PALE_GREEN = "#E8F4F0"
+UAB_WHITE = "#FFFFFF"
+
+# ========================================
+# STAGE CONFIGURATION (Used in generate_synthetic_data, badges, etc.)
+# ========================================
+
+STAGE_MAPPING = {
+    "S0": (0.35, 0.50),
+    "S1": (0.45, 0.58),
+    "S2": (0.55, 0.68),
+    "S3": (0.65, 0.78),
+    "S4": (0.73, 0.85),
+    "S5": (0.80, 0.92),
+    "S6": (0.88, 0.95),
+}
+
+STAGE_NAMES = {
+    "S0": "Ideation",
+    "S1": "Intake",
+    "S2": "Feasibility",
+    "S3": "In Silico",
+    "S4": "Wet Lab",
+    "S5": "IND-Ready",
+    "S6": "Handoff"
+}
+
+STAGE_COLORS = {
+    "S0": "#94A3B8",
+    "S1": "#A8CABD",
+    "S2": UAB_LIGHT_GREEN,
+    "S3": UAB_GREEN,
+    "S4": UAB_GREEN,
+    "S5": UAB_DARK_GREEN,
+    "S6": UAB_DARK_GREEN,
+}
+
+# ========================================
+# SCORE THRESHOLDS (Used in charts and interpretation)
+# ========================================
+
+SCORE_THRESHOLD_HIGH = 0.7
+SCORE_THRESHOLD_MODERATE = 0.5
+
+# ========================================
+# DISPLAY SETTINGS (Used in UI rendering)
+# ========================================
+
+MAX_CATEGORY_CANDIDATES_DISPLAY = 12
+MAX_TOP_CANDIDATES_DISPLAY = 5
+SMILES_DISPLAY_LENGTH = 60
+MAX_TARGET_DISPLAY = 5
+
+# Chart heights
+CHART_HEIGHT_SMALL = 190
+CHART_HEIGHT_MEDIUM = 300
+CHART_HEIGHT_LARGE = 400
+
+# ========================================
+# HELPER FUNCTIONS
+# ========================================
+
+def get_status_badge(stage):
+    """Generate HTML badge for stage status"""
+    colors = STAGE_COLORS
+    names = STAGE_NAMES
+    
+    color = colors.get(stage, "#CBD5E0")
+    name = names.get(stage, stage)
+    
+    return f'<span style="background: {color}; padding: 5px 12px; border-radius: 15px; font-weight: bold; color: white; font-family: \'Times New Roman\', Times, serif;">{stage} - {name}</span>'
+
+
+def get_score_type_badge(score_type):
+    """Get badge for score type (Real ML/DL or Synthetic/AI)"""
+    if score_type == "Real":
+        return f'<span style="background: {UAB_DARK_GREEN}; padding: 4px 10px; border-radius: 10px; color: white; font-family: \'Times New Roman\', Times, serif; font-size: 11px;">🤖 Real ML/DL</span>'
+    else:
+        return f'<span style="background: #FFA500; padding: 4px 10px; border-radius: 10px; color: white; font-family: \'Times New Roman\', Times, serif; font-size: 11px;">🔮 Synthetic/AI</span>'
+
+
+def get_evidence_stars(score):
+    """Convert score to star rating"""
+    stars = int(score * 5)
+    return "⭐" * stars
+
+
+def get_impact_badge(impact):
+    """Generate HTML badge for project impact"""
+    if impact >= 0.10:
+        return f'<span style="background: {UAB_DARK_GREEN}; padding: 3px 10px; border-radius: 10px; color: white; font-family: \'Times New Roman\', Times, serif;">High +{impact:.2f}</span>'
+    elif impact >= 0.05:
+        return f'<span style="background: {UAB_GREEN}; padding: 3px 10px; border-radius: 10px; color: white; font-family: \'Times New Roman\', Times, serif;">Moderate +{impact:.2f}</span>'
+    elif impact > 0:
+        return f'<span style="background: #A0AEC0; padding: 3px 10px; border-radius: 10px; color: white; font-family: \'Times New Roman\', Times, serif;">Low +{impact:.2f}</span>'
+    elif impact <= -0.10:
+        return f'<span style="background: #DC2626; padding: 3px 10px; border-radius: 10px; color: white; font-family: \'Times New Roman\', Times, serif;">High Risk {impact:.2f}</span>'
+    elif impact <= -0.05:
+        return f'<span style="background: #EF4444; padding: 3px 10px; border-radius: 10px; color: white; font-family: \'Times New Roman\', Times, serif;">Moderate Risk {impact:.2f}</span>'
+    else:
+        return f'<span style="background: #F87171; padding: 3px 10px; border-radius: 10px; color: white; font-family: \'Times New Roman\', Times, serif;">Low Risk {impact:.2f}</span>'

data_generator.py

@@ -0,0 +1,363 @@
+"""
+Data Generator Module
+Extracted from sud_promise_uab_theme.py
+Handles disease ID mapping and synthetic data generation with real ML/DL scores
+"""
+
+import random
+from datetime import datetime, timedelta
+from dataclasses import dataclass, field
+from typing import List
+
+# Import dependencies
+from const_ui import (
+    UAB_GREEN, UAB_DARK_GREEN, UAB_LIGHT_GREEN, UAB_ACCENT_TEAL,
+    STAGE_MAPPING
+)
+from const_data import (
+    SUD_CATEGORY_DESCRIPTIONS, DISEASE_SEARCH_CONFIG,
+    DRUG_TEMPLATES, PROJECT_TEMPLATES
+)
+from func_drug import find_drug_in_database
+
+# ========================================
+# DATA MODELS
+# ========================================
+
+@dataclass
+class Project:
+    """Research project providing evidence"""
+    id: str
+    name: str
+    project_type: str
+    added_date: datetime
+    sample_size: int
+    impact_score: float
+    status: str
+    summary: str
+
+@dataclass
+class DrugCandidate:
+    """Drug being evaluated for repositioning"""
+    id: str
+    drug_name: str
+    current_indication: str
+    target_sud_subtype: str
+    mechanism: str
+    stage: str
+    evidence_score: float
+    baseline_score: float
+    smiles: str
+    attached_projects: List[Project]
+    last_updated: datetime
+    cohort_count: int
+    has_market_analysis: bool
+    has_validation_plan: bool
+    team_members: int
+    data_produced: int
+    publications: int
+    tools_used: int
+    data_governance: int
+    training_participated: int
+    stage_entry_date: datetime = None
+    stage_history: List[tuple] = field(default_factory=list)
+    score_type: str = "Synthetic"
+    model_scores: dict = field(default_factory=dict)
+    protein_targets: List[str] = field(default_factory=list)
+    disease_id: str = ""
+
+@dataclass
+class SUDCategory:
+    """SUD disease category"""
+    name: str
+    color: str
+    hex_color: str
+    icon: str
+    candidate_count: int
+    description: str
+    disease_id: str = ""
+
+# ========================================
+# DISEASE ID MAPPING
+# ========================================
+
+def setup_disease_mapping(diseases_df):
+    """Setup disease ID mapping from database"""
+    DISEASE_ID_MAPPING = {}
+    
+    if diseases_df is not None:
+        print("\n🔍 Searching for best disease name matches in database...")
+        
+        for category, config in DISEASE_SEARCH_CONFIG.items():
+            print(f"\n Searching for: {category}")
+            found = False
+            
+            for search_term in config["search_terms"]:
+                # Try exact match first
+                exact_mask = diseases_df['DiseaseName'].str.lower() == search_term.lower()
+                exact_matches = diseases_df[exact_mask]
+                
+                if len(exact_matches) > 0:
+                    disease_id = exact_matches.iloc[0]['DiseaseID']
+                    disease_name = exact_matches.iloc[0]['DiseaseName']
+                    DISEASE_ID_MAPPING[category] = disease_id
+                    print(f"    EXACT MATCH: '{disease_name}'")
+                    print(f"      → {disease_id}")
+                    found = True
+                    break
+                
+                # Try partial match if exact fails
+                partial_mask = diseases_df['DiseaseName'].str.lower().str.contains(search_term.lower(), na=False)
+                partial_matches = diseases_df[partial_mask]
+                
+                if len(partial_matches) > 0:
+                    disease_id = partial_matches.iloc[0]['DiseaseID']
+                    disease_name = partial_matches.iloc[0]['DiseaseName']
+                    DISEASE_ID_MAPPING[category] = disease_id
+                    print(f"    Partial match for '{search_term}': '{disease_name}'")
+                    print(f"      → {disease_id}")
+                    found = True
+                    break
+            
+            if not found:
+                print(f"    No matches found for {category}")
+        
+        print(f"\n{'='*80}")
+        print(f"📋 FINAL DISEASE MAPPING:")
+        print(f"{'='*80}")
+        for category, disease_id in DISEASE_ID_MAPPING.items():
+            disease_row = diseases_df[diseases_df['DiseaseID'] == disease_id]
+            if len(disease_row) > 0:
+                disease_name = disease_row.iloc[0]['DiseaseName']
+                print(f"{category}:")
+                print(f"   → {disease_id} ({disease_name})")
+        
+        print(f"\n Successfully mapped {len(DISEASE_ID_MAPPING)}/6 SUD categories\n")
+    
+    return DISEASE_ID_MAPPING
+
+# ========================================
+# SYNTHETIC DATA GENERATION WITH REAL ML/DL SCORES
+# ========================================
+
+def generate_synthetic_data(DISEASE_ID_MAPPING, MODELS_AVAILABLE, ml_components, drugs_df):
+    """Generate realistic synthetic SUD repositioning data with REAL ML/DL scores where possible"""
+    
+    # Import here to avoid circular dependency
+    from func_models import predict_with_ml_models
+    
+    print("\n" + "="*70)
+    print("🔬 GENERATING CANDIDATE DATA WITH ML/DL PREDICTIONS")
+    print("="*70)
+    
+    # Use corrected category names
+    sud_categories = [
+        SUDCategory("Opioid-Related Disorders", "", UAB_GREEN, "", 0, 
+                   SUD_CATEGORY_DESCRIPTIONS["Opioid-Related Disorders"],
+                   disease_id=DISEASE_ID_MAPPING.get("Opioid-Related Disorders", "")),
+        SUDCategory("Alcohol Use Disorder", "", UAB_ACCENT_TEAL, "", 0,
+                   SUD_CATEGORY_DESCRIPTIONS["Alcohol Use Disorder"],
+                   disease_id=DISEASE_ID_MAPPING.get("Alcohol Use Disorder", "")),
+        SUDCategory("Stimulant Use Disorder", "", UAB_LIGHT_GREEN, "", 0,
+                   SUD_CATEGORY_DESCRIPTIONS["Stimulant Use Disorder"],
+                   disease_id=DISEASE_ID_MAPPING.get("Stimulant Use Disorder", "")),
+        SUDCategory("Cannabis Use Disorder", "", UAB_DARK_GREEN, "", 0,
+                   SUD_CATEGORY_DESCRIPTIONS["Cannabis Use Disorder"],
+                   disease_id=DISEASE_ID_MAPPING.get("Cannabis Use Disorder", "")),
+        SUDCategory("Sedative/Hypnotic Disorder", "", "#4A8B7A", "", 0,
+                   SUD_CATEGORY_DESCRIPTIONS["Sedative/Hypnotic Disorder"],
+                   disease_id=DISEASE_ID_MAPPING.get("Sedative/Hypnotic Disorder", "")),
+        SUDCategory("Nicotine Use Disorder", "", "#2C7A64", "", 0,
+                   SUD_CATEGORY_DESCRIPTIONS["Nicotine Use Disorder"],
+                   disease_id=DISEASE_ID_MAPPING.get("Nicotine Use Disorder", "")),
+    ]
+    
+    candidates = []
+    candidate_id = 1
+    
+    total_real_scores = 0
+    total_synthetic_scores = 0
+    
+    for category in sud_categories:
+        if category.name not in DRUG_TEMPLATES:
+            continue
+        
+        category_real = 0
+        category_synthetic = 0
+        
+        print(f"\n🔬 Processing {category.name}...")
+        if category.disease_id:
+            print(f"   Disease ID: {category.disease_id}")
+        else:
+            print(f"     No disease ID mapped - using synthetic scores only")
+        
+        for drug_info in DRUG_TEMPLATES[category.name]:
+            drug_name, current_use, mechanism, stage = drug_info
+            
+            # Try to find drug in database using corrected function
+            drug_smiles, drug_targets = find_drug_in_database(drug_name, drugs_df)
+            
+            if not drug_smiles:
+                # Generate random SMILES if not found
+                drug_smiles = f"C{'C' * random.randint(5, 15)}N"
+                drug_targets = []
+                print(f"     {drug_name}: Not in database, using synthetic SMILES")
+            else:
+                print(f"    {drug_name}: Found in database")
+            
+            # Generate stage history
+            stage_num = int(stage[1])
+            stage_history = []
+            
+            days_in_pipeline = random.randint(360, 900)
+            start_date_candidate = datetime.now() - timedelta(days=days_in_pipeline)
+            
+            current_date = start_date_candidate
+            for s in range(stage_num + 1):
+                stage_name = f"S{s}"
+                days_in_stage = random.randint(60, 120)
+                stage_entry = current_date
+                stage_history.append((stage_name, stage_entry))
+                current_date = current_date + timedelta(days=days_in_stage)
+            
+            stage_entry_date = stage_history[-1][1] if stage_history else datetime.now()
+            
+            score_min, score_max = STAGE_MAPPING[stage]
+            baseline = random.uniform(0.40, 0.55)
+            
+            # Try to get REAL ML/DL scores
+            score_type = "Synthetic"
+            model_scores = {}
+            evidence_score = baseline
+            baseline_score = baseline  # Will be updated for Real predictions
+            
+            if category.disease_id and drug_smiles and MODELS_AVAILABLE:
+                print(f"      Predicting {drug_name} → {category.disease_id}...", end=" ")
+                ml_results, message, ml_score_type = predict_with_ml_models(
+                    drug_smiles, drug_targets, category.disease_id, ml_components
+                )
+                
+                if ml_results is not None and ml_score_type == "Real":
+                    score_type = "Real"
+                    model_scores = ml_results
+                    
+                    # FIXED: Use ensemble as BASELINE
+                    baseline_score = ml_results.get('Ensemble', baseline)
+                    
+                    # Calculate target evidence score
+                    num_projects = random.randint(3, 5)
+                    total_impact_needed = random.uniform(0.15, 0.35)  # Total impact from projects
+                    evidence_score = baseline_score + total_impact_needed
+                    evidence_score = max(0.20, min(0.95, evidence_score))
+                    
+                    # Recalculate actual impact needed after clamping
+                    total_impact_needed = evidence_score - baseline_score
+                    
+                    print(f" Real ML/DL: {baseline_score:.3f} → {evidence_score:.3f}")
+                    category_real += 1
+                    total_real_scores += 1
+                else:
+                    # Generate synthetic score with projects
+                    baseline_score = baseline
+                    num_projects = random.randint(3, 5)
+                    total_impact_needed = random.uniform(0.20, 0.40)
+                    evidence_score = baseline_score + total_impact_needed
+                    evidence_score = max(0.20, min(0.95, evidence_score))
+                    total_impact_needed = evidence_score - baseline_score
+                    
+                    print(f"  Synthetic score: {evidence_score:.3f} ({message})")
+                    category_synthetic += 1
+                    total_synthetic_scores += 1
+            else:
+                # Generate synthetic score
+                baseline_score = baseline
+                num_projects = random.randint(3, 5)
+                total_impact_needed = random.uniform(0.20, 0.40)
+                evidence_score = baseline_score + total_impact_needed
+                evidence_score = max(0.20, min(0.95, evidence_score))
+                total_impact_needed = evidence_score - baseline_score
+                
+                print(f"      {drug_name}: Synthetic score: {evidence_score:.3f}")
+                category_synthetic += 1
+                total_synthetic_scores += 1
+            
+            # NOW Generate projects with impacts that sum EXACTLY to total_impact_needed
+            projects = []
+            
+            # Distribute the total impact across projects
+            remaining_impact = total_impact_needed
+            for i in range(num_projects):
+                template = random.choice(PROJECT_TEMPLATES)
+                days_ago = random.randint(30 + i*50, days_in_pipeline - (num_projects - i)*30)
+                
+                if i == num_projects - 1:
+                    # Last project gets exactly the remaining impact
+                    impact = remaining_impact
+                else:
+                    # Random portion of remaining, but ensure we don't exhaust it
+                    max_this_impact = remaining_impact * 0.6  # Use at most 60% of remaining
+                    impact = random.uniform(-0.05, max_this_impact)
+                    remaining_impact -= impact
+                
+                project = Project(
+                    id=f"proj_{candidate_id}_{i}",
+                    name=template["name"],
+                    project_type=template["type"],
+                    added_date=datetime.now() - timedelta(days=days_ago),
+                    sample_size=random.randint(*template["size_range"]),
+                    impact_score=impact,  # Use calculated impact
+                    status="Completed" if random.random() > 0.2 else "Active",
+                    summary=template["summary"]
+                )
+                projects.append(project)
+            
+            # Sort by date
+            projects.sort(key=lambda p: p.added_date)
+            
+            stage_num = int(stage[1])
+            
+            candidate = DrugCandidate(
+                id=f"cand_{candidate_id}",
+                drug_name=drug_name,
+                current_indication=current_use,
+                target_sud_subtype=category.name,
+                mechanism=mechanism,
+                stage=stage,
+                evidence_score=evidence_score,
+                baseline_score=baseline_score,  # Now uses ensemble for Real scores
+                smiles=drug_smiles,
+                attached_projects=projects,
+                last_updated=datetime.now() - timedelta(days=random.randint(1, 30)),
+                cohort_count=random.randint(1 + stage_num, 4 + stage_num * 2),
+                has_market_analysis=random.random() > 0.3,
+                has_validation_plan=random.random() > 0.4,
+                team_members=random.randint(2 + stage_num, 5 + stage_num * 2),
+                data_produced=random.randint(1 + stage_num, 3 + stage_num * 2),
+                publications=random.randint(0 + stage_num // 2, 2 + stage_num),
+                tools_used=random.randint(1 + stage_num // 2, 3 + stage_num),
+                data_governance=random.randint(1, 2 + stage_num // 2),
+                training_participated=random.randint(stage_num, 2 + stage_num),
+                stage_entry_date=stage_entry_date,
+                stage_history=stage_history,
+                score_type=score_type,
+                model_scores=model_scores,
+                protein_targets=drug_targets,
+                disease_id=category.disease_id
+            )
+            candidates.append(candidate)
+            candidate_id += 1
+        
+        # Update category count
+        category.candidate_count = category_real + category_synthetic
+        print(f"   Summary: {category_real} real, {category_synthetic} synthetic")
+    
+    print(f"\n{'='*70}")
+    print(f" FINAL STATISTICS")
+    print(f"{'='*70}")
+    print(f"Total candidates: {len(candidates)}")
+    print(f"Real ML/DL scores: {total_real_scores}")
+    print(f"Synthetic scores: {total_synthetic_scores}")
+    print(f"Real score percentage: {total_real_scores / len(candidates) * 100:.1f}%")
+    print(f"{'='*70}\n")
+    
+    return sud_categories, candidates

func_drug.py

@@ -0,0 +1,210 @@
+"""
+Drug Database Utility Functions
+Handles searching and extracting drug information from the database
+"""
+
+import pandas as pd
+import ast
+from typing import Optional, List, Tuple
+
+
+def find_drug_in_database(drug_name: str, drugs_df: pd.DataFrame) -> Tuple[Optional[str], Optional[List[str]]]:
+    """
+    Extract SMILES and targets for a drug by EXACT name match first, then partial
+    
+    Args:
+        drug_name: Name of the drug to search for
+        drugs_df: DataFrame containing drug information with columns:
+                 - DrugName: name of the drug
+                 - DrugSmile: SMILES structure
+                 - DrugTarget: protein targets (as string representation of list)
+    
+    Returns:
+        Tuple of (smiles, targets):
+        - smiles: SMILES string representation of molecular structure, or None if not found
+        - targets: List of protein target names, or empty list if none found
+        
+    Examples:
+        >>> smiles, targets = find_drug_in_database("Naltrexone", drugs_df)
+        >>> print(f"SMILES: {smiles}")
+        >>> print(f"Targets: {targets}")
+    """
+    if drugs_df is None:
+        return None, None
+    
+    # Try EXACT match first (case-insensitive)
+    mask = drugs_df['DrugName'].str.lower() == drug_name.lower()
+    matches = drugs_df[mask]
+    
+    # If no exact match, try partial match
+    if len(matches) == 0:
+        mask = drugs_df['DrugName'].str.lower().str.contains(drug_name.lower(), na=False)
+        matches = drugs_df[mask]
+    
+    if len(matches) == 0:
+        return None, None
+    
+    # Get the first match
+    row = matches.iloc[0]
+    
+    # Extract SMILES - try multiple possible column names
+    smiles = None
+    smiles_columns = ['DrugSmile', 'SMILES', 'Smiles', 'smiles', 'DrugSMILES', 'Structure']
+    for col in smiles_columns:
+        if col in row.index and pd.notna(row[col]) and str(row[col]).strip():
+            smiles = str(row[col]).strip()
+            break
+    
+    # Extract Targets - try multiple possible column names
+    targets = []
+    target_columns = ['DrugTarget', 'Targets', 'Target', 'targets', 'ProteinTargets']
+    for col in target_columns:
+        if col in row.index and pd.notna(row[col]) and str(row[col]).strip():
+            raw_targets = str(row[col]).strip()
+            
+            # Parse if it's a string representation of a list
+            if raw_targets.startswith('[') and raw_targets.endswith(']'):
+                try:
+                    targets = ast.literal_eval(raw_targets)
+                except:
+                    targets = [raw_targets]
+            elif ',' in raw_targets:
+                # Handle comma-separated targets
+                targets = [t.strip() for t in raw_targets.split(',')]
+            else:
+                # Single target
+                targets = [raw_targets]
+            break
+    
+    return smiles, targets if targets else []
+
+
+def search_drugs_by_target(target_name: str, drugs_df: pd.DataFrame, 
+                           exact_match: bool = False) -> pd.DataFrame:
+    """
+    Search for drugs that target a specific protein
+    
+    Args:
+        target_name: Name of the protein target to search for
+        drugs_df: DataFrame containing drug information
+        exact_match: If True, only return exact matches; if False, use partial matching
+    
+    Returns:
+        DataFrame containing all drugs that target the specified protein
+    """
+    if drugs_df is None:
+        return pd.DataFrame()
+    
+    def has_target(targets_str):
+        if pd.isna(targets_str):
+            return False
+        
+        # Parse targets
+        targets = []
+        if str(targets_str).startswith('['):
+            try:
+                targets = ast.literal_eval(str(targets_str))
+            except:
+                targets = [str(targets_str)]
+        else:
+            targets = [str(targets_str)]
+        
+        # Check if target matches
+        for target in targets:
+            if exact_match:
+                if target.lower() == target_name.lower():
+                    return True
+            else:
+                if target_name.lower() in target.lower():
+                    return True
+        return False
+    
+    mask = drugs_df['DrugTarget'].apply(has_target)
+    return drugs_df[mask]
+
+
+def get_drug_info(drug_name: str, drugs_df: pd.DataFrame) -> dict:
+    """
+    Get complete information about a drug
+    
+    Args:
+        drug_name: Name of the drug
+        drugs_df: DataFrame containing drug information
+    
+    Returns:
+        Dictionary with drug information including:
+        - name: Drug name
+        - smiles: SMILES structure
+        - targets: List of protein targets
+        - found: Boolean indicating if drug was found
+    """
+    smiles, targets = find_drug_in_database(drug_name, drugs_df)
+    
+    return {
+        'name': drug_name,
+        'smiles': smiles,
+        'targets': targets if targets else [],
+        'found': smiles is not None
+    }
+
+
+def validate_smiles(smiles: str) -> bool:
+    """
+    Validate if a SMILES string is valid (requires RDKit)
+    
+    Args:
+        smiles: SMILES string to validate
+    
+    Returns:
+        True if valid, False otherwise
+    """
+    try:
+        from rdkit import Chem
+        mol = Chem.MolFromSmiles(smiles)
+        return mol is not None
+    except:
+        return False
+
+
+# Example usage and testing
+if __name__ == "__main__":
+    # Load example data
+    try:
+        drugs_df = pd.read_csv("data1/drugsInfo.csv")
+        print(f" Loaded {len(drugs_df)} drugs from database\n")
+        
+        # Test 1: Find a specific drug
+        print("="*60)
+        print("TEST 1: Find Naltrexone")
+        print("="*60)
+        smiles, targets = find_drug_in_database("Naltrexone", drugs_df)
+        if smiles:
+            print(f" Found!")
+            print(f"   SMILES: {smiles[:60]}...")
+            print(f"   Targets: {targets[:3]}{'...' if len(targets) > 3 else ''}")
+        else:
+            print(f"❌ Not found")
+        
+        # Test 2: Get complete info
+        print("\n" + "="*60)
+        print("TEST 2: Get complete drug info")
+        print("="*60)
+        info = get_drug_info("Buprenorphine", drugs_df)
+        print(f"Drug: {info['name']}")
+        print(f"Found: {info['found']}")
+        print(f"Targets: {len(info['targets'])} targets")
+        
+        # Test 3: Search by target
+        print("\n" + "="*60)
+        print("TEST 3: Search drugs targeting opioid receptors")
+        print("="*60)
+        results = search_drugs_by_target("opioid", drugs_df, exact_match=False)
+        print(f"Found {len(results)} drugs")
+        if len(results) > 0:
+            print("Examples:")
+            for i, (idx, row) in enumerate(results.head(3).iterrows(), 1):
+                print(f"   {i}. {row['DrugName']}")
+        
+    except FileNotFoundError:
+        print("❌ Error: data1/drugsInfo.csv not found")
+        print("   Make sure the database file exists in the correct location")

func_models.py

@@ -0,0 +1,440 @@
+"""
+ML/DL Prediction Utilities
+Functions for making predictions with trained ML/DL models
+
+VERSION: 3.5.0 - Single initialization function for easy integration
+- Added initialize_ml_system() function
+- Consolidates all loading logic
+- Returns complete system state
+- Uses const_config for default paths
+"""
+
+import numpy as np
+import pandas as pd
+from pathlib import Path
+from typing import Tuple, Dict, List, Optional
+import joblib
+
+# Import configuration constants
+from const_config import MODEL_DIR, DRUGS_FILE, DISEASES_FILE
+
+def initialize_ml_system(model_dir: str = MODEL_DIR,
+                         drugs_file: str = DRUGS_FILE,
+                         diseases_file: str = DISEASES_FILE) -> Dict:
+    """
+    Initialize the complete ML/DL prediction system
+    
+    This single function replaces all the initialization code in the main script.
+    It loads CSV datasets and ML/DL models, handling all errors gracefully.
+    
+    Args:
+        model_dir: Path to directory containing model files (default from const_config.MODEL_DIR)
+        drugs_file: Path to drugs CSV file (default from const_config.DRUGS_FILE)
+        diseases_file: Path to diseases CSV file (default from const_config.DISEASES_FILE)
+        
+    Returns:
+        Dictionary containing:
+        - 'models_available': bool - Whether ML/DL models loaded successfully
+        - 'ml_components': dict - Loaded models and preprocessors
+        - 'drugs_df': DataFrame or None - Drugs database
+        - 'diseases_df': DataFrame or None - Diseases database
+    """
+    
+    result = {
+        'models_available': False,
+        'ml_components': {},
+        'drugs_df': None,
+        'diseases_df': None
+    }
+    
+    try:
+        # Suppress RDKit warnings
+        from rdkit import RDLogger
+        RDLogger.DisableLog('rdApp.*')
+        
+        # Suppress TensorFlow warnings
+        try:
+            import tensorflow as tf
+            tf.get_logger().setLevel('ERROR')
+        except:
+            pass
+        
+        # Load CSV datasets
+        print(" Loading drug and disease datasets...")
+        try:
+            result['drugs_df'] = pd.read_csv(drugs_file)
+            result['diseases_df'] = pd.read_csv(diseases_file)
+            print(f" Loaded {len(result['drugs_df'])} drugs and {len(result['diseases_df'])} diseases")
+        except Exception as e:
+            print(f"  Could not load CSV files: {e}")
+            print("   Continuing without drug/disease databases")
+        
+        # Load ML/DL models
+        model_path = Path(model_dir)
+        
+        if not model_path.exists():
+            print(f"  ML/DL models directory not found: {model_path}")
+            print("   Using synthetic scores only.")
+            return result
+        
+        print(f"\n Loading ML/DL models from: {model_path}")
+        success, ml_components = load_ml_models(model_path)
+        
+        if success:
+            result['models_available'] = True
+            result['ml_components'] = ml_components
+            print("\n ML/DL Models loaded successfully!")
+            print(f"   Available diseases in model: {len(ml_components['le_disease'].classes_)}")
+            print(f"   Available targets in model: {len(ml_components['mlb'].classes_)}")
+        else:
+            print("\n  ML/DL models not found. Using synthetic scores only.")
+        
+    except Exception as e:
+        print(f"\n  Error during ML system initialization: {e}")
+        print("   Using synthetic scores only.")
+        
+        # Try to at least load CSV files if models failed
+        if result['drugs_df'] is None:
+            try:
+                result['drugs_df'] = pd.read_csv(drugs_file)
+                result['diseases_df'] = pd.read_csv(diseases_file)
+                print(f" Loaded {len(result['drugs_df'])} drugs and {len(result['diseases_df'])} diseases (without ML models)")
+            except:
+                print(" Could not load CSV files either. Using fully synthetic data.")
+    
+    return result
+
+
+def load_ml_models(model_dir: Path) -> Tuple[bool, Dict]:
+    """
+    Load all ML/DL models and preprocessors with detailed error reporting
+    
+    Args:
+        model_dir: Path to directory containing model files
+        
+    Returns:
+        Tuple of (success: bool, ml_components: dict)
+    """
+    try:
+        from tensorflow import keras
+        from rdkit import Chem
+        from rdkit.Chem import AllChem
+        
+        ml_components = {}
+        
+        print(f"\n Loading models from: {model_dir.absolute()}")
+        
+        # Define all model files
+        model_files = {
+            'lr_model': ('logistic_regression.pkl', 'joblib'),
+            'rf_model': ('random_forest.pkl', 'joblib'),
+            'dnn_model': ('mm_dnn_model.keras', 'keras'),
+            'mlb': ('target_binarizer.pkl', 'joblib'),
+            'le_disease': ('disease_encoder.pkl', 'joblib'),
+            'disease_ohe_df': ('disease_ohe_df.pkl', 'pandas'),  #  Special handling
+            'scaler': ('scaler.pkl', 'joblib'),
+        }
+        
+        # Load each file with individual error handling
+        for component_name, (filename, file_type) in model_files.items():
+            file_path = model_dir / filename
+            
+            if not file_path.exists():
+                print(f"     {filename}: File not found, skipping...")
+                continue
+            
+            try:
+                if file_type == 'joblib':
+                    #  FIXED: Use joblib for sklearn models
+                    ml_components[component_name] = joblib.load(file_path)
+                    print(f"    {filename}: Loaded successfully")
+                    
+                elif file_type == 'pandas':
+                    #  FIXED: Use pd.read_pickle for pandas DataFrames
+                    ml_components[component_name] = pd.read_pickle(file_path)
+                    print(f"    {filename}: Loaded successfully")
+                    
+                elif file_type == 'keras':
+                    ml_components[component_name] = keras.models.load_model(str(file_path))
+                    print(f"    {filename}: Loaded successfully")
+                    
+            except Exception as e:
+                print(f"    {filename}: Failed to load")
+                print(f"      Error: {e}")
+                # Continue loading other files
+                continue
+        
+        # Check all required components are loaded
+        required = ['lr_model', 'rf_model', 'dnn_model', 'mlb', 'le_disease', 'scaler']
+        missing = [k for k in required if k not in ml_components]
+        
+        if missing:
+            print(f"\n  Missing required components: {missing}")
+            return False, {}
+        else:
+            print(f"\n All required components loaded successfully!")
+            return True, ml_components
+            
+    except ImportError as e:
+        print(f" Import error: {e}")
+        print("   Make sure tensorflow and rdkit are installed:")
+        print("   pip install tensorflow rdkit --break-system-packages")
+        return False, {}
+    except Exception as e:
+        print(f" Unexpected error loading ML models: {e}")
+        import traceback
+        traceback.print_exc()
+        return False, {}
+
+
+def prepare_drug_features(drug_smiles: str, drug_targets: List[str], mlb) -> Optional[np.ndarray]:
+    """
+    Prepare drug features from SMILES and targets
+    
+    Args:
+        drug_smiles: SMILES string of the drug
+        drug_targets: List of protein target names
+        mlb: MultiLabelBinarizer for targets
+        
+    Returns:
+        Feature vector or None if error
+    """
+    try:
+        from rdkit import Chem
+        from rdkit.Chem import AllChem
+        
+        # Generate Morgan fingerprint
+        mol = Chem.MolFromSmiles(drug_smiles)
+        if mol is None:
+            return None
+            
+        fp = AllChem.GetMorganFingerprintAsBitVect(mol, radius=2, nBits=1024)
+        fp_array = np.array(fp)
+        
+        # Encode targets
+        if drug_targets:
+            target_encoded = mlb.transform([drug_targets])
+        else:
+            target_encoded = mlb.transform([[]])
+        
+        # Concatenate features
+        features = np.concatenate([fp_array, target_encoded[0]])
+        
+        return features
+        
+    except Exception as e:
+        print(f"Error preparing drug features: {e}")
+        return None
+
+
+def predict_with_ml_models(drug_smiles: str, 
+                           drug_targets: List[str], 
+                           disease_id: str, 
+                           ml_components: Dict) -> Tuple[Optional[Dict], str, str]:
+    """
+    Make predictions using ML/DL models
+    
+    Args:
+        drug_smiles: SMILES string of drug
+        drug_targets: List of protein targets
+        disease_id: Disease ID (e.g., 'MESH:D009293')
+        ml_components: Dictionary containing loaded models and preprocessors
+        
+    Returns:
+        Tuple of (results_dict, message, score_type)
+        - results_dict: {'LR': score, 'RF': score, 'DNN': score, 'Ensemble': score} or None
+        - message: Status message
+        - score_type: 'Real' or 'Synthetic'
+    """
+    try:
+        # Validate inputs
+        if not drug_smiles or not disease_id:
+            return None, "Missing drug SMILES or disease ID", "Synthetic"
+        
+        if not ml_components:
+            return None, "ML models not available", "Synthetic"
+        
+        # Convert disease classes to list and check membership
+        disease_classes = ml_components['le_disease'].classes_
+        if isinstance(disease_classes, pd.Series):
+            disease_classes = disease_classes.tolist()
+        elif isinstance(disease_classes, np.ndarray):
+            disease_classes = disease_classes.tolist()
+        else:
+            disease_classes = list(disease_classes)
+        
+        # Check membership in Python list
+        if disease_id not in disease_classes:
+            return None, f"Disease {disease_id} not in training data", "Synthetic"
+        
+        # Prepare drug features
+        drug_features = prepare_drug_features(drug_smiles, drug_targets, ml_components['mlb'])
+        if drug_features is None:
+            return None, "Failed to generate drug features", "Synthetic"
+        
+        # Encode disease (for DNN input)
+        disease_encoded = ml_components['le_disease'].transform([disease_id])
+        
+        #  FIXED: Get disease OHE and drop 'DiseaseID' column (matching working code)
+        if 'disease_ohe_df' in ml_components:
+            disease_ohe_df = ml_components['disease_ohe_df']
+            
+            # Use the exact approach from sud_promise_uab_theme.py line 259
+            disease_matches = disease_ohe_df[disease_ohe_df['DiseaseID'] == disease_id]
+            if len(disease_matches) == 0:
+                return None, f"Disease ID '{disease_id}' not found in disease_ohe_df", "Synthetic"
+            
+            #  CRITICAL: Drop DiseaseID column before getting values
+            disease_ohe = disease_matches.drop('DiseaseID', axis=1).values
+        else:
+            return None, "disease_ohe_df not loaded", "Synthetic"
+        
+        #  FIXED: Prepare full feature vector for ML models (LR, RF)
+        # Drug features (1024 + target_dim) + disease OHE (should give 4615 total)
+        X_combined = np.concatenate([
+            drug_features.reshape(1, -1),
+            disease_ohe  #  This is the full one-hot vector WITHOUT DiseaseID column
+        ], axis=1)
+        
+        # Scale features for LR (RF might not need it, check your training)
+        if 'scaler' in ml_components:
+            X_scaled = ml_components['scaler'].transform(X_combined)
+        else:
+            X_scaled = X_combined
+        
+        # Make predictions with each model
+        results = {}
+        
+        # Logistic Regression (uses scaled features)
+        if 'lr_model' in ml_components:
+            try:
+                lr_pred = ml_components['lr_model'].predict_proba(X_scaled)[0][1]
+                results['Logistic Regression'] = float(lr_pred)
+            except Exception as e:
+                print(f"   LR prediction failed: {e}")
+        
+        # Random Forest (check if it needs scaled or unscaled)
+        # Based on working code, RF uses unscaled ml_input
+        if 'rf_model' in ml_components:
+            try:
+                rf_pred = ml_components['rf_model'].predict_proba(X_combined)[0][1]
+                results['Random Forest'] = float(rf_pred)
+            except Exception as e:
+                print(f"   RF prediction failed: {e}")
+        
+        #  FIXED: Deep Neural Network uses different input format
+        # DNN takes [drug_features, disease_index] as separate inputs
+        if 'dnn_model' in ml_components:
+            try:
+                disease_idx_arr = np.array([disease_encoded[0]], dtype=np.int32)
+                dnn_pred = ml_components['dnn_model'].predict(
+                    [drug_features.reshape(1, -1), disease_idx_arr], 
+                    verbose=0
+                )[0][0]
+                results['MM-DNN'] = float(dnn_pred)
+            except Exception as e:
+                print(f"   DNN prediction failed: {e}")
+        
+        # Calculate ensemble (average of all models)
+        if results:
+            ensemble_score = np.mean(list(results.values()))
+            results['Ensemble'] = float(ensemble_score)
+            
+            return results, " Prediction successful", "Real"
+        else:
+            return None, "No models available for prediction", "Synthetic"
+            
+    except Exception as e:
+        import traceback
+        error_msg = f"Prediction error: {str(e)}"
+        # Uncomment for debugging:
+        print(f"\n🔍 DETAILED ERROR:")
+        print(traceback.format_exc())
+        return None, error_msg, "Synthetic"
+
+
+def get_ensemble_prediction(results: Dict) -> float:
+    """Get ensemble prediction from model results"""
+    if not results:
+        return 0.5
+    
+    if 'Ensemble' in results:
+        return results['Ensemble']
+    
+    scores = [v for k, v in results.items() if k != 'Ensemble']
+    if scores:
+        return np.mean(scores)
+    else:
+        return 0.5
+
+
+def interpret_prediction_score(score: float) -> Tuple[str, str, str]:
+    """Interpret prediction score"""
+    if score >= 0.7:
+        return "HIGH", "🟢", "Strong therapeutic potential"
+    elif score >= 0.5:
+        return "MODERATE", "🟡", "Mixed evidence, further investigation needed"
+    else:
+        return "LOW", "🔴", "Limited evidence for this indication"
+
+
+def batch_predict(drug_disease_pairs: List[Tuple[str, List[str], str]], 
+                  ml_components: Dict) -> List[Dict]:
+    """Make predictions for multiple drug-disease pairs"""
+    results = []
+    
+    for drug_smiles, drug_targets, disease_id in drug_disease_pairs:
+        pred_results, message, score_type = predict_with_ml_models(
+            drug_smiles, drug_targets, disease_id, ml_components
+        )
+        
+        results.append({
+            'drug_smiles': drug_smiles,
+            'disease_id': disease_id,
+            'predictions': pred_results,
+            'message': message,
+            'score_type': score_type
+        })
+    
+    return results
+
+
+if __name__ == "__main__":
+    print("="*70)
+    print("ML PREDICTION UTILITIES - TESTING")
+    print("="*70)
+    
+    #  NEW: Single function call uses defaults from const_config
+    # No need to specify paths - they're already in const_config!
+    system = initialize_ml_system()
+    
+    print("\n" + "="*70)
+    print("SYSTEM STATUS")
+    print("="*70)
+    print(f"Models Available: {system['models_available']}")
+    print(f"Drugs Database: {' Loaded' if system['drugs_df'] is not None else ' Not loaded'}")
+    print(f"Diseases Database: {' Loaded' if system['diseases_df'] is not None else ' Not loaded'}")
+    
+    if system['models_available']:
+        print("\n ALL TESTS PASSED")
+        
+        # Test feature dimensions
+        print("\n🔍 Testing feature dimensions...")
+        test_smiles = "CC(C)NCC(COc1ccccc1)O"  # Example SMILES
+        test_targets = []
+        test_disease = list(system['ml_components']['le_disease'].classes_)[0]
+        
+        results, msg, score_type = predict_with_ml_models(
+            test_smiles, test_targets, test_disease, system['ml_components']
+        )
+        
+        if results:
+            print(f" Prediction successful!")
+            print(f"   Score Type: {score_type}")
+            print(f"   Results: {results}")
+        else:
+            print(f"  Prediction failed: {msg}")
+    else:
+        print("\n  MODEL LOADING FAILED - System will use synthetic scores")
+    
+    print("="*70)

module_dashboard.py

@@ -0,0 +1,395 @@
+"""
+Executive Dashboard Functions
+Handles KPI calculations, metrics, and dashboard visualizations
+
+VERSION: 1.0.0 - Modularized dashboard functionality
+"""
+
+import plotly.graph_objects as go
+from datetime import datetime, timedelta
+from typing import List, Dict
+
+# Import constants
+from const_ui import (
+    UAB_GREEN, UAB_DARK_GREEN, UAB_LIGHT_GREEN, UAB_PALE_GREEN,
+    CHART_HEIGHT_SMALL, CHART_HEIGHT_MEDIUM
+)
+
+from const_data import (
+    AVERAGE_TIME_TO_IND, CURRENT_IND_READY_COUNT,
+    TIME_BINS_LABELS, TIME_BINS_COUNTS, QUARTERLY_DELIVERIES
+)
+
+
+def calculate_executive_metrics(candidates: List, categories: List, models_available: bool) -> Dict:
+    """
+    Calculate KPIs for executive dashboard
+    
+    Args:
+        candidates: List of DrugCandidate objects
+        categories: List of SUDCategory objects
+        models_available: Whether ML/DL models are loaded
+        
+    Returns:
+        Dictionary containing all executive metrics
+    """
+    total_candidates = len(candidates)
+    active_projects = sum(len(c.attached_projects) for c in candidates)
+    total_cohorts = sum(c.cohort_count for c in candidates)
+    num_sud_types = len(categories)
+    
+    avg_time_ind = AVERAGE_TIME_TO_IND
+    quarterly_deliveries = QUARTERLY_DELIVERIES
+    
+    # Count real vs synthetic scores
+    real_scores = sum(1 for c in candidates if c.score_type == "Real")
+    synthetic_scores = total_candidates - real_scores
+    
+    return {
+        'total_candidates': total_candidates,
+        'active_projects': active_projects,
+        'total_cohorts': total_cohorts,
+        'num_sud_types': num_sud_types,
+        'avg_time_ind_ready': avg_time_ind,
+        'quarterly_deliveries': quarterly_deliveries,
+        'real_scores': real_scores,
+        'synthetic_scores': synthetic_scores
+    }
+
+
+def calculate_stage_distribution_over_time(candidates: List) -> List[Dict]:
+    """
+    Calculate stage distribution over last 12 months
+    
+    Args:
+        candidates: List of DrugCandidate objects
+        
+    Returns:
+        List of dictionaries containing stage counts per month
+    """
+    months = []
+    current_date = datetime.now()
+    
+    for i in range(12):
+        month_date = current_date - timedelta(days=i*30)
+        month_name = month_date.strftime('%b')
+        
+        stage_counts = {f'S{i}': 0 for i in range(7)}
+        
+        for candidate in candidates:
+            candidate_stage = 'S0'
+            for stage, date in candidate.stage_history:
+                if date <= month_date:
+                    candidate_stage = stage
+                else:
+                    break
+            stage_counts[candidate_stage] += 1
+        
+        months.append({
+            'month': month_name,
+            'date': month_date,
+            **stage_counts
+        })
+    
+    return list(reversed(months))
+
+
+def calculate_portfolio_breakdown(candidates: List, categories: List) -> List[Dict]:
+    """
+    Calculate active portfolio breakdown by SUD category
+    
+    Args:
+        candidates: List of DrugCandidate objects
+        categories: List of SUDCategory objects
+        
+    Returns:
+        List of dictionaries containing category breakdown
+    """
+    breakdown = []
+    for category in categories:
+        count = len([c for c in candidates if c.target_sud_subtype == category.name])
+        if count > 0:
+            breakdown.append({
+                'category': category.name,
+                'count': count,
+                'color': category.hex_color
+            })
+    
+    return breakdown
+
+
+def create_time_to_ind_distribution() -> go.Figure:
+    """
+    Create bar chart showing distribution of time to IND-ready
+    
+    Returns:
+        Plotly figure object
+    """
+    bin_labels = TIME_BINS_LABELS
+    bin_counts = TIME_BINS_COUNTS
+
+    colors = [
+        UAB_LIGHT_GREEN,
+        '#4A9B7A',
+        UAB_GREEN,
+        '#1E7B52',
+        UAB_DARK_GREEN,
+        '#16533E',
+        '#0F3E2E'
+    ]
+
+    y_max = max(bin_counts)
+
+    fig = go.Figure()
+    fig.add_trace(go.Bar(
+        x=bin_labels,
+        y=bin_counts,
+        marker_color=colors,
+        text=bin_counts,
+        textposition='outside',
+        textfont=dict(size=11, color=UAB_DARK_GREEN),
+        cliponaxis=False,
+        showlegend=False
+    ))
+
+    fig.update_layout(
+        title="Distribution 12 months",
+        xaxis_title="Months",
+        height=CHART_HEIGHT_SMALL,
+        margin=dict(l=25, r=10, t=55, b=45),
+        plot_bgcolor='#F0F9F6',
+        paper_bgcolor='white',
+        font=dict(family="Times New Roman, serif", color=UAB_DARK_GREEN, size=12),
+        showlegend=False,
+        yaxis=dict(
+            showticklabels=False,
+            showgrid=False,
+            zeroline=False,
+            range=[0, y_max * 1.18],
+        )
+    )
+
+    return fig
+
+
+def create_quarterly_deliveries_chart(quarterly_data: List[Dict]) -> go.Figure:
+    """
+    Create line chart showing quarterly IND-ready deliveries
+    
+    Args:
+        quarterly_data: List of quarterly delivery metrics
+        
+    Returns:
+        Plotly figure object
+    """
+    labels = [q['quarter'] for q in quarterly_data]
+    cumulative = [q['cumulative'] for q in quarterly_data]
+
+    display_percentages = ['0%', '4%', '6.5%', '20%', '21%', '14.5%'][:len(labels)]
+
+    y_max = max(cumulative) if cumulative else 1.0
+
+    fig = go.Figure()
+
+    fig.add_trace(go.Scatter(
+        x=labels,
+        y=cumulative,
+        mode='lines+markers+text',
+        line=dict(color=UAB_GREEN, width=3),
+        marker=dict(size=11, color=UAB_GREEN),
+        text=display_percentages,
+        textposition='top center',
+        textfont=dict(size=12, family="Times New Roman, serif", color=UAB_DARK_GREEN),
+        cliponaxis=False,
+        showlegend=False
+    ))
+
+    fig.update_layout(
+        title="% IND-Ready Start",
+        xaxis_title="",
+        yaxis_title="Cumulative",
+        height=CHART_HEIGHT_SMALL,
+        margin=dict(l=55, r=15, t=55, b=45),
+        plot_bgcolor='#F0F9F6',
+        paper_bgcolor='white',
+        font=dict(family="Times New Roman, serif", color=UAB_DARK_GREEN, size=12),
+        showlegend=False,
+        yaxis=dict(
+            range=[0, y_max * 1.35],
+            showgrid=True,
+            gridcolor="rgba(30,107,82,0.12)",
+            zeroline=False
+        )
+    )
+
+    return fig
+
+
+def create_pipeline_progression_chart(stage_data: List[Dict]) -> go.Figure:
+    """
+    Create stacked area chart for pipeline progression over time
+    
+    Args:
+        stage_data: List of stage distribution data by month
+        
+    Returns:
+        Plotly figure object
+    """
+    months = [d['month'] for d in stage_data]
+    
+    fig = go.Figure()
+    
+    stages = ['S0', 'S1', 'S2', 'S3', 'S4', 'S5', 'S6']
+    colors_map = {
+        'S0': '#CBD5E0',
+        'S1': '#A0AEC0',
+        'S2': UAB_LIGHT_GREEN,
+        'S3': UAB_GREEN,
+        'S4': UAB_GREEN,
+        'S5': UAB_DARK_GREEN,
+        'S6': UAB_DARK_GREEN,
+    }
+    
+    for stage in stages:
+        values = [d[stage] for d in stage_data]
+        fig.add_trace(go.Scatter(
+            x=months,
+            y=values,
+            mode='lines',
+            name=stage,
+            stackgroup='one',
+            fillcolor=colors_map[stage],
+            line=dict(width=0.5, color=colors_map[stage]),
+        ))
+    
+    fig.update_layout(
+        title="",
+        xaxis_title="",
+        yaxis_title="Candidates",
+        height=CHART_HEIGHT_MEDIUM,
+        margin=dict(l=40, r=20, t=50, b=40),
+        plot_bgcolor='white',
+        paper_bgcolor='white',
+        font=dict(family="Times New Roman, serif", color=UAB_DARK_GREEN, size=10),
+        legend=dict(
+            orientation="h",
+            yanchor="bottom",
+            y=1.02,
+            xanchor="right",
+            x=1
+        ),
+        hovermode='x unified'
+    )
+    
+    return fig
+
+
+def create_portfolio_breakdown_chart(breakdown_data: List[Dict]) -> go.Figure:
+    """
+    Create donut chart for active portfolio breakdown by SUD category
+    
+    Args:
+        breakdown_data: List of category breakdowns
+        
+    Returns:
+        Plotly figure object
+    """
+    labels = [d['category'] for d in breakdown_data]
+    values = [d['count'] for d in breakdown_data]
+    colors = [d['color'] for d in breakdown_data]
+    
+    fig = go.Figure(data=[go.Pie(
+        labels=labels,
+        values=values,
+        marker=dict(colors=colors),
+        textinfo='label+percent',
+        textposition='auto',
+        textfont=dict(size=10, family="Times New Roman, serif"),
+        hole=0.4
+    )])
+    
+    fig.update_layout(
+        title="",
+        height=CHART_HEIGHT_MEDIUM,
+        margin=dict(l=20, r=20, t=50, b=20),
+        paper_bgcolor='white',
+        font=dict(family="Times New Roman, serif", color=UAB_DARK_GREEN, size=10),
+        showlegend=True,
+        legend=dict(
+            orientation="v",
+            yanchor="middle",
+            y=0.5,
+            xanchor="left",
+            x=1.05,
+            font=dict(size=9)
+        )
+    )
+    
+    return fig
+
+
+def render_executive_dashboard(candidates: List, categories: List, models_available: bool) -> tuple:
+    """
+    Render complete executive dashboard with all components
+    
+    Args:
+        candidates: List of DrugCandidate objects
+        categories: List of SUDCategory objects
+        models_available: Whether ML/DL models are loaded
+        
+    Returns:
+        Tuple of (html, time_fig, quarterly_fig, pipeline_fig, portfolio_fig, avg_time, ind_ready)
+    """
+    # Calculate all metrics
+    metrics = calculate_executive_metrics(candidates, categories, models_available)
+    stage_data = calculate_stage_distribution_over_time(candidates)
+    breakdown_data = calculate_portfolio_breakdown(candidates, categories)
+    
+    # Create all charts
+    time_dist_fig = create_time_to_ind_distribution()
+    quarterly_fig = create_quarterly_deliveries_chart(metrics['quarterly_deliveries'])
+    pipeline_fig = create_pipeline_progression_chart(stage_data)
+    portfolio_fig = create_portfolio_breakdown_chart(breakdown_data)
+    
+    current_ind_ready = CURRENT_IND_READY_COUNT
+    
+    # Add ML/DL status indicator
+    ml_color = UAB_GREEN if models_available else "#FFA500"
+    
+    # Generate HTML
+    html = f"""
+    <div style="padding: 15px; font-family: 'Times New Roman', Times, serif;">
+        <h2 style="color: {UAB_DARK_GREEN}; margin: 0 0 15px 0; font-size: 18px;">Executive Dashboard: SUD Repositioning KPI Overview</h2>
+        
+        <!-- Top Row: 4 Metrics -->
+        <div style="display: grid; grid-template-columns: repeat(4, 1fr); gap: 15px; margin-bottom: 20px;">
+            <div style="background: linear-gradient(135deg, {UAB_GREEN} 0%, {UAB_DARK_GREEN} 100%); padding: 20px; border-radius: 10px; color: white; text-align: center; box-shadow: 0 2px 4px rgba(30,107,82,0.3);">
+                <h2 style="margin: 0; font-size: 32px; color: white;">{metrics['total_candidates']}</h2>
+                <p style="margin: 5px 0 0 0; font-size: 12px; opacity: 0.9; color: white;">Drug Candidates</p>
+            </div>
+            <div style="background: linear-gradient(135deg, {UAB_GREEN} 0%, {UAB_DARK_GREEN} 100%); padding: 20px; border-radius: 10px; color: white; text-align: center; box-shadow: 0 2px 4px rgba(30,107,82,0.3);">
+                <h2 style="margin: 0; font-size: 32px; color: white;">{metrics['active_projects']}</h2>
+                <p style="margin: 5px 0 0 0; font-size: 12px; opacity: 0.9; color: white;">Evidence Projects</p>
+            </div>
+            <div style="background: linear-gradient(135deg, {UAB_GREEN} 0%, {UAB_DARK_GREEN} 100%); padding: 20px; border-radius: 10px; color: white; text-align: center; box-shadow: 0 2px 4px rgba(30,107,82,0.3);">
+                <h2 style="margin: 0; font-size: 32px; color: white;">{metrics['total_cohorts']}</h2>
+                <p style="margin: 5px 0 0 0; font-size: 12px; opacity: 0.9; color: white;">Patient Cohorts</p>
+            </div>
+            <div style="background: linear-gradient(135deg, {UAB_GREEN} 0%, {UAB_DARK_GREEN} 100%); padding: 20px; border-radius: 10px; color: white; text-align: center; box-shadow: 0 2px 4px rgba(30,107,82,0.3);">
+                <h2 style="margin: 0; font-size: 32px; color: white;">{metrics['num_sud_types']}</h2>
+                <p style="margin: 5px 0 0 0; font-size: 12px; opacity: 0.9; color: white;">Types of SUD Indications</p>
+            </div>
+        </div>
+    </div>
+    """
+    
+    return html, time_dist_fig, quarterly_fig, pipeline_fig, portfolio_fig, metrics['avg_time_ind_ready'], current_ind_ready
+
+
+if __name__ == "__main__":
+    print("="*70)
+    print("DASHBOARD FUNCTIONS - TESTING")
+    print("="*70)
+    print("This module provides executive dashboard functionality.")
+    print("Import and use: render_executive_dashboard(candidates, categories, models_available)")
+    print("="*70)

page_candidate.py

@@ -0,0 +1,429 @@
+"""
+Candidate Detail Page Module
+Extracted from sud_promise_uab_theme.py
+"""
+
+import plotly.graph_objects as go
+from datetime import datetime, timedelta
+
+# Import UI constants
+from const_ui import (
+    UAB_GREEN, UAB_DARK_GREEN, UAB_LIGHT_GREEN, UAB_ACCENT_TEAL, UAB_PALE_GREEN,
+    SCORE_THRESHOLD_HIGH, SCORE_THRESHOLD_MODERATE,
+    SMILES_DISPLAY_LENGTH, MAX_TARGET_DISPLAY,
+    get_status_badge, get_score_type_badge, get_evidence_stars, get_impact_badge
+)
+
+from const_config import INSTITUTION
+
+
+def create_score_gauge(score: float, score_type: str, model_scores: dict = None) -> go.Figure:
+    """Create a gauge chart for the evidence score"""
+    
+    # Determine color based on score
+    if score >= SCORE_THRESHOLD_HIGH:
+        color = UAB_DARK_GREEN
+    elif score >= SCORE_THRESHOLD_MODERATE:
+        color = UAB_GREEN
+    else:
+        color = UAB_LIGHT_GREEN
+    
+    fig = go.Figure(go.Indicator(
+        mode="gauge+number+delta",
+        value=score,
+        domain={'x': [0, 1], 'y': [0, 1]},
+        title={'text': f"Evidence Score ({score_type})", 
+               'font': {'size': 16, 'family': "Times New Roman, serif", 'color': UAB_DARK_GREEN}},
+        number={'font': {'size': 40, 'family': "Times New Roman, serif"}},
+        gauge={
+            'axis': {'range': [0, 1], 'tickwidth': 1, 'tickcolor': UAB_DARK_GREEN},
+            'bar': {'color': color},
+            'bgcolor': "white",
+            'borderwidth': 2,
+            'bordercolor': UAB_DARK_GREEN,
+            'steps': [
+                {'range': [0, 0.5], 'color': '#FFE5E5'},
+                {'range': [0.5, 0.7], 'color': '#FFF4E5'},
+                {'range': [0.7, 1], 'color': UAB_PALE_GREEN}
+            ],
+            'threshold': {
+                'line': {'color': "red", 'width': 4},
+                'thickness': 0.75,
+                'value': 0.7
+            }
+        }
+    ))
+    
+    fig.update_layout(
+        height=300,
+        margin=dict(l=20, r=20, t=60, b=20),
+        paper_bgcolor='white',
+        font={'family': 'Times New Roman, serif', 'color': UAB_DARK_GREEN}
+    )
+    
+    return fig
+
+def create_model_comparison_chart(model_scores: dict, score_type: str) -> go.Figure:
+    """Create a bar chart comparing different model scores"""
+    
+    if not model_scores or score_type != "Real":
+        # Return empty figure for synthetic scores
+        fig = go.Figure()
+        fig.update_layout(
+            title="Model Scores (Not Available for Synthetic Predictions)",
+            height=300,
+            paper_bgcolor='white',
+            font={'family': 'Times New Roman, serif', 'color': UAB_DARK_GREEN}
+        )
+        return fig
+    
+    models = list(model_scores.keys())
+    scores = list(model_scores.values())
+    
+    colors = [UAB_GREEN if s >= SCORE_THRESHOLD_HIGH else UAB_LIGHT_GREEN if s >= SCORE_THRESHOLD_MODERATE else '#FFA500' for s in scores]
+    
+    fig = go.Figure(data=[
+        go.Bar(
+            x=models,
+            y=scores,
+            marker_color=colors,
+            text=[f'{s:.3f}' for s in scores],
+            textposition='outside',
+            textfont=dict(size=12, family="Times New Roman, serif", color=UAB_DARK_GREEN)
+        )
+    ])
+    
+    fig.update_layout(
+        title="Individual Model Predictions",
+        xaxis_title="",
+        yaxis_title="Prediction Score",
+        height=300,
+        margin=dict(l=40, r=20, t=50, b=80),
+        plot_bgcolor=UAB_PALE_GREEN,
+        paper_bgcolor='white',
+        font={'family': 'Times New Roman, serif', 'color': UAB_DARK_GREEN},
+        yaxis=dict(range=[0, 1]),
+        showlegend=False
+    )
+    
+    fig.add_hline(y=0.5, line_dash="dash", line_color="orange", annotation_text="Threshold 0.5")
+    fig.add_hline(y=SCORE_THRESHOLD_HIGH, line_dash="dash", line_color=UAB_DARK_GREEN, annotation_text="Threshold 0.7")
+    
+    return fig
+
+def create_evidence_timeline(candidate):
+    """Create timeline showing baseline + all project impacts"""
+    timeline_data = []
+    
+    # Start with baseline (either ML/DL ensemble or random baseline)
+    start_date = candidate.attached_projects[0].added_date - timedelta(days=30) if candidate.attached_projects else datetime.now() - timedelta(days=365)
+    
+    if candidate.score_type == "Real":
+        timeline_data.append({
+            'date': start_date,
+            'score': candidate.baseline_score,
+            'label': f'ML/DL Ensemble Baseline: {candidate.baseline_score:.3f}',
+            'color': UAB_DARK_GREEN,
+            'impact': 0
+        })
+    else:
+        timeline_data.append({
+            'date': start_date,
+            'score': candidate.baseline_score,
+            'label': 'Baseline (No Evidence)',
+            'color': '#A0AEC0',
+            'impact': 0
+        })
+    
+    # Add each project's impact
+    cumulative_score = candidate.baseline_score
+    for project in candidate.attached_projects:
+        cumulative_score += project.impact_score
+        cumulative_score = max(0.20, min(0.95, cumulative_score))
+        
+        marker_color = UAB_GREEN if project.impact_score > 0 else '#DC2626'
+        
+        timeline_data.append({
+            'date': project.added_date,
+            'score': cumulative_score,
+            'label': f'+ {project.name}' if project.impact_score > 0 else f'- {project.name}',
+            'color': marker_color,
+            'impact': project.impact_score,
+            'impact_text': f'+{project.impact_score:.2f}' if project.impact_score > 0 else f'{project.impact_score:.2f}'
+        })
+    
+    fig = go.Figure()
+    
+    # Draw line segments
+    for i in range(len(timeline_data) - 1):
+        segment_color = timeline_data[i+1]['color']
+        
+        fig.add_trace(go.Scatter(
+            x=[timeline_data[i]['date'], timeline_data[i+1]['date']],
+            y=[timeline_data[i]['score'], timeline_data[i+1]['score']],
+            mode='lines',
+            line=dict(color=segment_color, width=3),
+            showlegend=False,
+            hoverinfo='skip'
+        ))
+    
+    # Draw markers
+    fig.add_trace(go.Scatter(
+        x=[d['date'] for d in timeline_data],
+        y=[d['score'] for d in timeline_data],
+        mode='markers',
+        marker=dict(
+            size=12,
+            color=[d['color'] for d in timeline_data],
+            line=dict(width=2, color='white')
+        ),
+        text=[d['label'] for d in timeline_data],
+        hovertemplate='<b>%{text}</b><br>Score: %{y:.3f}<br>%{x|%b %d, %Y}<extra></extra>',
+        showlegend=False
+    ))
+    
+    # Add annotations for ALL project impacts (including Real ML/DL)
+    for i in range(1, len(timeline_data)):
+        if 'impact_text' in timeline_data[i]:
+            impact_value = timeline_data[i]['impact']
+            arrow_color = UAB_GREEN if impact_value > 0 else '#DC2626'
+            bg_color = UAB_GREEN if impact_value > 0 else '#DC2626'
+            
+            ay_value = 40 if impact_value > 0 else -40
+            
+            fig.add_annotation(
+                x=timeline_data[i]['date'],
+                y=timeline_data[i]['score'],
+                text=timeline_data[i]['impact_text'],
+                showarrow=True,
+                arrowhead=2,
+                arrowcolor=arrow_color,
+                ax=0,
+                ay=ay_value,
+                bgcolor=bg_color,
+                bordercolor=bg_color,
+                font=dict(color='white', size=10, family="Times New Roman, serif")
+            )
+    
+    # Add special annotation for ML/DL baseline
+    if candidate.score_type == "Real":
+        fig.add_annotation(
+            x=timeline_data[0]['date'],
+            y=timeline_data[0]['score'],
+            text=f"🤖 ML/DL: {candidate.baseline_score:.3f}",
+            showarrow=True,
+            arrowhead=2,
+            arrowcolor=UAB_DARK_GREEN,
+            ax=-50,
+            ay=-40,
+            bgcolor=UAB_DARK_GREEN,
+            bordercolor=UAB_DARK_GREEN,
+            font=dict(color='white', size=11, family="Times New Roman, serif", weight='bold')
+        )
+    
+    # Title
+    if candidate.score_type == "Real":
+        title_text = "Evidence Score Evolution Over Time (ML/DL Baseline + Project Evidence)"
+    else:
+        title_text = "Evidence Score Evolution Over Time (Synthetic Baseline + Project Evidence)"
+    
+    fig.update_layout(
+        title=title_text,
+        xaxis_title="Date",
+        yaxis_title="Prediction Score",
+        hovermode='closest',
+        height=400,
+        plot_bgcolor='#F0F9F6',
+        paper_bgcolor='white',
+        font=dict(family="Times New Roman, serif", color=UAB_DARK_GREEN),
+        yaxis=dict(range=[0, 1])
+    )
+    
+    return fig
+
+
+def format_date_ago(date):
+    delta = datetime.now() - date
+    if delta.days == 0:
+        return "Today"
+    elif delta.days == 1:
+        return "Yesterday"
+    elif delta.days < 7:
+        return f"{delta.days} days ago"
+    elif delta.days < 30:
+        return f"{delta.days // 7} weeks ago"
+    else:
+        return f"{delta.days // 30} months ago"
+
+
+def render_candidate_dashboard(candidate_selection, category_selection):
+    from sud_promise_uab_theme import CANDIDATES
+    
+    if not candidate_selection:
+        return "<p>Please select a candidate</p>", None, None, None, ""
+    
+    candidate_name = candidate_selection.split(" (Score:")[0].strip()
+    category_name = category_selection.split(" (")[0].strip() if category_selection else None
+    
+    if category_name:
+        candidate = next((c for c in CANDIDATES if c.drug_name == candidate_name and c.target_sud_subtype == category_name), None)
+    else:
+        candidate = next((c for c in CANDIDATES if c.drug_name == candidate_name), None)
+    
+    if not candidate:
+        return "<p>Candidate not found</p>", None, None, None, ""
+    
+    stars = get_evidence_stars(candidate.evidence_score)
+    status_badge = get_status_badge(candidate.stage)
+    score_type_badge = get_score_type_badge(candidate.score_type)
+    
+    timeline_fig = create_evidence_timeline(candidate)
+    gauge_fig = create_score_gauge(candidate.evidence_score, candidate.score_type, candidate.model_scores)
+    model_comparison_fig = create_model_comparison_chart(candidate.model_scores, candidate.score_type)
+    
+    # Evidence Evolution section
+    html_evolution = ""
+    if candidate.score_type == "Real":
+        html_evolution = f"""
+        <h2 style="color: {UAB_GREEN}; font-family: 'Times New Roman', Times, serif;">Evidence Evolution</h2>
+        <div style="background: {UAB_PALE_GREEN}; padding: 20px; border-radius: 10px; margin-bottom: 20px; border-left: 4px solid {UAB_GREEN}; font-family: 'Times New Roman', Times, serif;">
+            <p><b>ML/DL Ensemble Baseline:</b> {candidate.baseline_score:.3f} 🤖</p>
+            <p><b>Current Score (with Projects):</b> <span style="color: {UAB_GREEN}; font-weight: bold;">{candidate.evidence_score:.3f}</span></p>
+            <p style="color: {UAB_GREEN}; font-weight: bold;">Evidence Contribution: +{candidate.evidence_score - candidate.baseline_score:.3f} ({((candidate.evidence_score - candidate.baseline_score) / candidate.baseline_score * 100):.1f}%)</p>
+            <p style="color: #4A5568; font-size: 13px; margin-top: 10px;">
+                <i>Starting from ML/DL ensemble prediction, additional evidence projects further refine confidence.</i>
+            </p>
+        </div>
+        """
+    else:
+        html_evolution = f"""
+        <h2 style="color: {UAB_GREEN}; font-family: 'Times New Roman', Times, serif;">Evidence Evolution</h2>
+        <div style="background: {UAB_PALE_GREEN}; padding: 20px; border-radius: 10px; margin-bottom: 20px; border-left: 4px solid {UAB_GREEN}; font-family: 'Times New Roman', Times, serif;">
+            <p><b>Baseline Score:</b> {candidate.baseline_score:.2f} (no evidence)</p>
+            <p><b>Current Score:</b> <span style="color: {UAB_GREEN}; font-weight: bold;">{candidate.evidence_score:.2f}</span></p>
+            <p style="color: {UAB_GREEN}; font-weight: bold;">Total Improvement: +{candidate.evidence_score - candidate.baseline_score:.2f} ({((candidate.evidence_score - candidate.baseline_score) / candidate.baseline_score * 100):.1f}%)</p>
+        </div>
+        """
+    
+    html_before_plot = f"""
+    <div style="padding: 20px; font-family: 'Times New Roman', Times, serif;">
+        <div style="background: linear-gradient(135deg, {UAB_GREEN} 0%, {UAB_DARK_GREEN} 100%); padding: 30px; border-radius: 15px; color: white; margin-bottom: 30px; box-shadow: 0 4px 6px rgba(30,107,82,0.3);">
+            <h1 style="margin: 0; font-family: 'Times New Roman', Times, serif; color: white;">{candidate.drug_name}</h1>
+            <p style="margin: 10px 0 0 0; font-size: 18px; opacity: 0.9; font-family: 'Times New Roman', Times, serif; color: white;">Repositioning Candidate for {candidate.target_sud_subtype}</p>
+            <p style="margin: 5px 0 0 0; font-size: 14px; opacity: 0.8; font-family: 'Times New Roman', Times, serif; color: white;">{INSTITUTION} - SUD-PROMISE</p>
+        </div>
+        
+        <div style="display: flex; gap: 10px; margin-bottom: 30px; align-items: center;">
+            <div>{status_badge}</div>
+            <div style="background: {UAB_GREEN}; padding: 5px 12px; border-radius: 15px; font-weight: bold; color: white; font-family: 'Times New Roman', Times, serif;">
+                {stars} {candidate.evidence_score:.2f}
+            </div>
+            {score_type_badge}
+        </div>
+        
+        <h2 style="color: {UAB_GREEN}; font-family: 'Times New Roman', Times, serif;">Drug Summary</h2>
+        <div style="background: #F0F9F6; padding: 20px; border-radius: 10px; margin-bottom: 30px; border-left: 4px solid {UAB_GREEN}; font-family: 'Times New Roman', Times, serif;">
+            <p style="margin: 10px 0;"><b>Current Indication:</b> {candidate.current_indication}</p>
+            <p style="margin: 10px 0;"><b>Target SUD:</b> {candidate.target_sud_subtype}</p>
+            <p style="margin: 10px 0;"><b>Disease ID:</b> {candidate.disease_id if candidate.disease_id else 'Not Mapped'}</p>
+            <p style="margin: 10px 0;"><b>Mechanism of Action:</b> {candidate.mechanism}</p>
+            <p style="margin: 10px 0;"><b>SMILES:</b> <code style="background: white; padding: 2px 6px; border-radius: 4px;">{candidate.smiles[:SMILES_DISPLAY_LENGTH]}{'...' if len(candidate.smiles) > SMILES_DISPLAY_LENGTH else ''}</code></p>
+            <p style="margin: 10px 0;"><b>Protein Targets:</b> {', '.join(candidate.protein_targets[:MAX_TARGET_DISPLAY]) if candidate.protein_targets else 'Not specified'}{' (...)' if len(candidate.protein_targets) > MAX_TARGET_DISPLAY else ''}</p>
+        </div>
+        
+        <h2 style="color: {UAB_GREEN}; font-family: 'Times New Roman', Times, serif;">Project Metrics</h2>
+        <div style="background: {UAB_PALE_GREEN}; padding: 20px; border-radius: 10px; margin-bottom: 20px; border-left: 4px solid {UAB_GREEN}; font-family: 'Times New Roman', Times, serif;">
+            <div style="display: grid; grid-template-columns: repeat(3, 1fr); gap: 15px; margin: 15px 0;">
+                <div style="text-align: center;">
+                    <div style="font-weight: bold; font-size: 24px; color: {UAB_GREEN};">{candidate.team_members}</div>
+                    <div style="color: #4A5568;">Team Members</div>
+                </div>
+                <div style="text-align: center;">
+                    <div style="font-weight: bold; font-size: 24px; color: {UAB_GREEN};">{candidate.data_produced}</div>
+                    <div style="color: #4A5568;">Datasets Produced</div>
+                </div>
+                <div style="text-align: center;">
+                    <div style="font-weight: bold; font-size: 24px; color: {UAB_GREEN};">{candidate.publications}</div>
+                    <div style="color: #4A5568;">Publications</div>
+                </div>
+            </div>
+            <div style="display: grid; grid-template-columns: repeat(3, 1fr); gap: 15px; margin: 15px 0;">
+                <div style="text-align: center;">
+                    <div style="font-weight: bold; font-size: 24px; color: {UAB_GREEN};">{candidate.tools_used}</div>
+                    <div style="color: #4A5568;">Tools/Instruments</div>
+                </div>
+                <div style="text-align: center;">
+                    <div style="font-weight: bold; font-size: 24px; color: {UAB_GREEN};">{candidate.data_governance}</div>
+                    <div style="color: #4A5568;">Data Governance Policies</div>
+                </div>
+                <div style="text-align: center;">
+                    <div style="font-weight: bold; font-size: 24px; color: {UAB_GREEN};">{candidate.training_participated}</div>
+                    <div style="color: #4A5568;">Training Sessions</div>
+                </div>
+            </div>
+        </div>
+        
+        {html_evolution}
+    </div>
+    """
+    
+    html_after_plot = f"""
+    <div style="padding: 0 20px 20px 20px; font-family: 'Times New Roman', Times, serif;">
+        <h2 style="color: {UAB_GREEN}; font-family: 'Times New Roman', Times, serif;">Attached Evidence Projects ({len(candidate.attached_projects)})</h2>
+        <p style="color: #718096; margin-bottom: 15px; font-family: 'Times New Roman', Times, serif;">Projects contributing to prediction confidence</p>
+    """
+    
+    for project in candidate.attached_projects:
+        impact_badge = get_impact_badge(project.impact_score)
+        border_color = UAB_GREEN if project.impact_score > 0 else '#DC2626'
+        
+        html_after_plot += f"""
+        <div style="background: white; border-left: 5px solid {border_color}; padding: 20px; margin: 15px 0; border-radius: 10px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); font-family: 'Times New Roman', Times, serif;">
+            <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 10px;">
+                <h3 style="margin: 0; color: {UAB_DARK_GREEN}; font-family: 'Times New Roman', Times, serif;">{project.name}</h3>
+                {impact_badge}
+            </div>
+            
+            <div style="display: grid; grid-template-columns: repeat(2, 1fr); gap: 15px; margin: 15px 0;">
+                <div>
+                    <p style="margin: 5px 0; color: #4A5568;"><b>Type:</b> {project.project_type}</p>
+                    <p style="margin: 5px 0; color: #4A5568;"><b>Sample Size:</b> {project.sample_size:,} patients</p>
+                </div>
+                <div>
+                    <p style="margin: 5px 0; color: #4A5568;"><b>Status:</b> {project.status}</p>
+                    <p style="margin: 5px 0; color: #4A5568;"><b>Added:</b> {format_date_ago(project.added_date)}</p>
+                </div>
+            </div>
+            
+            <div style="background: #F0F9F6; padding: 15px; border-radius: 8px; margin-top: 10px;">
+                <p style="margin: 0; font-style: italic; color: #4A5568;">"{project.summary}"</p>
+            </div>
+        </div>
+        """
+    
+    html_after_plot += f"""
+        <div style="margin-top: 30px; padding: 20px; background: #F0F9F6; border-radius: 10px; border-left: 4px solid {UAB_GREEN}; font-family: 'Times New Roman', Times, serif;">
+            <h3 style="color: {UAB_DARK_GREEN}; font-family: 'Times New Roman', Times, serif;">Summary Statistics</h3>
+            <div style="display: grid; grid-template-columns: repeat(4, 1fr); gap: 15px; margin-bottom: 15px;">
+                <div style="text-align: center; font-family: 'Times New Roman', Times, serif;">
+                    <div style="font-weight: bold; font-size: 24px; color: {UAB_GREEN};">{len(candidate.attached_projects)}</div>
+                    <div style="color: #4A5568;">Evidence Projects</div>
+                </div>
+                <div style="text-align: center; font-family: 'Times New Roman', Times, serif;">
+                    <div style="font-weight: bold; font-size: 24px; color: {UAB_GREEN};">{candidate.cohort_count}</div>
+                    <div style="color: #4A5568;">Patient Cohorts</div>
+                </div>
+                <div style="text-align: center; font-family: 'Times New Roman', Times, serif;">
+                    <div style="font-weight: bold; font-size: 24px; color: {UAB_GREEN};">{"✅" if candidate.has_validation_plan else "—"}</div>
+                    <div style="color: #4A5568;">Validation Plan</div>
+                </div>
+                <div style="text-align: center; font-family: 'Times New Roman', Times, serif;">
+                    <div style="font-weight: bold; font-size: 24px; color: {UAB_GREEN};">{"✅" if candidate.has_market_analysis else "—"}</div>
+                    <div style="color: #4A5568;">Market Analysis</div>
+                </div>
+            </div>
+        </div>
+    </div>
+    """
+    
+    return html_before_plot, gauge_fig, model_comparison_fig, timeline_fig, html_after_plot

page_category.py

@@ -0,0 +1,53 @@
+"""
+Category Page Module
+Extracted from sud_promise_uab_theme.py
+"""
+
+# Import UI constants
+from const_ui import (
+    UAB_GREEN, UAB_DARK_GREEN,
+    MAX_TOP_CANDIDATES_DISPLAY
+)
+
+from const_data import SUD_CATEGORY_DESCRIPTIONS
+
+
+def render_landing_dashboard():
+    from sud_promise_uab_theme import CANDIDATES, SUD_CATEGORIES
+    
+    top_candidates = sorted(CANDIDATES, key=lambda c: c.evidence_score, reverse=True)[:MAX_TOP_CANDIDATES_DISPLAY]
+    
+    html = ""
+    
+    category_choices = [f"{cat.name} ({cat.candidate_count} candidates)" for cat in SUD_CATEGORIES]
+    
+    return html, category_choices, top_candidates
+
+def render_category_view(category_selection, sort_by="Evidence Score"):
+    from sud_promise_uab_theme import CANDIDATES, SUD_CATEGORIES
+    
+    if not category_selection:
+        return "<p>Please select a category</p>", [], []
+    
+    category_name = category_selection.split(" (")[0].strip()
+    category = next((c for c in SUD_CATEGORIES if c.name == category_name), None)
+    if not category:
+        return "<p>Category not found</p>", [], []
+    
+    filtered = [c for c in CANDIDATES if c.target_sud_subtype == category_name]
+    
+    if sort_by == "Evidence Score" or sort_by == "evidence_score":
+        filtered.sort(key=lambda c: c.evidence_score, reverse=True)
+    elif sort_by == "Recent" or sort_by == "recent":
+        filtered.sort(key=lambda c: c.last_updated, reverse=True)
+    elif sort_by == "Name" or sort_by == "name":
+        filtered.sort(key=lambda c: c.drug_name)
+    elif sort_by == "Stage":
+        filtered.sort(key=lambda c: c.stage, reverse=True)
+    
+    
+    candidate_choices = [f"{c.drug_name} (Score: {c.evidence_score:.2f})" for c in filtered]
+
+    html = ""
+    
+    return html, candidate_choices, filtered

requirements.txt

@@ -0,0 +1,20 @@
+# Core Data Science Libraries
+pandas>=1.5.0
+numpy>=1.23.0
+
+# Machine Learning & Deep Learning
+tensorflow>=2.13.0
+scikit-learn>=1.3.0
+joblib>=1.3.0
+
+# Chemistry & Drug Discovery
+rdkit>=2023.3.1
+
+# Visualization
+plotly>=5.17.0
+
+# Web Interface
+gradio>=4.0.0
+
+# Additional Dependencies (automatically installed with above, but listed for clarity)
+kaleido>=0.2.1  # For static image export in Plotly (optional but recommended)

saved_models/MODEL_INVENTORY.json

@@ -0,0 +1,30 @@
+{
+  "saved_files": {
+    "ML_Models": [
+      "logistic_regression.pkl",
+      "random_forest.pkl",
+      "xgboost.pkl"
+    ],
+    "DNN_Models": [
+      "mm_dnn_model.keras",
+      "mm_dnn_model.h5"
+    ],
+    "Preprocessing": [
+      "scaler.pkl",
+      "target_binarizer.pkl",
+      "disease_encoder.pkl",
+      "disease_ohe_df.pkl",
+      "disease_onehot_encoder.pkl"
+    ],
+    "Metadata": [
+      "dimensions.json",
+      "performance.json",
+      "metadata.json",
+      "training_history.csv",
+      "target_classes.json",
+      "disease_classes.json"
+    ]
+  },
+  "total_files": 17,
+  "total_size_mb": 927.69
+}

saved_models/dimensions.json

@@ -0,0 +1,8 @@
+{
+  "drug_dim": 3042,
+  "num_diseases": 1573,
+  "num_drugs": 1410,
+  "num_targets": 2018,
+  "num_positive_samples": 42200,
+  "train_test_split": 0.2
+}

saved_models/disease_classes.json

@@ -0,0 +1,1577 @@
+{
+  "classes": [
+    "MESH:D000013",
+    "MESH:D000014",
+    "MESH:D000015",
+    "MESH:D000022",
+    "MESH:D000026",
+    "MESH:D000037",
+    "MESH:D000067877",
+    "MESH:D000068079",
+    "MESH:D000070642",
+    "MESH:D000072657",
+    "MESH:D000072660",
+    "MESH:D000075222",
+    "MESH:D000077192",
+    "MESH:D000077195",
+    "MESH:D000077216",
+    "MESH:D000077273",
+    "MESH:D000077274",
+    "MESH:D000077277",
+    "MESH:D000138",
+    "MESH:D000140",
+    "MESH:D000141",
+    "MESH:D000152",
+    "MESH:D000163",
+    "MESH:D000169",
+    "MESH:D000172",
+    "MESH:D000210",
+    "MESH:D000224",
+    "MESH:D000230",
+    "MESH:D000236",
+    "MESH:D000275",
+    "MESH:D000303",
+    "MESH:D000307",
+    "MESH:D000309",
+    "MESH:D000310",
+    "MESH:D000312",
+    "MESH:D000361",
+    "MESH:D000380",
+    "MESH:D000382",
+    "MESH:D000402",
+    "MESH:D000419",
+    "MESH:D000430",
+    "MESH:D000435",
+    "MESH:D000437",
+    "MESH:D000471",
+    "MESH:D000505",
+    "MESH:D000506",
+    "MESH:D000542",
+    "MESH:D000544",
+    "MESH:D000568",
+    "MESH:D000647",
+    "MESH:D000648",
+    "MESH:D000686",
+    "MESH:D000690",
+    "MESH:D000707",
+    "MESH:D000740",
+    "MESH:D000741",
+    "MESH:D000743",
+    "MESH:D000744",
+    "MESH:D000748",
+    "MESH:D000749",
+    "MESH:D000751",
+    "MESH:D000753",
+    "MESH:D000755",
+    "MESH:D000756",
+    "MESH:D000757",
+    "MESH:D000782",
+    "MESH:D000783",
+    "MESH:D000784",
+    "MESH:D000787",
+    "MESH:D000789",
+    "MESH:D000799",
+    "MESH:D000848",
+    "MESH:D000853",
+    "MESH:D000855",
+    "MESH:D000856",
+    "MESH:D000857",
+    "MESH:D000858",
+    "MESH:D000860",
+    "MESH:D000987",
+    "MESH:D001002",
+    "MESH:D001005",
+    "MESH:D001006",
+    "MESH:D001008",
+    "MESH:D001010",
+    "MESH:D001014",
+    "MESH:D001018",
+    "MESH:D001019",
+    "MESH:D001022",
+    "MESH:D001037",
+    "MESH:D001049",
+    "MESH:D001068",
+    "MESH:D001139",
+    "MESH:D001145",
+    "MESH:D001157",
+    "MESH:D001161",
+    "MESH:D001165",
+    "MESH:D001167",
+    "MESH:D001168",
+    "MESH:D001169",
+    "MESH:D001170",
+    "MESH:D001171",
+    "MESH:D001172",
+    "MESH:D001176",
+    "MESH:D001195",
+    "MESH:D001201",
+    "MESH:D001228",
+    "MESH:D001237",
+    "MESH:D001238",
+    "MESH:D001247",
+    "MESH:D001249",
+    "MESH:D001254",
+    "MESH:D001259",
+    "MESH:D001260",
+    "MESH:D001281",
+    "MESH:D001284",
+    "MESH:D001289",
+    "MESH:D001308",
+    "MESH:D001321",
+    "MESH:D001327",
+    "MESH:D001342",
+    "MESH:D001416",
+    "MESH:D001424",
+    "MESH:D001471",
+    "MESH:D001477",
+    "MESH:D001478",
+    "MESH:D001480",
+    "MESH:D001523",
+    "MESH:D001528",
+    "MESH:D001607",
+    "MESH:D001649",
+    "MESH:D001650",
+    "MESH:D001651",
+    "MESH:D001661",
+    "MESH:D001714",
+    "MESH:D001724",
+    "MESH:D001744",
+    "MESH:D001745",
+    "MESH:D001748",
+    "MESH:D001749",
+    "MESH:D001750",
+    "MESH:D001752",
+    "MESH:D001763",
+    "MESH:D001764",
+    "MESH:D001766",
+    "MESH:D001768",
+    "MESH:D001778",
+    "MESH:D001791",
+    "MESH:D001835",
+    "MESH:D001847",
+    "MESH:D001848",
+    "MESH:D001849",
+    "MESH:D001851",
+    "MESH:D001855",
+    "MESH:D001859",
+    "MESH:D001862",
+    "MESH:D001913",
+    "MESH:D001919",
+    "MESH:D001927",
+    "MESH:D001928",
+    "MESH:D001929",
+    "MESH:D001930",
+    "MESH:D001932",
+    "MESH:D001941",
+    "MESH:D001943",
+    "MESH:D001982",
+    "MESH:D001987",
+    "MESH:D001989",
+    "MESH:D001997",
+    "MESH:D002006",
+    "MESH:D002051",
+    "MESH:D002056",
+    "MESH:D002057",
+    "MESH:D002100",
+    "MESH:D002114",
+    "MESH:D002177",
+    "MESH:D002178",
+    "MESH:D002180",
+    "MESH:D002181",
+    "MESH:D002189",
+    "MESH:D002276",
+    "MESH:D002277",
+    "MESH:D002280",
+    "MESH:D002289",
+    "MESH:D002292",
+    "MESH:D002294",
+    "MESH:D002295",
+    "MESH:D002296",
+    "MESH:D002303",
+    "MESH:D002305",
+    "MESH:D002310",
+    "MESH:D002311",
+    "MESH:D002312",
+    "MESH:D002313",
+    "MESH:D002318",
+    "MESH:D002340",
+    "MESH:D002341",
+    "MESH:D002349",
+    "MESH:D002357",
+    "MESH:D002375",
+    "MESH:D002386",
+    "MESH:D002389",
+    "MESH:D002446",
+    "MESH:D002471",
+    "MESH:D002481",
+    "MESH:D002493",
+    "MESH:D002524",
+    "MESH:D002526",
+    "MESH:D002532",
+    "MESH:D002534",
+    "MESH:D002538",
+    "MESH:D002542",
+    "MESH:D002543",
+    "MESH:D002544",
+    "MESH:D002545",
+    "MESH:D002546",
+    "MESH:D002547",
+    "MESH:D002561",
+    "MESH:D002578",
+    "MESH:D002583",
+    "MESH:D002607",
+    "MESH:D002637",
+    "MESH:D002658",
+    "MESH:D002659",
+    "MESH:D002690",
+    "MESH:D002761",
+    "MESH:D002769",
+    "MESH:D002779",
+    "MESH:D002780",
+    "MESH:D002805",
+    "MESH:D002806",
+    "MESH:D002813",
+    "MESH:D002819",
+    "MESH:D002869",
+    "MESH:D002908",
+    "MESH:D002971",
+    "MESH:D002972",
+    "MESH:D003025",
+    "MESH:D003057",
+    "MESH:D003072",
+    "MESH:D003092",
+    "MESH:D003093",
+    "MESH:D003103",
+    "MESH:D003110",
+    "MESH:D003111",
+    "MESH:D003117",
+    "MESH:D003123",
+    "MESH:D003128",
+    "MESH:D003161",
+    "MESH:D003229",
+    "MESH:D003240",
+    "MESH:D003248",
+    "MESH:D003286",
+    "MESH:D003294",
+    "MESH:D003316",
+    "MESH:D003318",
+    "MESH:D003320",
+    "MESH:D003323",
+    "MESH:D003324",
+    "MESH:D003327",
+    "MESH:D003328",
+    "MESH:D003329",
+    "MESH:D003330",
+    "MESH:D003371",
+    "MESH:D003384",
+    "MESH:D003394",
+    "MESH:D003398",
+    "MESH:D003409",
+    "MESH:D003424",
+    "MESH:D003456",
+    "MESH:D003480",
+    "MESH:D003490",
+    "MESH:D003550",
+    "MESH:D003554",
+    "MESH:D003556",
+    "MESH:D003557",
+    "MESH:D003560",
+    "MESH:D003586",
+    "MESH:D003638",
+    "MESH:D003639",
+    "MESH:D003643",
+    "MESH:D003645",
+    "MESH:D003677",
+    "MESH:D003680",
+    "MESH:D003681",
+    "MESH:D003704",
+    "MESH:D003711",
+    "MESH:D003715",
+    "MESH:D003865",
+    "MESH:D003866",
+    "MESH:D003872",
+    "MESH:D003875",
+    "MESH:D003876",
+    "MESH:D003877",
+    "MESH:D003882",
+    "MESH:D003914",
+    "MESH:D003919",
+    "MESH:D003920",
+    "MESH:D003921",
+    "MESH:D003922",
+    "MESH:D003924",
+    "MESH:D003925",
+    "MESH:D003928",
+    "MESH:D003929",
+    "MESH:D003930",
+    "MESH:D003967",
+    "MESH:D003969",
+    "MESH:D004195",
+    "MESH:D004198",
+    "MESH:D004211",
+    "MESH:D004283",
+    "MESH:D004310",
+    "MESH:D004314",
+    "MESH:D004370",
+    "MESH:D004374",
+    "MESH:D004381",
+    "MESH:D004401",
+    "MESH:D004409",
+    "MESH:D004412",
+    "MESH:D004413",
+    "MESH:D004417",
+    "MESH:D004421",
+    "MESH:D004427",
+    "MESH:D004443",
+    "MESH:D004476",
+    "MESH:D004485",
+    "MESH:D004487",
+    "MESH:D004489",
+    "MESH:D004617",
+    "MESH:D004646",
+    "MESH:D004660",
+    "MESH:D004681",
+    "MESH:D004700",
+    "MESH:D004714",
+    "MESH:D004715",
+    "MESH:D004719",
+    "MESH:D004749",
+    "MESH:D004751",
+    "MESH:D004760",
+    "MESH:D004769",
+    "MESH:D004802",
+    "MESH:D004806",
+    "MESH:D004820",
+    "MESH:D004827",
+    "MESH:D004829",
+    "MESH:D004830",
+    "MESH:D004831",
+    "MESH:D004832",
+    "MESH:D004833",
+    "MESH:D004890",
+    "MESH:D004892",
+    "MESH:D004915",
+    "MESH:D004916",
+    "MESH:D004927",
+    "MESH:D004932",
+    "MESH:D004935",
+    "MESH:D004938",
+    "MESH:D004940",
+    "MESH:D004941",
+    "MESH:D004942",
+    "MESH:D005076",
+    "MESH:D005119",
+    "MESH:D005124",
+    "MESH:D005128",
+    "MESH:D005131",
+    "MESH:D005132",
+    "MESH:D005134",
+    "MESH:D005141",
+    "MESH:D005146",
+    "MESH:D005148",
+    "MESH:D005158",
+    "MESH:D005183",
+    "MESH:D005198",
+    "MESH:D005199",
+    "MESH:D005207",
+    "MESH:D005221",
+    "MESH:D005234",
+    "MESH:D005235",
+    "MESH:D005262",
+    "MESH:D005264",
+    "MESH:D005271",
+    "MESH:D005313",
+    "MESH:D005315",
+    "MESH:D005316",
+    "MESH:D005317",
+    "MESH:D005327",
+    "MESH:D005334",
+    "MESH:D005350",
+    "MESH:D005354",
+    "MESH:D005355",
+    "MESH:D005357",
+    "MESH:D005483",
+    "MESH:D005494",
+    "MESH:D005497",
+    "MESH:D005512",
+    "MESH:D005532",
+    "MESH:D005596",
+    "MESH:D005600",
+    "MESH:D005621",
+    "MESH:D005687",
+    "MESH:D005706",
+    "MESH:D005715",
+    "MESH:D005759",
+    "MESH:D005761",
+    "MESH:D005764",
+    "MESH:D005767",
+    "MESH:D005770",
+    "MESH:D005776",
+    "MESH:D005832",
+    "MESH:D005833",
+    "MESH:D005871",
+    "MESH:D005879",
+    "MESH:D005885",
+    "MESH:D005886",
+    "MESH:D005891",
+    "MESH:D005901",
+    "MESH:D005902",
+    "MESH:D005909",
+    "MESH:D005910",
+    "MESH:D005911",
+    "MESH:D005921",
+    "MESH:D005922",
+    "MESH:D005923",
+    "MESH:D006008",
+    "MESH:D006030",
+    "MESH:D006042",
+    "MESH:D006044",
+    "MESH:D006053",
+    "MESH:D006059",
+    "MESH:D006073",
+    "MESH:D006083",
+    "MESH:D006086",
+    "MESH:D006104",
+    "MESH:D006106",
+    "MESH:D006111",
+    "MESH:D006130",
+    "MESH:D006177",
+    "MESH:D006201",
+    "MESH:D006212",
+    "MESH:D006222",
+    "MESH:D006228",
+    "MESH:D006255",
+    "MESH:D006258",
+    "MESH:D006259",
+    "MESH:D006261",
+    "MESH:D006311",
+    "MESH:D006314",
+    "MESH:D006317",
+    "MESH:D006319",
+    "MESH:D006323",
+    "MESH:D006327",
+    "MESH:D006330",
+    "MESH:D006331",
+    "MESH:D006332",
+    "MESH:D006333",
+    "MESH:D006335",
+    "MESH:D006342",
+    "MESH:D006343",
+    "MESH:D006344",
+    "MESH:D006345",
+    "MESH:D006349",
+    "MESH:D006356",
+    "MESH:D006391",
+    "MESH:D006394",
+    "MESH:D006402",
+    "MESH:D006406",
+    "MESH:D006408",
+    "MESH:D006417",
+    "MESH:D006429",
+    "MESH:D006432",
+    "MESH:D006457",
+    "MESH:D006461",
+    "MESH:D006463",
+    "MESH:D006467",
+    "MESH:D006470",
+    "MESH:D006471",
+    "MESH:D006474",
+    "MESH:D006484",
+    "MESH:D006501",
+    "MESH:D006502",
+    "MESH:D006504",
+    "MESH:D006505",
+    "MESH:D006509",
+    "MESH:D006519",
+    "MESH:D006520",
+    "MESH:D006521",
+    "MESH:D006526",
+    "MESH:D006527",
+    "MESH:D006528",
+    "MESH:D006529",
+    "MESH:D006530",
+    "MESH:D006548",
+    "MESH:D006554",
+    "MESH:D006556",
+    "MESH:D006561",
+    "MESH:D006566",
+    "MESH:D006620",
+    "MESH:D006628",
+    "MESH:D006679",
+    "MESH:D006689",
+    "MESH:D006712",
+    "MESH:D006816",
+    "MESH:D006831",
+    "MESH:D006849",
+    "MESH:D006869",
+    "MESH:D006929",
+    "MESH:D006930",
+    "MESH:D006932",
+    "MESH:D006934",
+    "MESH:D006935",
+    "MESH:D006937",
+    "MESH:D006938",
+    "MESH:D006940",
+    "MESH:D006941",
+    "MESH:D006942",
+    "MESH:D006943",
+    "MESH:D006946",
+    "MESH:D006947",
+    "MESH:D006948",
+    "MESH:D006949",
+    "MESH:D006950",
+    "MESH:D006951",
+    "MESH:D006952",
+    "MESH:D006953",
+    "MESH:D006954",
+    "MESH:D006955",
+    "MESH:D006958",
+    "MESH:D006959",
+    "MESH:D006961",
+    "MESH:D006962",
+    "MESH:D006963",
+    "MESH:D006965",
+    "MESH:D006966",
+    "MESH:D006967",
+    "MESH:D006968",
+    "MESH:D006969",
+    "MESH:D006971",
+    "MESH:D006972",
+    "MESH:D006973",
+    "MESH:D006974",
+    "MESH:D006975",
+    "MESH:D006976",
+    "MESH:D006977",
+    "MESH:D006978",
+    "MESH:D006980",
+    "MESH:D006981",
+    "MESH:D006983",
+    "MESH:D006984",
+    "MESH:D006985",
+    "MESH:D006994",
+    "MESH:D006996",
+    "MESH:D007003",
+    "MESH:D007006",
+    "MESH:D007008",
+    "MESH:D007009",
+    "MESH:D007010",
+    "MESH:D007011",
+    "MESH:D007018",
+    "MESH:D007020",
+    "MESH:D007021",
+    "MESH:D007022",
+    "MESH:D007024",
+    "MESH:D007035",
+    "MESH:D007037",
+    "MESH:D007039",
+    "MESH:D007040",
+    "MESH:D007057",
+    "MESH:D007079",
+    "MESH:D007105",
+    "MESH:D007119",
+    "MESH:D007153",
+    "MESH:D007154",
+    "MESH:D007172",
+    "MESH:D007174",
+    "MESH:D007177",
+    "MESH:D007232",
+    "MESH:D007235",
+    "MESH:D007238",
+    "MESH:D007247",
+    "MESH:D007248",
+    "MESH:D007249",
+    "MESH:D007251",
+    "MESH:D007319",
+    "MESH:D007333",
+    "MESH:D007340",
+    "MESH:D007405",
+    "MESH:D007410",
+    "MESH:D007414",
+    "MESH:D007415",
+    "MESH:D007416",
+    "MESH:D007417",
+    "MESH:D007511",
+    "MESH:D007562",
+    "MESH:D007567",
+    "MESH:D007569",
+    "MESH:D007589",
+    "MESH:D007592",
+    "MESH:D007619",
+    "MESH:D007627",
+    "MESH:D007634",
+    "MESH:D007642",
+    "MESH:D007644",
+    "MESH:D007645",
+    "MESH:D007647",
+    "MESH:D007669",
+    "MESH:D007674",
+    "MESH:D007676",
+    "MESH:D007680",
+    "MESH:D007683",
+    "MESH:D007690",
+    "MESH:D007706",
+    "MESH:D007738",
+    "MESH:D007752",
+    "MESH:D007805",
+    "MESH:D007806",
+    "MESH:D007822",
+    "MESH:D007835",
+    "MESH:D007859",
+    "MESH:D007889",
+    "MESH:D007890",
+    "MESH:D007896",
+    "MESH:D007897",
+    "MESH:D007898",
+    "MESH:D007905",
+    "MESH:D007918",
+    "MESH:D007938",
+    "MESH:D007942",
+    "MESH:D007943",
+    "MESH:D007945",
+    "MESH:D007948",
+    "MESH:D007951",
+    "MESH:D007960",
+    "MESH:D007964",
+    "MESH:D007970",
+    "MESH:D007972",
+    "MESH:D007984",
+    "MESH:D008060",
+    "MESH:D008064",
+    "MESH:D008067",
+    "MESH:D008068",
+    "MESH:D008080",
+    "MESH:D008103",
+    "MESH:D008104",
+    "MESH:D008105",
+    "MESH:D008106",
+    "MESH:D008107",
+    "MESH:D008108",
+    "MESH:D008113",
+    "MESH:D008114",
+    "MESH:D008133",
+    "MESH:D008171",
+    "MESH:D008173",
+    "MESH:D008175",
+    "MESH:D008179",
+    "MESH:D008180",
+    "MESH:D008181",
+    "MESH:D008207",
+    "MESH:D008209",
+    "MESH:D008223",
+    "MESH:D008224",
+    "MESH:D008228",
+    "MESH:D008231",
+    "MESH:D008232",
+    "MESH:D008258",
+    "MESH:D008268",
+    "MESH:D008269",
+    "MESH:D008275",
+    "MESH:D008286",
+    "MESH:D008288",
+    "MESH:D008305",
+    "MESH:D008325",
+    "MESH:D008382",
+    "MESH:D008413",
+    "MESH:D008415",
+    "MESH:D008439",
+    "MESH:D008527",
+    "MESH:D008545",
+    "MESH:D008546",
+    "MESH:D008548",
+    "MESH:D008569",
+    "MESH:D008579",
+    "MESH:D008580",
+    "MESH:D008581",
+    "MESH:D008582",
+    "MESH:D008585",
+    "MESH:D008589",
+    "MESH:D008590",
+    "MESH:D008591",
+    "MESH:D008607",
+    "MESH:D008641",
+    "MESH:D008654",
+    "MESH:D008659",
+    "MESH:D008661",
+    "MESH:D008679",
+    "MESH:D008708",
+    "MESH:D008831",
+    "MESH:D008850",
+    "MESH:D008881",
+    "MESH:D008924",
+    "MESH:D008944",
+    "MESH:D009021",
+    "MESH:D009056",
+    "MESH:D009057",
+    "MESH:D009059",
+    "MESH:D009062",
+    "MESH:D009069",
+    "MESH:D009080",
+    "MESH:D009084",
+    "MESH:D009101",
+    "MESH:D009102",
+    "MESH:D009103",
+    "MESH:D009122",
+    "MESH:D009123",
+    "MESH:D009127",
+    "MESH:D009128",
+    "MESH:D009133",
+    "MESH:D009134",
+    "MESH:D009135",
+    "MESH:D009136",
+    "MESH:D009137",
+    "MESH:D009139",
+    "MESH:D009157",
+    "MESH:D009164",
+    "MESH:D009165",
+    "MESH:D009175",
+    "MESH:D009182",
+    "MESH:D009190",
+    "MESH:D009196",
+    "MESH:D009202",
+    "MESH:D009203",
+    "MESH:D009205",
+    "MESH:D009212",
+    "MESH:D009216",
+    "MESH:D009220",
+    "MESH:D009222",
+    "MESH:D009223",
+    "MESH:D009224",
+    "MESH:D009260",
+    "MESH:D009290",
+    "MESH:D009293",
+    "MESH:D009298",
+    "MESH:D009303",
+    "MESH:D009325",
+    "MESH:D009336",
+    "MESH:D009361",
+    "MESH:D009362",
+    "MESH:D009364",
+    "MESH:D009369",
+    "MESH:D009373",
+    "MESH:D009374",
+    "MESH:D009375",
+    "MESH:D009376",
+    "MESH:D009377",
+    "MESH:D009381",
+    "MESH:D009385",
+    "MESH:D009389",
+    "MESH:D009393",
+    "MESH:D009395",
+    "MESH:D009396",
+    "MESH:D009397",
+    "MESH:D009400",
+    "MESH:D009401",
+    "MESH:D009402",
+    "MESH:D009404",
+    "MESH:D009410",
+    "MESH:D009421",
+    "MESH:D009422",
+    "MESH:D009436",
+    "MESH:D009437",
+    "MESH:D009442",
+    "MESH:D009447",
+    "MESH:D009461",
+    "MESH:D009468",
+    "MESH:D009471",
+    "MESH:D009503",
+    "MESH:D009669",
+    "MESH:D009765",
+    "MESH:D009771",
+    "MESH:D009784",
+    "MESH:D009798",
+    "MESH:D009837",
+    "MESH:D009839",
+    "MESH:D009845",
+    "MESH:D009846",
+    "MESH:D009886",
+    "MESH:D009896",
+    "MESH:D009901",
+    "MESH:D009902",
+    "MESH:D009976",
+    "MESH:D009999",
+    "MESH:D010001",
+    "MESH:D010003",
+    "MESH:D010009",
+    "MESH:D010014",
+    "MESH:D010020",
+    "MESH:D010022",
+    "MESH:D010024",
+    "MESH:D010026",
+    "MESH:D010048",
+    "MESH:D010049",
+    "MESH:D010051",
+    "MESH:D010146",
+    "MESH:D010148",
+    "MESH:D010149",
+    "MESH:D010182",
+    "MESH:D010190",
+    "MESH:D010195",
+    "MESH:D010198",
+    "MESH:D010212",
+    "MESH:D010214",
+    "MESH:D010235",
+    "MESH:D010243",
+    "MESH:D010244",
+    "MESH:D010257",
+    "MESH:D010259",
+    "MESH:D010267",
+    "MESH:D010282",
+    "MESH:D010291",
+    "MESH:D010292",
+    "MESH:D010300",
+    "MESH:D010302",
+    "MESH:D010382",
+    "MESH:D010390",
+    "MESH:D010391",
+    "MESH:D010392",
+    "MESH:D010409",
+    "MESH:D010411",
+    "MESH:D010412",
+    "MESH:D010437",
+    "MESH:D010438",
+    "MESH:D010490",
+    "MESH:D010505",
+    "MESH:D010510",
+    "MESH:D010518",
+    "MESH:D010520",
+    "MESH:D010523",
+    "MESH:D010538",
+    "MESH:D010547",
+    "MESH:D010554",
+    "MESH:D010623",
+    "MESH:D010673",
+    "MESH:D010698",
+    "MESH:D010859",
+    "MESH:D010899",
+    "MESH:D010900",
+    "MESH:D010911",
+    "MESH:D010916",
+    "MESH:D010922",
+    "MESH:D010930",
+    "MESH:D010995",
+    "MESH:D010996",
+    "MESH:D010997",
+    "MESH:D010998",
+    "MESH:D011008",
+    "MESH:D011014",
+    "MESH:D011015",
+    "MESH:D011018",
+    "MESH:D011024",
+    "MESH:D011030",
+    "MESH:D011085",
+    "MESH:D011086",
+    "MESH:D011087",
+    "MESH:D011115",
+    "MESH:D011123",
+    "MESH:D011125",
+    "MESH:D011141",
+    "MESH:D011164",
+    "MESH:D011183",
+    "MESH:D011218",
+    "MESH:D011225",
+    "MESH:D011230",
+    "MESH:D011248",
+    "MESH:D011249",
+    "MESH:D011271",
+    "MESH:D011297",
+    "MESH:D011371",
+    "MESH:D011469",
+    "MESH:D011470",
+    "MESH:D011471",
+    "MESH:D011472",
+    "MESH:D011488",
+    "MESH:D011507",
+    "MESH:D011537",
+    "MESH:D011546",
+    "MESH:D011547",
+    "MESH:D011552",
+    "MESH:D011561",
+    "MESH:D011565",
+    "MESH:D011595",
+    "MESH:D011596",
+    "MESH:D011605",
+    "MESH:D011618",
+    "MESH:D011625",
+    "MESH:D011628",
+    "MESH:D011629",
+    "MESH:D011644",
+    "MESH:D011654",
+    "MESH:D011655",
+    "MESH:D011656",
+    "MESH:D011657",
+    "MESH:D011658",
+    "MESH:D011668",
+    "MESH:D011695",
+    "MESH:D011697",
+    "MESH:D011704",
+    "MESH:D011778",
+    "MESH:D011782",
+    "MESH:D011832",
+    "MESH:D011833",
+    "MESH:D011928",
+    "MESH:D012004",
+    "MESH:D012008",
+    "MESH:D012021",
+    "MESH:D012035",
+    "MESH:D012120",
+    "MESH:D012127",
+    "MESH:D012128",
+    "MESH:D012130",
+    "MESH:D012131",
+    "MESH:D012135",
+    "MESH:D012140",
+    "MESH:D012141",
+    "MESH:D012148",
+    "MESH:D012162",
+    "MESH:D012163",
+    "MESH:D012164",
+    "MESH:D012170",
+    "MESH:D012173",
+    "MESH:D012174",
+    "MESH:D012175",
+    "MESH:D012178",
+    "MESH:D012206",
+    "MESH:D012208",
+    "MESH:D012220",
+    "MESH:D012221",
+    "MESH:D012279",
+    "MESH:D012282",
+    "MESH:D012393",
+    "MESH:D012422",
+    "MESH:D012468",
+    "MESH:D012481",
+    "MESH:D012507",
+    "MESH:D012509",
+    "MESH:D012512",
+    "MESH:D012513",
+    "MESH:D012514",
+    "MESH:D012516",
+    "MESH:D012555",
+    "MESH:D012559",
+    "MESH:D012563",
+    "MESH:D012594",
+    "MESH:D012595",
+    "MESH:D012598",
+    "MESH:D012600",
+    "MESH:D012608",
+    "MESH:D012640",
+    "MESH:D012678",
+    "MESH:D012713",
+    "MESH:D012734",
+    "MESH:D012751",
+    "MESH:D012769",
+    "MESH:D012770",
+    "MESH:D012771",
+    "MESH:D012772",
+    "MESH:D012791",
+    "MESH:D012798",
+    "MESH:D012804",
+    "MESH:D012848",
+    "MESH:D012851",
+    "MESH:D012852",
+    "MESH:D012857",
+    "MESH:D012859",
+    "MESH:D012868",
+    "MESH:D012871",
+    "MESH:D012877",
+    "MESH:D012878",
+    "MESH:D012883",
+    "MESH:D012891",
+    "MESH:D012892",
+    "MESH:D012893",
+    "MESH:D012912",
+    "MESH:D012983",
+    "MESH:D013001",
+    "MESH:D013035",
+    "MESH:D013036",
+    "MESH:D013064",
+    "MESH:D013117",
+    "MESH:D013118",
+    "MESH:D013119",
+    "MESH:D013121",
+    "MESH:D013132",
+    "MESH:D013158",
+    "MESH:D013160",
+    "MESH:D013163",
+    "MESH:D013167",
+    "MESH:D013203",
+    "MESH:D013217",
+    "MESH:D013226",
+    "MESH:D013262",
+    "MESH:D013272",
+    "MESH:D013274",
+    "MESH:D013276",
+    "MESH:D013280",
+    "MESH:D013313",
+    "MESH:D013341",
+    "MESH:D013342",
+    "MESH:D013345",
+    "MESH:D013375",
+    "MESH:D013398",
+    "MESH:D013471",
+    "MESH:D013479",
+    "MESH:D013494",
+    "MESH:D013576",
+    "MESH:D013584",
+    "MESH:D013585",
+    "MESH:D013610",
+    "MESH:D013616",
+    "MESH:D013617",
+    "MESH:D013625",
+    "MESH:D013651",
+    "MESH:D013684",
+    "MESH:D013705",
+    "MESH:D013733",
+    "MESH:D013736",
+    "MESH:D013771",
+    "MESH:D013832",
+    "MESH:D013896",
+    "MESH:D013899",
+    "MESH:D013920",
+    "MESH:D013921",
+    "MESH:D013922",
+    "MESH:D013923",
+    "MESH:D013927",
+    "MESH:D013953",
+    "MESH:D013959",
+    "MESH:D013964",
+    "MESH:D013967",
+    "MESH:D013971",
+    "MESH:D013981",
+    "MESH:D014012",
+    "MESH:D014029",
+    "MESH:D014062",
+    "MESH:D014076",
+    "MESH:D014098",
+    "MESH:D014103",
+    "MESH:D014178",
+    "MESH:D014188",
+    "MESH:D014202",
+    "MESH:D014277",
+    "MESH:D014313",
+    "MESH:D014314",
+    "MESH:D014339",
+    "MESH:D014376",
+    "MESH:D014397",
+    "MESH:D014402",
+    "MESH:D014424",
+    "MESH:D014435",
+    "MESH:D014456",
+    "MESH:D014474",
+    "MESH:D014511",
+    "MESH:D014514",
+    "MESH:D014516",
+    "MESH:D014517",
+    "MESH:D014552",
+    "MESH:D014555",
+    "MESH:D014564",
+    "MESH:D014565",
+    "MESH:D014571",
+    "MESH:D014581",
+    "MESH:D014591",
+    "MESH:D014594",
+    "MESH:D014605",
+    "MESH:D014607",
+    "MESH:D014625",
+    "MESH:D014648",
+    "MESH:D014652",
+    "MESH:D014657",
+    "MESH:D014693",
+    "MESH:D014694",
+    "MESH:D014718",
+    "MESH:D014766",
+    "MESH:D014777",
+    "MESH:D014786",
+    "MESH:D014802",
+    "MESH:D014806",
+    "MESH:D014808",
+    "MESH:D014820",
+    "MESH:D014839",
+    "MESH:D014854",
+    "MESH:D014855",
+    "MESH:D014869",
+    "MESH:D014890",
+    "MESH:D014898",
+    "MESH:D014899",
+    "MESH:D014901",
+    "MESH:D014927",
+    "MESH:D014947",
+    "MESH:D014950",
+    "MESH:D014973",
+    "MESH:D014983",
+    "MESH:D015173",
+    "MESH:D015175",
+    "MESH:D015179",
+    "MESH:D015207",
+    "MESH:D015209",
+    "MESH:D015210",
+    "MESH:D015212",
+    "MESH:D015228",
+    "MESH:D015266",
+    "MESH:D015352",
+    "MESH:D015417",
+    "MESH:D015427",
+    "MESH:D015428",
+    "MESH:D015430",
+    "MESH:D015431",
+    "MESH:D015432",
+    "MESH:D015433",
+    "MESH:D015451",
+    "MESH:D015452",
+    "MESH:D015458",
+    "MESH:D015459",
+    "MESH:D015461",
+    "MESH:D015464",
+    "MESH:D015470",
+    "MESH:D015473",
+    "MESH:D015479",
+    "MESH:D015508",
+    "MESH:D015526",
+    "MESH:D015535",
+    "MESH:D015576",
+    "MESH:D015619",
+    "MESH:D015658",
+    "MESH:D015663",
+    "MESH:D015674",
+    "MESH:D015745",
+    "MESH:D015746",
+    "MESH:D015792",
+    "MESH:D015812",
+    "MESH:D015834",
+    "MESH:D015837",
+    "MESH:D015858",
+    "MESH:D015861",
+    "MESH:D015877",
+    "MESH:D016055",
+    "MESH:D016111",
+    "MESH:D016114",
+    "MESH:D016135",
+    "MESH:D016137",
+    "MESH:D016142",
+    "MESH:D016171",
+    "MESH:D016301",
+    "MESH:D016393",
+    "MESH:D016399",
+    "MESH:D016403",
+    "MESH:D016410",
+    "MESH:D016411",
+    "MESH:D016470",
+    "MESH:D016471",
+    "MESH:D016472",
+    "MESH:D016481",
+    "MESH:D016483",
+    "MESH:D016491",
+    "MESH:D016506",
+    "MESH:D016510",
+    "MESH:D016534",
+    "MESH:D016535",
+    "MESH:D016543",
+    "MESH:D016553",
+    "MESH:D016584",
+    "MESH:D016603",
+    "MESH:D016609",
+    "MESH:D016638",
+    "MESH:D016640",
+    "MESH:D016649",
+    "MESH:D016736",
+    "MESH:D016757",
+    "MESH:D016769",
+    "MESH:D016773",
+    "MESH:D016778",
+    "MESH:D016870",
+    "MESH:D016883",
+    "MESH:D016889",
+    "MESH:D016891",
+    "MESH:D016893",
+    "MESH:D016905",
+    "MESH:D016908",
+    "MESH:D017029",
+    "MESH:D017086",
+    "MESH:D017088",
+    "MESH:D017093",
+    "MESH:D017094",
+    "MESH:D017096",
+    "MESH:D017098",
+    "MESH:D017114",
+    "MESH:D017116",
+    "MESH:D017118",
+    "MESH:D017119",
+    "MESH:D017180",
+    "MESH:D017202",
+    "MESH:D017240",
+    "MESH:D017241",
+    "MESH:D017246",
+    "MESH:D017285",
+    "MESH:D017379",
+    "MESH:D017380",
+    "MESH:D017445",
+    "MESH:D017449",
+    "MESH:D017453",
+    "MESH:D017492",
+    "MESH:D017495",
+    "MESH:D017496",
+    "MESH:D017497",
+    "MESH:D017511",
+    "MESH:D017512",
+    "MESH:D017544",
+    "MESH:D017545",
+    "MESH:D017563",
+    "MESH:D017566",
+    "MESH:D017588",
+    "MESH:D017599",
+    "MESH:D017674",
+    "MESH:D017681",
+    "MESH:D017682",
+    "MESH:D017689",
+    "MESH:D017700",
+    "MESH:D017728",
+    "MESH:D017880",
+    "MESH:D017889",
+    "MESH:D018149",
+    "MESH:D018177",
+    "MESH:D018188",
+    "MESH:D018192",
+    "MESH:D018197",
+    "MESH:D018200",
+    "MESH:D018212",
+    "MESH:D018213",
+    "MESH:D018221",
+    "MESH:D018222",
+    "MESH:D018223",
+    "MESH:D018226",
+    "MESH:D018232",
+    "MESH:D018233",
+    "MESH:D018235",
+    "MESH:D018236",
+    "MESH:D018239",
+    "MESH:D018241",
+    "MESH:D018242",
+    "MESH:D018248",
+    "MESH:D018256",
+    "MESH:D018262",
+    "MESH:D018263",
+    "MESH:D018268",
+    "MESH:D018269",
+    "MESH:D018270",
+    "MESH:D018275",
+    "MESH:D018276",
+    "MESH:D018281",
+    "MESH:D018287",
+    "MESH:D018288",
+    "MESH:D018307",
+    "MESH:D018316",
+    "MESH:D018317",
+    "MESH:D018318",
+    "MESH:D018325",
+    "MESH:D018328",
+    "MESH:D018352",
+    "MESH:D018357",
+    "MESH:D018358",
+    "MESH:D018376",
+    "MESH:D018382",
+    "MESH:D018442",
+    "MESH:D018450",
+    "MESH:D018476",
+    "MESH:D018487",
+    "MESH:D018496",
+    "MESH:D018497",
+    "MESH:D018500",
+    "MESH:D018567",
+    "MESH:D018589",
+    "MESH:D018636",
+    "MESH:D018754",
+    "MESH:D018771",
+    "MESH:D018777",
+    "MESH:D018792",
+    "MESH:D018798",
+    "MESH:D018805",
+    "MESH:D018827",
+    "MESH:D018856",
+    "MESH:D018879",
+    "MESH:D018883",
+    "MESH:D018908",
+    "MESH:D018917",
+    "MESH:D018921",
+    "MESH:D018923",
+    "MESH:D018979",
+    "MESH:D019046",
+    "MESH:D019048",
+    "MESH:D019066",
+    "MESH:D019082",
+    "MESH:D019150",
+    "MESH:D019189",
+    "MESH:D019190",
+    "MESH:D019226",
+    "MESH:D019247",
+    "MESH:D019283",
+    "MESH:D019305",
+    "MESH:D019337",
+    "MESH:D019446",
+    "MESH:D019457",
+    "MESH:D019465",
+    "MESH:D019512",
+    "MESH:D019578",
+    "MESH:D019586",
+    "MESH:D019588",
+    "MESH:D019636",
+    "MESH:D019693",
+    "MESH:D019694",
+    "MESH:D019698",
+    "MESH:D019767",
+    "MESH:D019851",
+    "MESH:D019873",
+    "MESH:D019896",
+    "MESH:D019954",
+    "MESH:D019956",
+    "MESH:D019957",
+    "MESH:D019958",
+    "MESH:D019964",
+    "MESH:D019965",
+    "MESH:D019966",
+    "MESH:D019967",
+    "MESH:D019969",
+    "MESH:D019970",
+    "MESH:D020016",
+    "MESH:D020018",
+    "MESH:D020078",
+    "MESH:D020083",
+    "MESH:D020138",
+    "MESH:D020149",
+    "MESH:D020151",
+    "MESH:D020158",
+    "MESH:D020163",
+    "MESH:D020176",
+    "MESH:D020178",
+    "MESH:D020181",
+    "MESH:D020190",
+    "MESH:D020191",
+    "MESH:D020194",
+    "MESH:D020198",
+    "MESH:D020199",
+    "MESH:D020225",
+    "MESH:D020233",
+    "MESH:D020234",
+    "MESH:D020244",
+    "MESH:D020246",
+    "MESH:D020256",
+    "MESH:D020257",
+    "MESH:D020258",
+    "MESH:D020261",
+    "MESH:D020262",
+    "MESH:D020267",
+    "MESH:D020270",
+    "MESH:D020294",
+    "MESH:D020295",
+    "MESH:D020300",
+    "MESH:D020301",
+    "MESH:D020323",
+    "MESH:D020325",
+    "MESH:D020326",
+    "MESH:D020329",
+    "MESH:D020345",
+    "MESH:D020347",
+    "MESH:D020370",
+    "MESH:D020388",
+    "MESH:D020417",
+    "MESH:D020426",
+    "MESH:D020514",
+    "MESH:D020520",
+    "MESH:D020521",
+    "MESH:D020522",
+    "MESH:D020529",
+    "MESH:D020734",
+    "MESH:D020751",
+    "MESH:D020754",
+    "MESH:D020760",
+    "MESH:D020767",
+    "MESH:D020774",
+    "MESH:D020790",
+    "MESH:D020795",
+    "MESH:D020803",
+    "MESH:D020817",
+    "MESH:D020820",
+    "MESH:D020821",
+    "MESH:D020879",
+    "MESH:D020886",
+    "MESH:D020920",
+    "MESH:D020925",
+    "MESH:D020936",
+    "MESH:D020945",
+    "MESH:D020961",
+    "MESH:D020964",
+    "MESH:D020967",
+    "MESH:D020968",
+    "MESH:D021081",
+    "MESH:D021441",
+    "MESH:D022124",
+    "MESH:D023341",
+    "MESH:D023903",
+    "MESH:D023921",
+    "MESH:D024801",
+    "MESH:D024821",
+    "MESH:D027601",
+    "MESH:D028227",
+    "MESH:D028361",
+    "MESH:D029241",
+    "MESH:D029242",
+    "MESH:D029424",
+    "MESH:D029481",
+    "MESH:D029502",
+    "MESH:D029503",
+    "MESH:D029597",
+    "MESH:D030342",
+    "MESH:D030361",
+    "MESH:D030401",
+    "MESH:D033461",
+    "MESH:D034141",
+    "MESH:D034381",
+    "MESH:D034721",
+    "MESH:D038062",
+    "MESH:D038261",
+    "MESH:D039682",
+    "MESH:D041781",
+    "MESH:D042822",
+    "MESH:D042882",
+    "MESH:D042883",
+    "MESH:D043171",
+    "MESH:D043183",
+    "MESH:D044148",
+    "MESH:D044342",
+    "MESH:D044483",
+    "MESH:D044584",
+    "MESH:D044882",
+    "MESH:D044903",
+    "MESH:D045169",
+    "MESH:D045262",
+    "MESH:D045743",
+    "MESH:D046110",
+    "MESH:D046152",
+    "MESH:D046349",
+    "MESH:D046350",
+    "MESH:D046351",
+    "MESH:D046748",
+    "MESH:D047508",
+    "MESH:D047748",
+    "MESH:D047928",
+    "MESH:D048550",
+    "MESH:D048629",
+    "MESH:D048909",
+    "MESH:D049188",
+    "MESH:D049310",
+    "MESH:D049912",
+    "MESH:D049970",
+    "MESH:D050031",
+    "MESH:D050171",
+    "MESH:D050177",
+    "MESH:D050197",
+    "MESH:D050500",
+    "MESH:D050723",
+    "MESH:D051359",
+    "MESH:D051436",
+    "MESH:D051437",
+    "MESH:D051474",
+    "MESH:D052016",
+    "MESH:D052177",
+    "MESH:D052439",
+    "MESH:D052456",
+    "MESH:D052496",
+    "MESH:D052556",
+    "MESH:D052776",
+    "MESH:D052878",
+    "MESH:D053040",
+    "MESH:D053098",
+    "MESH:D053099",
+    "MESH:D053201",
+    "MESH:D053565",
+    "MESH:D053578",
+    "MESH:D053608",
+    "MESH:D053609",
+    "MESH:D053627",
+    "MESH:D053713",
+    "MESH:D053840",
+    "MESH:D054038",
+    "MESH:D054058",
+    "MESH:D054066",
+    "MESH:D054078",
+    "MESH:D054079",
+    "MESH:D054143",
+    "MESH:D054144",
+    "MESH:D054179",
+    "MESH:D054198",
+    "MESH:D054218",
+    "MESH:D054220",
+    "MESH:D054221",
+    "MESH:D054318",
+    "MESH:D054391",
+    "MESH:D054429",
+    "MESH:D054537",
+    "MESH:D054556",
+    "MESH:D054559",
+    "MESH:D054882",
+    "MESH:D054971",
+    "MESH:D054990",
+    "MESH:D055013",
+    "MESH:D055031",
+    "MESH:D055191",
+    "MESH:D055370",
+    "MESH:D055371",
+    "MESH:D055665",
+    "MESH:D055728",
+    "MESH:D055752",
+    "MESH:D055959",
+    "MESH:D055963",
+    "MESH:D056486",
+    "MESH:D056627",
+    "MESH:D056647",
+    "MESH:D056693",
+    "MESH:D056735",
+    "MESH:D056769",
+    "MESH:D056784",
+    "MESH:D056829",
+    "MESH:D056889",
+    "MESH:D056912",
+    "MESH:D056929",
+    "MESH:D057049",
+    "MESH:D057066",
+    "MESH:D057180",
+    "MESH:D057772",
+    "MESH:D057973",
+    "MESH:D058065",
+    "MESH:D058186",
+    "MESH:D058226",
+    "MESH:D058426",
+    "MESH:D058447",
+    "MESH:D058496",
+    "MESH:D058566",
+    "MESH:D058625",
+    "MESH:D058729",
+    "MESH:D058739",
+    "MESH:D058922",
+    "MESH:D059348",
+    "MESH:D059350",
+    "MESH:D059352",
+    "MESH:D059366",
+    "MESH:D059606",
+    "MESH:D060050",
+    "MESH:D060825",
+    "MESH:D061205",
+    "MESH:D062787",
+    "MESH:D063646",
+    "MESH:D063647",
+    "MESH:D064129",
+    "MESH:D064726",
+    "MESH:D064793",
+    "MESH:D065306",
+    "MESH:D065626",
+    "MESH:D065630",
+    "MESH:D065631",
+    "MESH:D065646",
+    "MESH:D065666",
+    "MESH:D065766",
+    "MESH:D065817",
+    "MESH:D065886",
+    "MESH:D066088",
+    "MESH:D066126",
+    "MESH:D066253"
+  ]
+}

saved_models/disease_encoder.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7114defa10f1565caf2c7554720b9faaa5fb9651dd3ecbfd0930f056a82941df
+size 24107

saved_models/disease_ohe_df.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a74b25677f82a65e759b8007fee949d3b998fcc3e53b0c4caeb75d86e619b992
+size 19832087

saved_models/disease_onehot_encoder.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:01a49419d9ec3d2f59a60e51ac54c4b9aefc19c78d584a4b493c7c159432ef64
+size 24603

saved_models/logistic_regression.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e4c679bee7eeee672231864710b629a7e372b2c758ded409f39e255222d6da03
+size 37791

saved_models/metadata.json

@@ -0,0 +1,39 @@
+{
+  "training_date": "2026-01-19 14:03:28",
+  "model_versions": {
+    "tensorflow": "2.16.2",
+    "xgboost": "3.1.3",
+    "sklearn": "1.4.0",
+    "python": "3.10"
+  },
+  "dataset_info": {
+    "num_drugs": 1410,
+    "num_diseases": 1573,
+    "num_associations": 42200,
+    "num_targets": 2018
+  },
+  "feature_engineering": {
+    "morgan_fp_bits": 1024,
+    "morgan_fp_radius": 2,
+    "target_encoding": "multi-hot",
+    "disease_encoding_ml": "one-hot",
+    "disease_encoding_dnn": "embedding"
+  },
+  "model_architecture": {
+    "dnn_drug_layers": [
+      256,
+      128
+    ],
+    "dnn_embedding_dim": 32,
+    "dnn_dropout": 0.3,
+    "dnn_l2_reg": 0.001
+  },
+  "training_config": {
+    "negative_sampling": "1:1 balanced",
+    "train_test_split": 0.2,
+    "random_seed": 42,
+    "dnn_epochs": 30,
+    "dnn_batch_size": 128,
+    "dnn_learning_rate": 0.0001
+  }
+}

saved_models/mm_dnn_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5ff53567647b2f029769e1bda8f4a81decde91d74196dcc9e0070d23c6d89785
+size 10421416

saved_models/mm_dnn_model.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e0a0433d9bd08f94cd118ed9a1445bdfe1c51236c9f5ca33b79e45138d61280
+size 10422861

saved_models/performance.json

@@ -0,0 +1,29 @@
+{
+  "test_metrics": {
+    "Logistic_Regression": {
+      "AUC": 0.8412681094315042,
+      "Accuracy": 0.7679502369668246,
+      "F1": 0.7698184168772404
+    },
+    "Random_Forest": {
+      "AUC": 0.8273200989420723,
+      "Accuracy": 0.7533767772511848,
+      "F1": 0.717628705148206
+    },
+    "XGBoost": {
+      "AUC": 0.7347429724175111,
+      "Accuracy": 0.7026658767772512,
+      "F1": 0.610477299185099
+    },
+    "MM_DNN": {
+      "AUC": 0.8507875496956492,
+      "Accuracy": 0.7731635071090047,
+      "F1": 0.7757540263543192
+    }
+  },
+  "training_info": {
+    "train_size": 67520,
+    "test_size": 16880,
+    "positive_ratio": 0.5
+  }
+}

saved_models/random_forest.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:798846bfc6d6b4d0ac12a4c8c3d818223ecf9786b8a384f3fe8274cefcffb38c
+size 930998329

saved_models/scaler.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c856a7d71e02c97ce9d694638eec6850ef8568b67afcb51587906ef9f3786ecb
+size 150927

saved_models/target_binarizer.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:408b1daa97b6c894afea0ffd4229baae7b996e9bf8ac81a195fe979080d4c64a
+size 18723

saved_models/target_classes.json

@@ -0,0 +1,2022 @@
+{
+  "classes": [
+    "A0A024R8I1",
+    "A0A045ISQ8",
+    "A0A045KKX4",
+    "A0A0E1R3H3",
+    "A0A0H2XJ39",
+    "A0A0T9AZ62",
+    "A0A143ZZK9",
+    "A0A1K3GRG2",
+    "A1L3X4",
+    "A2QLK4",
+    "A5X5Y0",
+    "A9X444",
+    "B0B3C9",
+    "B2ZTR6",
+    "B4YQT9",
+    "C0H4L1",
+    "C0H4V6",
+    "C0H4X5",
+    "C0H4Y6",
+    "C0H546",
+    "C0H551",
+    "C0H571",
+    "C0H5C2",
+    "C0H5H0",
+    "C1KC03",
+    "C3T8E2",
+    "C6KSR5",
+    "C6KT34",
+    "C6KT50",
+    "C6KTA4",
+    "C6S3C7",
+    "C9EH48",
+    "D6R448",
+    "F1L7U3",
+    "F1T0I5",
+    "F7VJQ1",
+    "H3BUU9",
+    "O00180",
+    "O00206",
+    "O00217",
+    "O00264",
+    "O00299",
+    "O00305",
+    "O00329",
+    "O00398",
+    "O00408",
+    "O00469",
+    "O00483",
+    "O00519",
+    "O00555",
+    "O00591",
+    "O00763",
+    "O00764",
+    "O14521",
+    "O14556",
+    "O14561",
+    "O14594",
+    "O14618",
+    "O14649",
+    "O14717",
+    "O14727",
+    "O14732",
+    "O14746",
+    "O14764",
+    "O14788",
+    "O14791",
+    "O14832",
+    "O14920",
+    "O14939",
+    "O14958",
+    "O14983",
+    "O15111",
+    "O15239",
+    "O15264",
+    "O15269",
+    "O15270",
+    "O15304",
+    "O15350",
+    "O15374",
+    "O15375",
+    "O15379",
+    "O15382",
+    "O15392",
+    "O15393",
+    "O15399",
+    "O15403",
+    "O15427",
+    "O15439",
+    "O15440",
+    "O15528",
+    "O15530",
+    "O15547",
+    "O15554",
+    "O25608",
+    "O39930",
+    "O43175",
+    "O43181",
+    "O43193",
+    "O43252",
+    "O43451",
+    "O43497",
+    "O43519",
+    "O43525",
+    "O43526",
+    "O43570",
+    "O43612",
+    "O43617",
+    "O43674",
+    "O43676",
+    "O43677",
+    "O43678",
+    "O43681",
+    "O43708",
+    "O43741",
+    "O43766",
+    "O43772",
+    "O43837",
+    "O43920",
+    "O60218",
+    "O60359",
+    "O60391",
+    "O60427",
+    "O60488",
+    "O60494",
+    "O60502",
+    "O60568",
+    "O60603",
+    "O60656",
+    "O60658",
+    "O60669",
+    "O60674",
+    "O60701",
+    "O60706",
+    "O60733",
+    "O60840",
+    "O60858",
+    "O60931",
+    "O60939",
+    "O68601",
+    "O75185",
+    "O75251",
+    "O75306",
+    "O75311",
+    "O75330",
+    "O75340",
+    "O75343",
+    "O75380",
+    "O75438",
+    "O75469",
+    "O75489",
+    "O75493",
+    "O75600",
+    "O75636",
+    "O75715",
+    "O75762",
+    "O75838",
+    "O75880",
+    "O75891",
+    "O75897",
+    "O75899",
+    "O75908",
+    "O75911",
+    "O75912",
+    "O75936",
+    "O75964",
+    "O76054",
+    "O76074",
+    "O76082",
+    "O76083",
+    "O77323",
+    "O77361",
+    "O90777",
+    "O94760",
+    "O94788",
+    "O94903",
+    "O94956",
+    "O95069",
+    "O95139",
+    "O95167",
+    "O95168",
+    "O95169",
+    "O95178",
+    "O95180",
+    "O95182",
+    "O95237",
+    "O95255",
+    "O95259",
+    "O95263",
+    "O95264",
+    "O95298",
+    "O95299",
+    "O95342",
+    "O95470",
+    "O95477",
+    "O95479",
+    "O95622",
+    "O95644",
+    "O95665",
+    "O95718",
+    "O95749",
+    "O95864",
+    "O95907",
+    "O95954",
+    "O95977",
+    "O96000",
+    "O96221",
+    "O97313",
+    "P00091",
+    "P00138",
+    "P00167",
+    "P00183",
+    "P00325",
+    "P00326",
+    "P00338",
+    "P00352",
+    "P00363",
+    "P00367",
+    "P00374",
+    "P00378",
+    "P00387",
+    "P00390",
+    "P00395",
+    "P00439",
+    "P00441",
+    "P00450",
+    "P00484",
+    "P00491",
+    "P00492",
+    "P00505",
+    "P00509",
+    "P00519",
+    "P00533",
+    "P00558",
+    "P00582",
+    "P00709",
+    "P00720",
+    "P00734",
+    "P00736",
+    "P00738",
+    "P00739",
+    "P00740",
+    "P00742",
+    "P00747",
+    "P00748",
+    "P00749",
+    "P00750",
+    "P00751",
+    "P00797",
+    "P00811",
+    "P00813",
+    "P00846",
+    "P00915",
+    "P00918",
+    "P00966",
+    "P01008",
+    "P01009",
+    "P01011",
+    "P01019",
+    "P01023",
+    "P01024",
+    "P01031",
+    "P01042",
+    "P01100",
+    "P01106",
+    "P01133",
+    "P01137",
+    "P01138",
+    "P01189",
+    "P01303",
+    "P01308",
+    "P01375",
+    "P01579",
+    "P01584",
+    "P01591",
+    "P01599",
+    "P01619",
+    "P01709",
+    "P01857",
+    "P01861",
+    "P01871",
+    "P01876",
+    "P02359",
+    "P02452",
+    "P02533",
+    "P02538",
+    "P02585",
+    "P02647",
+    "P02649",
+    "P02652",
+    "P02655",
+    "P02656",
+    "P02671",
+    "P02689",
+    "P02708",
+    "P02743",
+    "P02746",
+    "P02747",
+    "P02748",
+    "P02749",
+    "P02750",
+    "P02751",
+    "P02753",
+    "P02763",
+    "P02765",
+    "P02766",
+    "P02768",
+    "P02775",
+    "P02786",
+    "P02787",
+    "P02788",
+    "P02790",
+    "P02792",
+    "P02794",
+    "P02795",
+    "P02818",
+    "P02918",
+    "P02919",
+    "P03366",
+    "P03369",
+    "P03372",
+    "P03886",
+    "P03891",
+    "P03897",
+    "P03901",
+    "P03905",
+    "P03915",
+    "P03923",
+    "P03951",
+    "P03952",
+    "P04003",
+    "P04004",
+    "P04035",
+    "P04040",
+    "P04049",
+    "P04054",
+    "P04070",
+    "P04075",
+    "P04080",
+    "P04083",
+    "P04114",
+    "P04150",
+    "P04155",
+    "P04156",
+    "P04179",
+    "P04181",
+    "P04196",
+    "P04217",
+    "P04264",
+    "P04271",
+    "P04278",
+    "P04279",
+    "P04293",
+    "P04350",
+    "P04406",
+    "P04585",
+    "P04626",
+    "P04629",
+    "P04637",
+    "P04731",
+    "P04732",
+    "P04733",
+    "P04746",
+    "P04792",
+    "P04798",
+    "P04818",
+    "P04839",
+    "P05023",
+    "P05026",
+    "P05067",
+    "P05089",
+    "P05090",
+    "P05091",
+    "P05093",
+    "P05106",
+    "P05108",
+    "P05109",
+    "P05113",
+    "P05121",
+    "P05129",
+    "P05141",
+    "P05155",
+    "P05156",
+    "P05160",
+    "P05164",
+    "P05165",
+    "P05166",
+    "P05177",
+    "P05181",
+    "P05187",
+    "P05193",
+    "P05230",
+    "P05231",
+    "P05362",
+    "P05412",
+    "P05452",
+    "P05543",
+    "P05546",
+    "P05653",
+    "P05771",
+    "P05787",
+    "P06149",
+    "P06213",
+    "P06239",
+    "P06241",
+    "P06276",
+    "P06307",
+    "P06396",
+    "P06401",
+    "P06478",
+    "P06576",
+    "P06702",
+    "P06703",
+    "P06715",
+    "P06727",
+    "P06732",
+    "P06733",
+    "P06737",
+    "P06744",
+    "P06746",
+    "P06748",
+    "P06756",
+    "P06818",
+    "P06858",
+    "P06864",
+    "P06870",
+    "P06881",
+    "P07098",
+    "P07101",
+    "P07195",
+    "P07202",
+    "P07203",
+    "P07204",
+    "P07225",
+    "P07237",
+    "P07288",
+    "P07327",
+    "P07333",
+    "P07355",
+    "P07357",
+    "P07358",
+    "P07359",
+    "P07360",
+    "P07437",
+    "P07438",
+    "P07451",
+    "P07477",
+    "P07550",
+    "P07686",
+    "P07737",
+    "P07741",
+    "P07864",
+    "P07900",
+    "P07947",
+    "P07948",
+    "P07949",
+    "P08069",
+    "P08100",
+    "P08149",
+    "P08172",
+    "P08173",
+    "P08174",
+    "P08183",
+    "P08185",
+    "P08235",
+    "P08238",
+    "P08243",
+    "P08253",
+    "P08294",
+    "P08319",
+    "P08473",
+    "P08493",
+    "P08506",
+    "P08519",
+    "P08546",
+    "P08559",
+    "P08581",
+    "P08588",
+    "P08603",
+    "P08620",
+    "P08648",
+    "P08670",
+    "P08684",
+    "P08686",
+    "P08697",
+    "P08700",
+    "P08708",
+    "P08729",
+    "P08758",
+    "P08779",
+    "P08865",
+    "P08908",
+    "P08909",
+    "P08912",
+    "P08913",
+    "P08922",
+    "P09038",
+    "P09172",
+    "P09210",
+    "P09211",
+    "P09250",
+    "P09252",
+    "P09382",
+    "P09417",
+    "P09429",
+    "P09455",
+    "P09466",
+    "P09486",
+    "P09488",
+    "P09493",
+    "P09525",
+    "P09601",
+    "P09619",
+    "P09622",
+    "P09769",
+    "P09871",
+    "P09874",
+    "P09884",
+    "P09917",
+    "P0A0K8",
+    "P0A334",
+    "P0A3M5",
+    "P0A3M6",
+    "P0A4L9",
+    "P0A6I3",
+    "P0A6J8",
+    "P0A6R0",
+    "P0A749",
+    "P0A7J6",
+    "P0A7R5",
+    "P0A7S3",
+    "P0A7S9",
+    "P0A7U3",
+    "P0A7V3",
+    "P0A7V8",
+    "P0A7W7",
+    "P0A7X3",
+    "P0A7Z4",
+    "P0A8T7",
+    "P0A8V2",
+    "P0A953",
+    "P0AAI5",
+    "P0ABP8",
+    "P0ABQ4",
+    "P0AC13",
+    "P0AD63",
+    "P0AD65",
+    "P0AD68",
+    "P0ADY7",
+    "P0AEB2",
+    "P0AES4",
+    "P0AF12",
+    "P0AFI5",
+    "P0AFU8",
+    "P0AG59",
+    "P0C002",
+    "P0C0H6",
+    "P0C0L5",
+    "P0C0X1",
+    "P0C0X2",
+    "P0C1U9",
+    "P0CG04",
+    "P0DJD9",
+    "P0DM35",
+    "P0DMS8",
+    "P0DP23",
+    "P0DP24",
+    "P0DP25",
+    "P10109",
+    "P10253",
+    "P10275",
+    "P10276",
+    "P10398",
+    "P10412",
+    "P10415",
+    "P10515",
+    "P10613",
+    "P10632",
+    "P10635",
+    "P10636",
+    "P10696",
+    "P10721",
+    "P10724",
+    "P10809",
+    "P10826",
+    "P10827",
+    "P10828",
+    "P10909",
+    "P10915",
+    "P10997",
+    "P11021",
+    "P11137",
+    "P11142",
+    "P11166",
+    "P11168",
+    "P11177",
+    "P11216",
+    "P11217",
+    "P11229",
+    "P11274",
+    "P11362",
+    "P11387",
+    "P11388",
+    "P11413",
+    "P11473",
+    "P11474",
+    "P11485",
+    "P11498",
+    "P11511",
+    "P11586",
+    "P11678",
+    "P11712",
+    "P11766",
+    "P11802",
+    "P11926",
+    "P12004",
+    "P12070",
+    "P12104",
+    "P12235",
+    "P12236",
+    "P12256",
+    "P12268",
+    "P12277",
+    "P12429",
+    "P12461",
+    "P12532",
+    "P12644",
+    "P12724",
+    "P12814",
+    "P12821",
+    "P12823",
+    "P12851",
+    "P12931",
+    "P13196",
+    "P13498",
+    "P13500",
+    "P13551",
+    "P13568",
+    "P13569",
+    "P13611",
+    "P13631",
+    "P13637",
+    "P13640",
+    "P13645",
+    "P13647",
+    "P13674",
+    "P13693",
+    "P13716",
+    "P13817",
+    "P13827",
+    "P13830",
+    "P13922",
+    "P13945",
+    "P13995",
+    "P14060",
+    "P14061",
+    "P14207",
+    "P14210",
+    "P14223",
+    "P14324",
+    "P14410",
+    "P14415",
+    "P14416",
+    "P14550",
+    "P14555",
+    "P14598",
+    "P14618",
+    "P14625",
+    "P14642",
+    "P14677",
+    "P14679",
+    "P14735",
+    "P14770",
+    "P14780",
+    "P14866",
+    "P14867",
+    "P14902",
+    "P14923",
+    "P15056",
+    "P15121",
+    "P15144",
+    "P15153",
+    "P15169",
+    "P15328",
+    "P15336",
+    "P15382",
+    "P15428",
+    "P15502",
+    "P15531",
+    "P15538",
+    "P15555",
+    "P15559",
+    "P15587",
+    "P15692",
+    "P15814",
+    "P15880",
+    "P15924",
+    "P16050",
+    "P16066",
+    "P16070",
+    "P16083",
+    "P16152",
+    "P16219",
+    "P16220",
+    "P16233",
+    "P16234",
+    "P16389",
+    "P16444",
+    "P16455",
+    "P16499",
+    "P16502",
+    "P16581",
+    "P16615",
+    "P16860",
+    "P17050",
+    "P17117",
+    "P17174",
+    "P17252",
+    "P17302",
+    "P17405",
+    "P17516",
+    "P17540",
+    "P17544",
+    "P17568",
+    "P17612",
+    "P17658",
+    "P17707",
+    "P17735",
+    "P17752",
+    "P17787",
+    "P17802",
+    "P17844",
+    "P17936",
+    "P17948",
+    "P18089",
+    "P18251",
+    "P18283",
+    "P18314",
+    "P18405",
+    "P18505",
+    "P18507",
+    "P18545",
+    "P18669",
+    "P18825",
+    "P18846",
+    "P18847",
+    "P18848",
+    "P18850",
+    "P18858",
+    "P19021",
+    "P19113",
+    "P19320",
+    "P19404",
+    "P19525",
+    "P19634",
+    "P19652",
+    "P19793",
+    "P19801",
+    "P19823",
+    "P19827",
+    "P19838",
+    "P19878",
+    "P19961",
+    "P20020",
+    "P20035",
+    "P20061",
+    "P20132",
+    "P20276",
+    "P20309",
+    "P20618",
+    "P20648",
+    "P20701",
+    "P20711",
+    "P20742",
+    "P20810",
+    "P20815",
+    "P20831",
+    "P20839",
+    "P20851",
+    "P21281",
+    "P21291",
+    "P21333",
+    "P21397",
+    "P21430",
+    "P21453",
+    "P21462",
+    "P21549",
+    "P21554",
+    "P21589",
+    "P21695",
+    "P21728",
+    "P21731",
+    "P21796",
+    "P21802",
+    "P21817",
+    "P21917",
+    "P21918",
+    "P21964",
+    "P22001",
+    "P22033",
+    "P22102",
+    "P22303",
+    "P22352",
+    "P22455",
+    "P22459",
+    "P22460",
+    "P22557",
+    "P22607",
+    "P22626",
+    "P22676",
+    "P22748",
+    "P22792",
+    "P22888",
+    "P22894",
+    "P23141",
+    "P23219",
+    "P23246",
+    "P23258",
+    "P23280",
+    "P23297",
+    "P23367",
+    "P23368",
+    "P23378",
+    "P23415",
+    "P23416",
+    "P23458",
+    "P23469",
+    "P23526",
+    "P23528",
+    "P23560",
+    "P23634",
+    "P23743",
+    "P23786",
+    "P23921",
+    "P23975",
+    "P24024",
+    "P24046",
+    "P24093",
+    "P24228",
+    "P24298",
+    "P24300",
+    "P24385",
+    "P24462",
+    "P24530",
+    "P24666",
+    "P24752",
+    "P25021",
+    "P25024",
+    "P25092",
+    "P25098",
+    "P25100",
+    "P25101",
+    "P25103",
+    "P25105",
+    "P25311",
+    "P25705",
+    "P25713",
+    "P25815",
+    "P25963",
+    "P26358",
+    "P26439",
+    "P26447",
+    "P26676",
+    "P27169",
+    "P27338",
+    "P27361",
+    "P27487",
+    "P27635",
+    "P27707",
+    "P27797",
+    "P27815",
+    "P27816",
+    "P27824",
+    "P27907",
+    "P28062",
+    "P28065",
+    "P28074",
+    "P28221",
+    "P28222",
+    "P28223",
+    "P28329",
+    "P28331",
+    "P28335",
+    "P28472",
+    "P28482",
+    "P28566",
+    "P28676",
+    "P28702",
+    "P28845",
+    "P29034",
+    "P29074",
+    "P29218",
+    "P29274",
+    "P29275",
+    "P29317",
+    "P29371",
+    "P29372",
+    "P29401",
+    "P29422",
+    "P29466",
+    "P29474",
+    "P29475",
+    "P29590",
+    "P29597",
+    "P29622",
+    "P29762",
+    "P29803",
+    "P29972",
+    "P30038",
+    "P30041",
+    "P30043",
+    "P30044",
+    "P30049",
+    "P30085",
+    "P30086",
+    "P30101",
+    "P30405",
+    "P30411",
+    "P30518",
+    "P30519",
+    "P30531",
+    "P30532",
+    "P30536",
+    "P30542",
+    "P30556",
+    "P30559",
+    "P30613",
+    "P30626",
+    "P30837",
+    "P30838",
+    "P30872",
+    "P30874",
+    "P30926",
+    "P30939",
+    "P30968",
+    "P31025",
+    "P31040",
+    "P31151",
+    "P31152",
+    "P31153",
+    "P31213",
+    "P31260",
+    "P31350",
+    "P31391",
+    "P31415",
+    "P31639",
+    "P31644",
+    "P31645",
+    "P31749",
+    "P31937",
+    "P31939",
+    "P31942",
+    "P31943",
+    "P31946",
+    "P31948",
+    "P32004",
+    "P32119",
+    "P32238",
+    "P32239",
+    "P32297",
+    "P32322",
+    "P32418",
+    "P32745",
+    "P32754",
+    "P32929",
+    "P33121",
+    "P33151",
+    "P33261",
+    "P33402",
+    "P33527",
+    "P34896",
+    "P34897",
+    "P34903",
+    "P34969",
+    "P34972",
+    "P34995",
+    "P35218",
+    "P35219",
+    "P35222",
+    "P35228",
+    "P35346",
+    "P35348",
+    "P35354",
+    "P35367",
+    "P35368",
+    "P35372",
+    "P35408",
+    "P35462",
+    "P35498",
+    "P35499",
+    "P35520",
+    "P35527",
+    "P35556",
+    "P35579",
+    "P35610",
+    "P35626",
+    "P35858",
+    "P35869",
+    "P35908",
+    "P35913",
+    "P35916",
+    "P35968",
+    "P36021",
+    "P36507",
+    "P36542",
+    "P36544",
+    "P36578",
+    "P36888",
+    "P36896",
+    "P36955",
+    "P36969",
+    "P37023",
+    "P37058",
+    "P37059",
+    "P37088",
+    "P37108",
+    "P37231",
+    "P37288",
+    "P37610",
+    "P37802",
+    "P37840",
+    "P38435",
+    "P38545",
+    "P38606",
+    "P38936",
+    "P39019",
+    "P39023",
+    "P39086",
+    "P39748",
+    "P39900",
+    "P40238",
+    "P40261",
+    "P40306",
+    "P40394",
+    "P40925",
+    "P40926",
+    "P40933",
+    "P40939",
+    "P41143",
+    "P41145",
+    "P41146",
+    "P41180",
+    "P41222",
+    "P41231",
+    "P41238",
+    "P41240",
+    "P41250",
+    "P41439",
+    "P41594",
+    "P41595",
+    "P41743",
+    "P42261",
+    "P42262",
+    "P42263",
+    "P42330",
+    "P42336",
+    "P42338",
+    "P42345",
+    "P42574",
+    "P42684",
+    "P42685",
+    "P42765",
+    "P42766",
+    "P42858",
+    "P42898",
+    "P42971",
+    "P43088",
+    "P43115",
+    "P43116",
+    "P43119",
+    "P43155",
+    "P43166",
+    "P43353",
+    "P43405",
+    "P43487",
+    "P43652",
+    "P43657",
+    "P43681",
+    "P43700",
+    "P43702",
+    "P44345",
+    "P44469",
+    "P45059",
+    "P45381",
+    "P45844",
+    "P45954",
+    "P45973",
+    "P45983",
+    "P45984",
+    "P46059",
+    "P46098",
+    "P46597",
+    "P46663",
+    "P46736",
+    "P46781",
+    "P46782",
+    "P46925",
+    "P46939",
+    "P46940",
+    "P47712",
+    "P47775",
+    "P47869",
+    "P47870",
+    "P47895",
+    "P47898",
+    "P47900",
+    "P47901",
+    "P47944",
+    "P47989",
+    "P48029",
+    "P48039",
+    "P48047",
+    "P48048",
+    "P48050",
+    "P48051",
+    "P48058",
+    "P48163",
+    "P48167",
+    "P48169",
+    "P48181",
+    "P48443",
+    "P48448",
+    "P48506",
+    "P48507",
+    "P48544",
+    "P48547",
+    "P48549",
+    "P48637",
+    "P48651",
+    "P48723",
+    "P48728",
+    "P49019",
+    "P49069",
+    "P49146",
+    "P49189",
+    "P49228",
+    "P49286",
+    "P49327",
+    "P49354",
+    "P49356",
+    "P49368",
+    "P49411",
+    "P49419",
+    "P49448",
+    "P49585",
+    "P49589",
+    "P49619",
+    "P49642",
+    "P49721",
+    "P49747",
+    "P49788",
+    "P49821",
+    "P49841",
+    "P49888",
+    "P49902",
+    "P49908",
+    "P49916",
+    "P50052",
+    "P50135",
+    "P50213",
+    "P50250",
+    "P50406",
+    "P50416",
+    "P50440",
+    "P50453",
+    "P50579",
+    "P50747",
+    "P50859",
+    "P50897",
+    "P50914",
+    "P50993",
+    "P51160",
+    "P51168",
+    "P51170",
+    "P51172",
+    "P51512",
+    "P51553",
+    "P51575",
+    "P51580",
+    "P51582",
+    "P51648",
+    "P51649",
+    "P51659",
+    "P51681",
+    "P51692",
+    "P51693",
+    "P51787",
+    "P51788",
+    "P51800",
+    "P51812",
+    "P51843",
+    "P51857",
+    "P51858",
+    "P51884",
+    "P51970",
+    "P52209",
+    "P52333",
+    "P52429",
+    "P52647",
+    "P52664",
+    "P52788",
+    "P52824",
+    "P52895",
+    "P53004",
+    "P53041",
+    "P53667",
+    "P53778",
+    "P53779",
+    "P53805",
+    "P53848",
+    "P53985",
+    "P54219",
+    "P54284",
+    "P54289",
+    "P54577",
+    "P54619",
+    "P54646",
+    "P54687",
+    "P54709",
+    "P54710",
+    "P54750",
+    "P54756",
+    "P54760",
+    "P54762",
+    "P54965",
+    "P55011",
+    "P55017",
+    "P55055",
+    "P55157",
+    "P55211",
+    "P55786",
+    "P56181",
+    "P56282",
+    "P56373",
+    "P56381",
+    "P56524",
+    "P56537",
+    "P56556",
+    "P56696",
+    "P56937",
+    "P57059",
+    "P59676",
+    "P59768",
+    "P59796",
+    "P60174",
+    "P60568",
+    "P60723",
+    "P60842",
+    "P61024",
+    "P61073",
+    "P61769",
+    "P61978",
+    "P61987",
+    "P62166",
+    "P62241",
+    "P62269",
+    "P62277",
+    "P62316",
+    "P62508",
+    "P62580",
+    "P62594",
+    "P62750",
+    "P62753",
+    "P62807",
+    "P62857",
+    "P62937",
+    "P62942",
+    "P62955",
+    "P63000",
+    "P63244",
+    "P63252",
+    "P63261",
+    "P63316",
+    "P66010",
+    "P67870",
+    "P68104",
+    "P68366",
+    "P68371",
+    "P68400",
+    "P68871",
+    "P69905",
+    "P69924",
+    "P72355",
+    "P72524",
+    "P72525",
+    "P76577",
+    "P78330",
+    "P78334",
+    "P78348",
+    "P78362",
+    "P78508",
+    "P78527",
+    "P78559",
+    "P80075",
+    "P80294",
+    "P80297",
+    "P80303",
+    "P80365",
+    "P80404",
+    "P80511",
+    "P80748",
+    "P81605",
+    "P83223",
+    "P83812",
+    "P84077",
+    "P86287",
+    "P87764",
+    "P95029",
+    "P95468",
+    "P96965",
+    "P98066",
+    "P98194",
+    "P99999",
+    "P9WGR1",
+    "P9WGY7",
+    "P9WIE5",
+    "P9WIP7",
+    "P9WJ63",
+    "P9WJY5",
+    "P9WNL5",
+    "P9WNL7",
+    "P9WNL9",
+    "P9WNX1",
+    "P9WPS1",
+    "Q00080",
+    "Q00266",
+    "Q00534",
+    "Q00653",
+    "Q00796",
+    "Q00975",
+    "Q00987",
+    "Q01064",
+    "Q01082",
+    "Q01118",
+    "Q01344",
+    "Q01668",
+    "Q01718",
+    "Q01814",
+    "Q01959",
+    "Q01995",
+    "Q02083",
+    "Q02108",
+    "Q02127",
+    "Q02153",
+    "Q02155",
+    "Q02156",
+    "Q02218",
+    "Q02252",
+    "Q02338",
+    "Q02383",
+    "Q02641",
+    "Q02750",
+    "Q02763",
+    "Q02768",
+    "Q02809",
+    "Q02817",
+    "Q02818",
+    "Q02880",
+    "Q02928",
+    "Q03154",
+    "Q03181",
+    "Q03393",
+    "Q03403",
+    "Q03721",
+    "Q04206",
+    "Q04707",
+    "Q04759",
+    "Q04760",
+    "Q04771",
+    "Q04828",
+    "Q04912",
+    "Q05486",
+    "Q05513",
+    "Q05586",
+    "Q05603",
+    "Q05655",
+    "Q05901",
+    "Q05932",
+    "Q05940",
+    "Q06033",
+    "Q06187",
+    "Q06203",
+    "Q06278",
+    "Q06323",
+    "Q06432",
+    "Q06481",
+    "Q06830",
+    "Q06AK7",
+    "Q07020",
+    "Q07021",
+    "Q07343",
+    "Q07699",
+    "Q07806",
+    "Q07864",
+    "Q07869",
+    "Q07912",
+    "Q07955",
+    "Q08170",
+    "Q08210",
+    "Q08257",
+    "Q08288",
+    "Q08289",
+    "Q08345",
+    "Q08426",
+    "Q08460",
+    "Q08462",
+    "Q08493",
+    "Q08499",
+    "Q08828",
+    "Q08853",
+    "Q08881",
+    "Q09428",
+    "Q09470",
+    "Q0VD83",
+    "Q12791",
+    "Q12809",
+    "Q12879",
+    "Q12882",
+    "Q13002",
+    "Q13003",
+    "Q13085",
+    "Q13126",
+    "Q13131",
+    "Q13133",
+    "Q13164",
+    "Q13224",
+    "Q13258",
+    "Q13303",
+    "Q13315",
+    "Q13332",
+    "Q13370",
+    "Q13393",
+    "Q13423",
+    "Q13547",
+    "Q13564",
+    "Q13574",
+    "Q13621",
+    "Q13630",
+    "Q13639",
+    "Q13698",
+    "Q13733",
+    "Q13748",
+    "Q13838",
+    "Q13882",
+    "Q13936",
+    "Q13938",
+    "Q13946",
+    "Q13956",
+    "Q14003",
+    "Q14032",
+    "Q14081",
+    "Q14103",
+    "Q14123",
+    "Q14145",
+    "Q14181",
+    "Q14289",
+    "Q14330",
+    "Q14353",
+    "Q14432",
+    "Q14457",
+    "Q14500",
+    "Q14520",
+    "Q14524",
+    "Q14534",
+    "Q14541",
+    "Q14542",
+    "Q14571",
+    "Q14573",
+    "Q14624",
+    "Q14643",
+    "Q14654",
+    "Q14697",
+    "Q14721",
+    "Q14722",
+    "Q14749",
+    "Q14872",
+    "Q14957",
+    "Q14978",
+    "Q14994",
+    "Q15080",
+    "Q15111",
+    "Q15125",
+    "Q15155",
+    "Q15185",
+    "Q15238",
+    "Q15274",
+    "Q15303",
+    "Q15391",
+    "Q15428",
+    "Q15493",
+    "Q15596",
+    "Q15637",
+    "Q15722",
+    "Q15738",
+    "Q15746",
+    "Q15759",
+    "Q15800",
+    "Q15822",
+    "Q15825",
+    "Q15842",
+    "Q15858",
+    "Q15878",
+    "Q15942",
+    "Q16099",
+    "Q16134",
+    "Q16322",
+    "Q16348",
+    "Q16445",
+    "Q16478",
+    "Q16515",
+    "Q16539",
+    "Q16555",
+    "Q16558",
+    "Q16568",
+    "Q16595",
+    "Q16602",
+    "Q16620",
+    "Q16647",
+    "Q16654",
+    "Q16659",
+    "Q16665",
+    "Q16671",
+    "Q16678",
+    "Q16718",
+    "Q16719",
+    "Q16720",
+    "Q16739",
+    "Q16760",
+    "Q16773",
+    "Q16790",
+    "Q16795",
+    "Q16798",
+    "Q16832",
+    "Q16836",
+    "Q16850",
+    "Q16853",
+    "Q16873",
+    "Q16878",
+    "Q16881",
+    "Q23022",
+    "Q25634",
+    "Q27218",
+    "Q27738",
+    "Q27743",
+    "Q2G0P0",
+    "Q32P28",
+    "Q47066",
+    "Q49184",
+    "Q4U2R8",
+    "Q51504",
+    "Q51911",
+    "Q53707",
+    "Q53ET4",
+    "Q54873",
+    "Q59192",
+    "Q59961",
+    "Q59FK2",
+    "Q59GM9",
+    "Q5JAM2",
+    "Q5JVS0",
+    "Q5JXX5",
+    "Q5KSL6",
+    "Q5L478",
+    "Q5R2K6",
+    "Q5SHN7",
+    "Q5SL87",
+    "Q5SSJ5",
+    "Q5UBX3",
+    "Q5VZ30",
+    "Q60FT7",
+    "Q693P7",
+    "Q6FHJ7",
+    "Q6GI75",
+    "Q6IB77",
+    "Q6IBS8",
+    "Q6LFH8",
+    "Q6MZM0",
+    "Q6N063",
+    "Q6NS38",
+    "Q6NUM9",
+    "Q6PIU1",
+    "Q6UX15",
+    "Q6V0L0",
+    "Q6W5P4",
+    "Q6WRI0",
+    "Q6YP21",
+    "Q6ZMR3",
+    "Q6ZQY3",
+    "Q701N4",
+    "Q70KI2",
+    "Q70Z44",
+    "Q71U36",
+    "Q72547",
+    "Q72874",
+    "Q75N90",
+    "Q75Y35",
+    "Q76NM6",
+    "Q76NN7",
+    "Q7CRA4",
+    "Q7DHH4",
+    "Q7K6A4",
+    "Q7KQK0",
+    "Q7KQL5",
+    "Q7KQM4",
+    "Q7L0J3",
+    "Q7LG56",
+    "Q7RTT9",
+    "Q7RTX0",
+    "Q7SIE2",
+    "Q7Z2W7",
+    "Q7Z3S7",
+    "Q7Z5B4",
+    "Q86T13",
+    "Q86U10",
+    "Q86UW7",
+    "Q86V67",
+    "Q86VZ1",
+    "Q86W47",
+    "Q86XP1",
+    "Q86Y39",
+    "Q86YN6",
+    "Q86YZ3",
+    "Q89ZI2",
+    "Q8DNB6",
+    "Q8DR59",
+    "Q8I0V4",
+    "Q8I0X2",
+    "Q8I2Z8",
+    "Q8I3T9",
+    "Q8I3X4",
+    "Q8I3Z5",
+    "Q8I431",
+    "Q8I487",
+    "Q8I492",
+    "Q8I4R5",
+    "Q8I4W4",
+    "Q8I5G6",
+    "Q8I5H4",
+    "Q8I5Y3",
+    "Q8I6U8",
+    "Q8IAW0",
+    "Q8IB72",
+    "Q8IB78",
+    "Q8IBI3",
+    "Q8IBN5",
+    "Q8IBS5",
+    "Q8IC05",
+    "Q8ID50",
+    "Q8IDD3",
+    "Q8IDH5",
+    "Q8IDI5",
+    "Q8IDP1",
+    "Q8IDP8",
+    "Q8IDQ9",
+    "Q8IDV0",
+    "Q8IE67",
+    "Q8IE82",
+    "Q8IEM3",
+    "Q8IEN3",
+    "Q8IHS5",
+    "Q8II73",
+    "Q8IIA4",
+    "Q8III5",
+    "Q8IIJ9",
+    "Q8IIR9",
+    "Q8IJ60",
+    "Q8IJ74",
+    "Q8IJA9",
+    "Q8IJC6",
+    "Q8IJK8",
+    "Q8IJN7",
+    "Q8IJR6",
+    "Q8IJT2",
+    "Q8IKF0",
+    "Q8IKH8",
+    "Q8IKK7",
+    "Q8IKL4",
+    "Q8IKM5",
+    "Q8IKM6",
+    "Q8IKR1",
+    "Q8IKW5",
+    "Q8IL80",
+    "Q8IL86",
+    "Q8IL88",
+    "Q8ILE8",
+    "Q8ILF7",
+    "Q8ILK3",
+    "Q8ILQ7",
+    "Q8ILV2",
+    "Q8IM15",
+    "Q8IM16",
+    "Q8IM74",
+    "Q8IUZ5",
+    "Q8IVA8",
+    "Q8IVH4",
+    "Q8IVL5",
+    "Q8IVL6",
+    "Q8IWT1",
+    "Q8IZS8",
+    "Q8L103",
+    "Q8N0U8",
+    "Q8N1C3",
+    "Q8N1G2",
+    "Q8N1Q1",
+    "Q8N339",
+    "Q8N543",
+    "Q8N5Z0",
+    "Q8N8N7",
+    "Q8N8R3",
+    "Q8N907",
+    "Q8NBN7",
+    "Q8NCM2",
+    "Q8NER1",
+    "Q8NET8",
+    "Q8NFJ5",
+    "Q8NG66",
+    "Q8RLY5",
+    "Q8TAB3",
+    "Q8TAE7",
+    "Q8TC12",
+    "Q8TCC7",
+    "Q8TCG2",
+    "Q8TCT1",
+    "Q8TCT9",
+    "Q8TCU5",
+    "Q8TD08",
+    "Q8TD30",
+    "Q8TD43",
+    "Q8TDN1",
+    "Q8TDN2",
+    "Q8TDS4",
+    "Q8TDU6",
+    "Q8TE23",
+    "Q8TED1",
+    "Q8TET4",
+    "Q8WTV0",
+    "Q8WU03",
+    "Q8WUI4",
+    "Q8WWG9",
+    "Q8WWQ8",
+    "Q8WXA8",
+    "Q8WXI7",
+    "Q8WXS5",
+    "Q8WYK2",
+    "Q8XB74",
+    "Q8XJ01",
+    "Q91RS4",
+    "Q92206",
+    "Q92482",
+    "Q92506",
+    "Q92570",
+    "Q92731",
+    "Q92736",
+    "Q92753",
+    "Q92769",
+    "Q92781",
+    "Q92806",
+    "Q92887",
+    "Q92911",
+    "Q92945",
+    "Q92952",
+    "Q92953",
+    "Q93083",
+    "Q93086",
+    "Q93088",
+    "Q969G6",
+    "Q969I3",
+    "Q969P6",
+    "Q969S2",
+    "Q969S8",
+    "Q96A70",
+    "Q96C36",
+    "Q96DB2",
+    "Q96DP5",
+    "Q96EB6",
+    "Q96EN8",
+    "Q96ER9",
+    "Q96FI4",
+    "Q96FQ6",
+    "Q96G91",
+    "Q96GA7",
+    "Q96GD0",
+    "Q96I15",
+    "Q96KK3",
+    "Q96KS0",
+    "Q96L12",
+    "Q96L21",
+    "Q96L42",
+    "Q96LZ3",
+    "Q96NR8",
+    "Q96P88",
+    "Q96PD5",
+    "Q96PR1",
+    "Q96Q40",
+    "Q96Q83",
+    "Q96QT4",
+    "Q96RD7",
+    "Q96RE1",
+    "Q96RI1",
+    "Q96RJ0",
+    "Q96RP8",
+    "Q96RQ3",
+    "Q96S37",
+    "Q96S86",
+    "Q96SL4",
+    "Q96SW2",
+    "Q99250",
+    "Q99259",
+    "Q99456",
+    "Q99497",
+    "Q99500",
+    "Q99519",
+    "Q99527",
+    "Q99571",
+    "Q99572",
+    "Q99584",
+    "Q99623",
+    "Q99653",
+    "Q99677",
+    "Q99705",
+    "Q99707",
+    "Q99712",
+    "Q99714",
+    "Q99720",
+    "Q99808",
+    "Q99828",
+    "Q99829",
+    "Q99835",
+    "Q99870",
+    "Q99928",
+    "Q9BPV8",
+    "Q9BQ31",
+    "Q9BQB6",
+    "Q9BTZ2",
+    "Q9BUF5",
+    "Q9BVG9",
+    "Q9BXA1",
+    "Q9BXJ7",
+    "Q9BXT2",
+    "Q9BY41",
+    "Q9BY49",
+    "Q9BY66",
+    "Q9BYF1",
+    "Q9BYV1",
+    "Q9BYZ2",
+    "Q9BZV3",
+    "Q9C0B1",
+    "Q9GPQ4",
+    "Q9GZT4",
+    "Q9GZT9",
+    "Q9GZZ6",
+    "Q9H015",
+    "Q9H169",
+    "Q9H228",
+    "Q9H244",
+    "Q9H252",
+    "Q9H2M3",
+    "Q9H2S1",
+    "Q9H2X9",
+    "Q9H3M0",
+    "Q9H3N8",
+    "Q9H3S4",
+    "Q9H4B7",
+    "Q9H6Z9",
+    "Q9HA77",
+    "Q9HAB3",
+    "Q9HB55",
+    "Q9HBA0",
+    "Q9HBH5",
+    "Q9HBK9",
+    "Q9HC97",
+    "Q9HCC0",
+    "Q9HCR9",
+    "Q9HD40",
+    "Q9L888",
+    "Q9N587",
+    "Q9N623",
+    "Q9NP56",
+    "Q9NPA1",
+    "Q9NPA2",
+    "Q9NPC2",
+    "Q9NPD5",
+    "Q9NPH2",
+    "Q9NQX3",
+    "Q9NR19",
+    "Q9NR33",
+    "Q9NR82",
+    "Q9NR96",
+    "Q9NR97",
+    "Q9NRF9",
+    "Q9NRX3",
+    "Q9NS40",
+    "Q9NS75",
+    "Q9NS85",
+    "Q9NSA0",
+    "Q9NSA2",
+    "Q9NUB1",
+    "Q9NUV7",
+    "Q9NVH6",
+    "Q9NVS9",
+    "Q9NWM0",
+    "Q9NXB9",
+    "Q9NXE4",
+    "Q9NXG6",
+    "Q9NY46",
+    "Q9NY47",
+    "Q9NY56",
+    "Q9NY59",
+    "Q9NY72",
+    "Q9NYK1",
+    "Q9NYL2",
+    "Q9NYP7",
+    "Q9NYR8",
+    "Q9NYV7",
+    "Q9NYX4",
+    "Q9NZD4",
+    "Q9NZK7",
+    "Q9NZQ7",
+    "Q9NZV8",
+    "Q9P0J0",
+    "Q9P0X4",
+    "Q9P0Z9",
+    "Q9QNF7",
+    "Q9TY94",
+    "Q9UBC3",
+    "Q9UBK8",
+    "Q9UBL9",
+    "Q9UBM7",
+    "Q9UBN1",
+    "Q9UBN7",
+    "Q9UBS5",
+    "Q9UBV8",
+    "Q9UDR5",
+    "Q9UDX4",
+    "Q9UE69",
+    "Q9UF02",
+    "Q9UG56",
+    "Q9UGI5",
+    "Q9UGI6",
+    "Q9UGI9",
+    "Q9UGJ0",
+    "Q9UGM1",
+    "Q9UGN5",
+    "Q9UHC3",
+    "Q9UHC9",
+    "Q9UHF0",
+    "Q9UHW9",
+    "Q9UI09",
+    "Q9UI33",
+    "Q9UIX4",
+    "Q9UJ90",
+    "Q9UJ96",
+    "Q9UJT0",
+    "Q9UJT1",
+    "Q9UJU2",
+    "Q9UJX1",
+    "Q9UK17",
+    "Q9UKG9",
+    "Q9UKQ2",
+    "Q9UKV0",
+    "Q9ULB1",
+    "Q9ULD8",
+    "Q9ULU8",
+    "Q9ULX7",
+    "Q9UM07",
+    "Q9UM73",
+    "Q9UN88",
+    "Q9UNA0",
+    "Q9UNX9",
+    "Q9UP95",
+    "Q9UPY5",
+    "Q9UQ05",
+    "Q9UQD0",
+    "Q9UQF2",
+    "Q9UQL6",
+    "Q9UQQ2",
+    "Q9X1H9",
+    "Q9X6V3",
+    "Q9X6W0",
+    "Q9Y233",
+    "Q9Y234",
+    "Q9Y257",
+    "Q9Y271",
+    "Q9Y289",
+    "Q9Y2D0",
+    "Q9Y2D1",
+    "Q9Y2I1",
+    "Q9Y2Q0",
+    "Q9Y2T6",
+    "Q9Y3R4",
+    "Q9Y478",
+    "Q9Y4I5",
+    "Q9Y4R7",
+    "Q9Y4U1",
+    "Q9Y4W6",
+    "Q9Y5K3",
+    "Q9Y5N1",
+    "Q9Y5S1",
+    "Q9Y5S8",
+    "Q9Y5Y4",
+    "Q9Y5Y6",
+    "Q9Y5Y7",
+    "Q9Y5Y9",
+    "Q9Y600",
+    "Q9Y617",
+    "Q9Y666",
+    "Q9Y691",
+    "Q9Y694",
+    "Q9Y697",
+    "Q9Y698",
+    "Q9Y6F1",
+    "Q9Y6H6",
+    "Q9Y6J6",
+    "Q9Y6K1",
+    "Q9Y6L6",
+    "Q9Y6M9",
+    "Q9Y6T7",
+    "Q9Y6Y9",
+    "T1RTG8"
+  ]
+}

saved_models/training_history.csv

@@ -0,0 +1,31 @@
+AUC,accuracy,loss,val_AUC,val_accuracy,val_loss
+0.507036566734314,0.506087064743042,1.251436471939087,0.560474157333374,0.537973940372467,1.118517518043518
+0.5717569589614868,0.5529028177261353,1.094144582748413,0.7252181768417358,0.6705568432807922,1.0167717933654785
+0.6771646738052368,0.6323607563972473,0.9863069653511047,0.8049399852752686,0.7427725195884705,0.9220553636550903
+0.7607740759849548,0.6971563696861267,0.8919795155525208,0.8290924429893494,0.7576422095298767,0.840315043926239
+0.8090741634368896,0.7406398057937622,0.8109089136123657,0.8403506278991699,0.7670023441314697,0.7717797160148621
+0.8317762613296509,0.7588270306587219,0.7453528046607971,0.8435057997703552,0.7688388824462891,0.7186243534088135
+0.8440607786178589,0.7671060562133789,0.6934641003608704,0.846678614616394,0.7714455127716064,0.6751850247383118
+0.8495978713035583,0.7718898057937622,0.6534435749053955,0.84805828332901,0.7710307836532593,0.6414969563484192
+0.8531641960144043,0.7733116149902344,0.6213479042053223,0.8488333225250244,0.7728673219680786,0.6156119704246521
+0.8555516600608826,0.7748815417289734,0.5954170823097229,0.8501092791557312,0.7738744020462036,0.5926122069358826
+0.8566988110542297,0.7768661379814148,0.5746751427650452,0.8504654765129089,0.7740521430969238,0.5752732753753662
+0.8578413724899292,0.7773104310035706,0.5575758814811707,0.8504075407981873,0.7749999761581421,0.5614798665046692
+0.8588142395019531,0.7775177955627441,0.5431153774261475,0.8505890965461731,0.7734597325325012,0.5496740341186523
+0.8591389060020447,0.7778288125991821,0.5316771864891052,0.8502337336540222,0.773281991481781,0.5407591462135315
+0.8595371246337891,0.7791172862052917,0.5219547152519226,0.8508097529411316,0.773281991481781,0.5321451425552368
+0.8597018122673035,0.7780953645706177,0.5140978097915649,0.850566565990448,0.7745853066444397,0.5260604023933411
+0.8601245284080505,0.7787173986434937,0.5070772171020508,0.8509330749511719,0.7748222947120667,0.5200948119163513
+0.8601078987121582,0.7798281908035278,0.5016252994537354,0.8509336113929749,0.7737559080123901,0.5155055522918701
+0.8604037761688232,0.7799763083457947,0.4965570271015167,0.8508681654930115,0.7736374139785767,0.5119370818138123
+0.8608267307281494,0.7800799608230591,0.4920053780078888,0.850792646408081,0.7748815417289734,0.5087065696716309
+0.8607773780822754,0.7803317308425903,0.4887770414352417,0.850511372089386,0.7736374139785767,0.5064854025840759
+0.8605943918228149,0.7799763083457947,0.48619967699050903,0.8505977392196655,0.7748222947120667,0.5042062401771545
+0.8608408570289612,0.7800503373146057,0.4833099842071533,0.8505635261535645,0.7739336490631104,0.5024905800819397
+0.8606656789779663,0.7801984548568726,0.4814632534980774,0.8504072427749634,0.7748222947120667,0.5012912154197693
+0.8609856367111206,0.781013011932373,0.47936224937438965,0.8508611917495728,0.7736966609954834,0.4995896518230438
+0.8608008623123169,0.7801095843315125,0.47802749276161194,0.8506401181221008,0.7749407291412354,0.4986792206764221
+0.8611049056053162,0.7803761959075928,0.4761931002140045,0.8509538769721985,0.7743483185768127,0.4975397288799286
+0.8612802624702454,0.7809537649154663,0.47482502460479736,0.8503994941711426,0.773518979549408,0.49760735034942627
+0.8610990047454834,0.7807019948959351,0.4740986227989197,0.8510578870773315,0.7741706371307373,0.49625903367996216
+0.8611677885055542,0.7814128994941711,0.47304511070251465,0.8507607579231262,0.7731634974479675,0.49609485268592834

saved_models/xgboost.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b8dd6a73cb2aaa26429ceabddb608e9e4c0dc9cf8084d476077780370f7f33c7
+size 752881

sud_promise_uab_theme.py

@@ -0,0 +1,708 @@
+"""
+🧬 SUD-PROMISE Drug Repositioning Assessment Platform 
+UAB Color Theme: Forest Green/Blue (#1E6B52) & White
+Font: Times New Roman
+Stage System: S0 (Ideation) → S1 (Intake) → S2 (Feasibility) → S3 (In Silico) → S4 (Wet Lab) → S5 (IND-Ready) → S6 (Handoff)
+
+VERSION: 3.4.0 - Clickable Card Overlay
+- NEW: Entire card is clickable with invisible overlay button
+- CLEAN: No visible "View Details" button - card itself is the button
+- FIXED: Timeline shows ensemble baseline + all project impacts
+- FIXED: Real ML/DL scores start from ensemble, then show evidence progression
+
+UPDATED THEME:
+- Changed Gradio default primary button color ("View Candidates") to UAB GREEN
+"""
+
+import gradio as gr
+import pandas as pd
+import plotly.graph_objects as go
+from datetime import datetime, timedelta
+import random
+import json
+import numpy as np
+from pathlib import Path
+import warnings
+
+# Import custom utilities
+from func_drug import find_drug_in_database
+from func_models import initialize_ml_system, predict_with_ml_models, load_ml_models
+from module_dashboard import render_executive_dashboard
+from page_candidate import render_candidate_dashboard
+from page_category import render_landing_dashboard, render_category_view
+
+# Import UI constants and helpers
+from const_ui import (
+    # Colors
+    UAB_GREEN, UAB_DARK_GREEN, UAB_LIGHT_GREEN, UAB_ACCENT_TEAL, UAB_PALE_GREEN, UAB_WHITE,
+    # Stage configuration
+    STAGE_MAPPING, STAGE_NAMES, STAGE_COLORS,
+    # Thresholds
+    SCORE_THRESHOLD_HIGH, SCORE_THRESHOLD_MODERATE,
+    # Display limits
+    MAX_CATEGORY_CANDIDATES_DISPLAY, MAX_TOP_CANDIDATES_DISPLAY,
+    SMILES_DISPLAY_LENGTH, MAX_TARGET_DISPLAY,
+    CHART_HEIGHT_SMALL, CHART_HEIGHT_MEDIUM, CHART_HEIGHT_LARGE,
+    # Helper functions
+    get_status_badge, get_score_type_badge, get_evidence_stars, get_impact_badge
+)
+
+# Import data constants
+from const_data import (
+    # SUD Categories
+    SUD_CATEGORY_DESCRIPTIONS, SUD_CATEGORY_COLORS, DISEASE_SEARCH_CONFIG,
+    # Templates
+    DRUG_TEMPLATES, PROJECT_TEMPLATES,
+    # Metrics
+    AVERAGE_TIME_TO_IND, CURRENT_IND_READY_COUNT,
+    TIME_BINS_LABELS, TIME_BINS_COUNTS, QUARTERLY_DELIVERIES,
+)
+
+# Import config constants
+from const_config import (
+    APP_NAME, APP_VERSION, INSTITUTION,
+    DATA_DIR, MODEL_DIR, DRUGS_FILE, DISEASES_FILE,
+)
+
+# Import data generation module
+from data_generator import (
+    Project, DrugCandidate, SUDCategory,
+    setup_disease_mapping,
+    generate_synthetic_data
+)
+
+warnings.filterwarnings('ignore')
+
+uab_blue_theme = gr.themes.Soft(
+    primary_hue="blue",
+    secondary_hue="slate",
+).set(
+    # Primary buttons
+    button_primary_background_fill=UAB_GREEN,
+    button_primary_background_fill_hover=UAB_DARK_GREEN,
+    button_primary_text_color="white",
+
+    # Secondary buttons
+    button_secondary_border_color=UAB_GREEN,
+    button_secondary_text_color=UAB_GREEN,
+
+    # Inputs focus ring / highlights
+    input_border_color_focus=UAB_GREEN,
+    block_label_background_fill=UAB_GREEN,
+    block_label_text_color="white",
+    link_text_color=UAB_GREEN,
+)
+
+# ========================================
+# ML/DL MODEL LOADING
+# ========================================
+
+system = initialize_ml_system()
+
+# Extract for backwards compatibility
+MODELS_AVAILABLE = system['models_available']
+ml_components = system['ml_components']
+drugs_df = system['drugs_df']
+diseases_df = system['diseases_df']
+
+# ========================================
+# DISEASE ID MAPPING
+# ========================================
+
+DISEASE_ID_MAPPING = setup_disease_mapping(diseases_df)
+
+# ========================================
+# GENERATE DATA
+# ========================================
+
+SUD_CATEGORIES, CANDIDATES = generate_synthetic_data(
+    DISEASE_ID_MAPPING, 
+    MODELS_AVAILABLE, 
+    ml_components, 
+    drugs_df
+)
+
+# ========================================
+# HELPER FUNCTIONS
+# ========================================
+
+def format_date_ago(date):
+    delta = datetime.now() - date
+    if delta.days == 0:
+        return "Today"
+    elif delta.days == 1:
+        return "Yesterday"
+    elif delta.days < 7:
+        return f"{delta.days} days ago"
+    elif delta.days < 30:
+        return f"{delta.days // 7} weeks ago"
+    else:
+        return f"{delta.days // 30} months ago"
+
+def render_candidate_card(candidate, rank, border_color=None):
+    stars = get_evidence_stars(candidate.evidence_score)
+    status_badge = get_status_badge(candidate.stage)
+    score_type_badge = get_score_type_badge(candidate.score_type)
+    border = UAB_GREEN
+    market_analysis_num = 1 if hasattr(candidate, 'has_market_analysis') and candidate.has_market_analysis else 0
+
+    html = f"""
+    <div style="background: white; border: 2px solid {border}; padding: 15px 20px; margin: 10px 20px;
+                border-radius: 12px; box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+                font-family: 'Times New Roman', Times, serif; cursor: pointer; transition: all 0.3s ease;">
+        <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 12px;">
+            <div style="display: flex; align-items: center; gap: 12px;">
+                <span style="background: #EDF2F7; padding: 4px 10px; border-radius: 20px;
+                             font-size: 14px; color: {UAB_DARK_GREEN}; font-weight: bold;">
+                    {rank}
+                </span>
+                <span style="font-size: 24px; font-weight: bold; color: {UAB_DARK_GREEN};">
+                    {candidate.drug_name}
+                </span>
+                <span style="font-size: 16px; color: {UAB_GREEN}; font-weight: bold;">
+                    {stars} {candidate.evidence_score:.2f}
+                </span>
+                {score_type_badge}
+            </div>
+            {status_badge}
+        </div>
+
+        <p style="margin: 8px 0; color: #4A5568;"><b>Current Use:</b> {candidate.current_indication}</p>
+        <p style="margin: 8px 0; color: #4A5568;"><b>Mechanism:</b> {candidate.mechanism}</p>
+
+        <div style="display: grid; grid-template-columns: repeat(3, 1fr); gap: 12px; margin: 12px 0;">
+            <div style="text-align: center; padding: 10px; background: {UAB_GREEN}; border-radius: 8px;">
+                <div style="font-weight: bold; color: white; font-size: 20px;">{len(candidate.attached_projects)}</div>
+                <div style="font-size: 12px; color: white;">Projects</div>
+            </div>
+            <div style="text-align: center; padding: 10px; background: {UAB_GREEN}; border-radius: 8px;">
+                <div style="font-weight: bold; color: white; font-size: 20px;">{candidate.cohort_count}</div>
+                <div style="font-size: 12px; color: white;">Cohorts</div>
+            </div>
+            <div style="text-align: center; padding: 10px; background: {UAB_GREEN}; border-radius: 8px;">
+                <div style="font-weight: bold; color: white; font-size: 20px;">{market_analysis_num}</div>
+                <div style="font-size: 12px; color: white;">Market Analysis</div>
+            </div>
+        </div>
+
+        <div style="background: {UAB_PALE_GREEN}; padding: 12px; border-radius: 8px; margin: 12px 0;
+                    border-left: 3px solid {UAB_GREEN};">
+            <p style="margin: 5px 0; color: #4A5568; font-size: 13px;">
+                <b>Team Members:</b> {candidate.team_members} |
+                <b>Data Produced:</b> {candidate.data_produced} |
+                <b>Publications:</b> {candidate.publications}
+            </p>
+            <p style="margin: 5px 0; color: #4A5568; font-size: 13px;">
+                <b>Tools Used:</b> {candidate.tools_used} |
+                <b>Data Governance:</b> {candidate.data_governance} |
+                <b>Training:</b> {candidate.training_participated}
+            </p>
+        </div>
+
+        <p style="margin: 8px 0 0 0; font-size: 13px; color: #A0AEC0;">
+            Last updated: {format_date_ago(candidate.last_updated)}
+        </p>
+    </div>
+    """
+    return html
+
+# ========================================
+# GRADIO INTERFACE
+# ========================================
+
+def create_interface():
+    CSS = f"""
+    * {{
+        font-family: 'Times New Roman', Times, serif !important;
+    }}
+
+    .gr-button {{
+        font-family: 'Times New Roman', Times, serif !important;
+    }}
+
+    /* Dropdown highlight: UAB GREEN */
+    .choices__item--selectable.is-highlighted {{
+        background-color: rgba(30, 58, 138, 0.15) !important;
+        color: {UAB_DARK_GREEN} !important;
+    }}
+
+    /* Force Gradio primary button color to UAB GREEN (HF Spaces safe) */
+    .gr-button-primary,
+    .gr-button-primary button {{
+        background: {UAB_GREEN} !important;
+        border-color: {UAB_GREEN} !important;
+        color: white !important;
+        font-weight: bold !important;
+    }}
+
+    .gr-button-primary:hover,
+    .gr-button-primary button:hover {{
+        background: {UAB_DARK_GREEN} !important;
+        border-color: {UAB_DARK_GREEN} !important;
+    }}
+
+    /* Card container with relative positioning */
+    .card-wrap {{
+        position: relative;
+        width: 100%;
+        margin: 10px 0;
+    }}
+
+    /* Invisible overlay button covering entire card */
+    .overlay-btn {{
+        position: absolute !important;
+        inset: 0 !important;
+        z-index: 10 !important;
+        opacity: 0 !important;
+        cursor: pointer !important;
+    }}
+
+    .overlay-btn button {{
+        width: 100% !important;
+        height: 100% !important;
+        border-radius: 12px !important;
+    }}
+
+    /* Hover effect on card when hovering over invisible button */
+    .card-wrap:hover > div:first-child > div {{
+        box-shadow: 0 4px 12px rgba(30, 58, 138, 0.22) !important;
+        transform: translateY(-2px);
+    }}
+    """
+
+    with gr.Blocks(
+        title="SUD-PROMISE | UAB",
+        css=CSS,
+        theme=uab_blue_theme,  #  APPLY THEME HERE
+    ) as demo:
+
+        current_view = gr.State("dashboard")
+        selected_category = gr.State(None)
+        selected_candidate = gr.State(None)
+
+        with gr.Column():
+            gr.HTML(f"""
+            <div style="text-align: center; padding: 40px 20px;
+                        background: linear-gradient(135deg, {UAB_GREEN} 0%, {UAB_DARK_GREEN} 100%);
+                        border-radius: 15px; margin-bottom: 20px;
+                        box-shadow: 0 4px 6px rgba(30,107,82,0.3);">
+                <div style="font-size: 60px; margin-bottom: 20px;">🧬</div>
+                <h1 style="color: white; margin: 0; font-size: 42px; font-weight: bold;">
+                    {APP_NAME}
+                </h1>
+                <p style="color: white; opacity: 0.95; margin: 15px 0 0 0; font-size: 18px;">
+                    {INSTITUTION} - Evidence-Based Drug Discovery for Substance Use Disorders
+                </p>
+                <p style="color: white; opacity: 0.85; margin: 10px 0 0 0; font-size: 14px;">
+                    🤖 v8: Clickable Card Overlay + UAB Green Primary Buttons
+                </p>
+            </div>
+            """)
+
+            breadcrumb = gr.Markdown("")
+
+            with gr.Column() as main_content:
+
+                # DASHBOARD VIEW
+                with gr.Column(visible=True) as dashboard_view:
+                    exec_html = gr.HTML()
+
+                    gr.Markdown("---")
+
+                    with gr.Row():
+                        with gr.Column():
+                            gr.Markdown("### Average Time to IND-Ready")
+                            with gr.Row():
+                                with gr.Column(scale=1):
+                                    avg_time_display = gr.Markdown("")
+                                with gr.Column(scale=2):
+                                    time_dist_plot = gr.Plot()
+
+                        with gr.Column():
+                            gr.Markdown("### Quarterly Deliveries")
+                            with gr.Row():
+                                with gr.Column(scale=1):
+                                    quarterly_display = gr.Markdown("")
+                                with gr.Column(scale=2):
+                                    quarterly_plot = gr.Plot()               
+
+                    with gr.Row():
+                        with gr.Column():
+                            gr.Markdown("### Pipeline Progression - Stage Distribution Over Time")
+                            pipeline_plot = gr.Plot()
+
+                        with gr.Column():
+                            gr.Markdown("### Active Portfolio Breakdown")
+                            portfolio_plot = gr.Plot()
+
+                    gr.Markdown("---")
+
+                    dashboard_html = gr.HTML()
+                    gr.Markdown("### Top Candidates by Evidence Score")
+                    gr.Markdown("*Click on any card to view detailed information*")
+
+                    top_candidate_components = []
+                    for i in range(MAX_TOP_CANDIDATES_DISPLAY):
+                        with gr.Column(elem_classes=["card-wrap"]):
+                            top_html = gr.HTML()
+                            top_btn = gr.Button("View Details", elem_classes=["overlay-btn"])
+                            top_candidate_components.append((top_html, top_btn))
+
+                    gr.Markdown("---")
+                    gr.Markdown("### Select a SUD Category to Explore")
+
+                    category_selector = gr.Dropdown(
+                        choices=[],
+                        label="",
+                        show_label=False,
+                        interactive=True
+                    )
+
+                    #  This is the button in your screenshot: now it becomes UAB GREEN
+                    view_category_btn = gr.Button("View Candidates", variant="primary", size="lg")
+
+                # CATEGORY VIEW
+                with gr.Column(visible=False) as category_view:
+                    category_html = gr.HTML()
+
+                    gr.Markdown("**Sort by**")
+                    with gr.Row():
+                        sort_dropdown = gr.Dropdown(
+                            choices=["Evidence Score", "Recent", "Name", "Stage"],
+                            value="Evidence Score",
+                            label="",
+                            show_label=False,
+                            interactive=True
+                        )
+
+                    candidate_selector = gr.Dropdown(
+                        choices=[],
+                        label="",
+                        show_label=False,
+                        interactive=True,
+                        visible=False
+                    )
+
+                    gr.Markdown("*Click on any card to view detailed information*")
+
+                    category_candidate_components = []
+                    category_candidate_buttons = []
+                    for i in range(MAX_CATEGORY_CANDIDATES_DISPLAY):
+                        with gr.Column(visible=False, elem_classes=["card-wrap"]) as cat_card_col:
+                            cat_html = gr.HTML()
+                            cat_btn = gr.Button("View Details", elem_classes=["overlay-btn"])
+                            category_candidate_components.append((cat_card_col, cat_html))
+                            category_candidate_buttons.append(cat_btn)
+
+                    with gr.Row():
+                        back_to_dashboard_btn = gr.Button("← Back to Dashboard", variant="secondary")
+
+                # CANDIDATE DETAIL VIEW
+                with gr.Column(visible=False) as candidate_view:
+                    candidate_html_before = gr.HTML()
+
+                    with gr.Row():
+                        with gr.Column():
+                            gr.Markdown("### Evidence Score Gauge")
+                            gauge_plot = gr.Plot()
+                        with gr.Column():
+                            gr.Markdown("### Model Score Comparison")
+                            model_comparison_plot = gr.Plot()
+
+                    gr.Markdown("### Evidence Score Evolution Timeline")
+                    timeline_plot = gr.Plot()
+                    gr.Markdown("---")
+                    candidate_html_after = gr.HTML()
+                    back_to_category_btn = gr.Button("← Back to Category", variant="secondary", size="lg")
+
+        # ==========================================================
+        # EVENT HANDLERS
+        # ==========================================================
+
+        def show_dashboard():
+            exec_html_content, time_fig, quart_fig, pipe_fig, port_fig, avg_time, ind_ready = render_executive_dashboard(
+                candidates=CANDIDATES,
+                categories=SUD_CATEGORIES,
+                models_available=MODELS_AVAILABLE
+            )
+
+            avg_time_md = f"""
+            <div style="text-align: center; padding: 15px; background: white;
+                        border: 2px solid {UAB_GREEN}; border-radius: 10px;">
+                <div style="font-size: 36px; font-weight: bold; color: {UAB_GREEN};">{avg_time:.1f}</div>
+                <div style="font-size: 14px; color: {UAB_DARK_GREEN};">months</div>
+            </div>
+            """
+
+            quarterly_md = f"""
+            <div style="text-align: center; padding: 15px; background: white;
+                        border: 2px solid {UAB_GREEN}; border-radius: 10px;">
+                <div style="font-size: 36px; font-weight: bold; color: {UAB_GREEN};">{ind_ready}</div>
+                <div style="font-size: 14px; color: {UAB_DARK_GREEN};">IND-Ready</div>
+            </div>
+            """
+
+            dash_html, categories, top_5 = render_landing_dashboard()
+
+            top_outputs = [
+                exec_html_content,
+                avg_time_md,
+                time_fig,
+                quarterly_md,
+                quart_fig,
+                pipe_fig,
+                port_fig,
+                dash_html,
+                gr.update(choices=categories, value=None)
+            ]
+
+            for i, (html_component, btn_component) in enumerate(top_candidate_components):
+                if i < len(top_5):
+                    candidate = top_5[i]
+                    card_html = render_candidate_card(candidate, f"#{i+1}")
+                    top_outputs.append(card_html)
+                else:
+                    top_outputs.append("")
+
+            for col, html in category_candidate_components:
+                top_outputs.extend([gr.update(visible=False), ""])
+
+            top_outputs.extend([
+                gr.update(visible=True),
+                gr.update(visible=False),
+                gr.update(visible=False),
+                "dashboard",
+                "📊 Dashboard"
+            ])
+
+            return top_outputs
+
+        def show_category(category_selection):
+            if not category_selection:
+                return [gr.update()] * (2 + len(category_candidate_components) * 2 + 6)
+
+            cat_html, candidates, filtered = render_category_view(category_selection)
+            category_name = category_selection.split(" (")[0]
+
+            outputs = [
+                cat_html,
+                gr.update(choices=candidates, value=None),
+            ]
+
+            for i, (col, html) in enumerate(category_candidate_components):
+                if i < len(filtered):
+                    candidate = filtered[i]
+                    card_html = render_candidate_card(candidate, f"#{i+1}")
+                    outputs.extend([gr.update(visible=True), card_html])
+                else:
+                    outputs.extend([gr.update(visible=False), ""])
+
+            outputs.extend([
+                gr.update(visible=False),
+                gr.update(visible=True),
+                gr.update(visible=False),
+                category_selection,
+                "category",
+                f"📊 Dashboard > {category_name}",
+            ])
+            return outputs
+
+        def show_candidate(candidate_selection, category_selection):
+            if not candidate_selection:
+                return [gr.update()] * 10
+
+            html_before, gauge_fig, model_fig, timeline_fig, html_after = render_candidate_dashboard(
+                candidate_selection, category_selection
+            )
+            candidate_name = candidate_selection.split(" (Score:")[0]
+            category_name = category_selection.split(" (")[0] if category_selection else "Category"
+
+            return (
+                f"📊 Dashboard > {category_name} > {candidate_name}",
+                html_before,
+                gauge_fig,
+                model_fig,
+                timeline_fig,
+                html_after,
+                gr.update(visible=False),
+                gr.update(visible=False),
+                gr.update(visible=True),
+                category_selection,
+            )
+
+        def update_category_sort(category_selection, sort_by):
+            if not category_selection:
+                return [gr.update()] * (2 + len(category_candidate_components) * 2)
+
+            cat_html, candidates, filtered = render_category_view(category_selection, sort_by)
+            outputs = [cat_html, gr.update(choices=candidates)]
+
+            for i, (col, html) in enumerate(category_candidate_components):
+                if i < len(filtered):
+                    candidate = filtered[i]
+                    card_html = render_candidate_card(candidate, f"#{i+1}")
+                    outputs.extend([gr.update(visible=True), card_html])
+                else:
+                    outputs.extend([gr.update(visible=False), ""])
+
+            return outputs
+
+        def make_view_candidate_handler(candidate_index, is_top=False):
+            def handler():
+                if is_top:
+                    top_5 = sorted(CANDIDATES, key=lambda c: c.evidence_score, reverse=True)[:MAX_TOP_CANDIDATES_DISPLAY]
+                    if candidate_index >= len(top_5):
+                        return [gr.update()] * 10
+                    candidate = top_5[candidate_index]
+                else:
+                    return [gr.update()] * 10
+
+                category_str = f"{candidate.target_sud_subtype} ({sum(1 for c in CANDIDATES if c.target_sud_subtype == candidate.target_sud_subtype)} candidates)"
+                candidate_str = f"{candidate.drug_name} (Score: {candidate.evidence_score:.2f})"
+
+                html_before, gauge_fig, model_fig, timeline_fig, html_after = render_candidate_dashboard(candidate_str, category_str)
+                return (
+                    f"📊 Dashboard > {candidate.target_sud_subtype} > {candidate.drug_name}",
+                    html_before,
+                    gauge_fig,
+                    model_fig,
+                    timeline_fig,
+                    html_after,
+                    gr.update(visible=False),
+                    gr.update(visible=False),
+                    gr.update(visible=True),
+                    category_str,
+                )
+            return handler
+
+        def make_category_candidate_handler(candidate_index):
+            def handler(category_selection):
+                if not category_selection:
+                    return [gr.update()] * 10
+
+                category_name = category_selection.split(" (")[0].strip()
+                filtered = [c for c in CANDIDATES if c.target_sud_subtype == category_name]
+                filtered.sort(key=lambda c: c.evidence_score, reverse=True)
+
+                if candidate_index >= len(filtered):
+                    return [gr.update()] * 10
+
+                candidate = filtered[candidate_index]
+                candidate_str = f"{candidate.drug_name} (Score: {candidate.evidence_score:.2f})"
+
+                html_before, gauge_fig, model_fig, timeline_fig, html_after = render_candidate_dashboard(candidate_str, category_selection)
+                return (
+                    f"📊 Dashboard > {category_name} > {candidate.drug_name}",
+                    html_before,
+                    gauge_fig,
+                    model_fig,
+                    timeline_fig,
+                    html_after,
+                    gr.update(visible=False),
+                    gr.update(visible=False),
+                    gr.update(visible=True),
+                    category_selection,
+                )
+            return handler
+
+        # ==========================================================
+        # CONNECT EVENTS
+        # ==========================================================
+
+        demo.load(
+            fn=show_dashboard,
+            outputs=[
+                exec_html, avg_time_display, time_dist_plot, quarterly_display, quarterly_plot, pipeline_plot, portfolio_plot,
+                dashboard_html, category_selector
+            ] +
+            [comp for pair in top_candidate_components for comp in [pair[0]]] +
+            [comp for pair in category_candidate_components for comp in [pair[0], pair[1]]] +
+            [dashboard_view, category_view, candidate_view, current_view, breadcrumb]
+        )
+
+        view_category_btn.click(
+            fn=show_category,
+            inputs=[category_selector],
+            outputs=[category_html, candidate_selector] +
+                    [comp for pair in category_candidate_components for comp in [pair[0], pair[1]]] +
+                    [dashboard_view, category_view, candidate_view, selected_category, current_view, breadcrumb]
+        )
+
+        sort_dropdown.change(
+            fn=update_category_sort,
+            inputs=[selected_category, sort_dropdown],
+            outputs=[category_html, candidate_selector] +
+                    [comp for pair in category_candidate_components for comp in [pair[0], pair[1]]]
+        )
+
+        for i, (html, btn) in enumerate(top_candidate_components):
+            btn.click(
+                fn=make_view_candidate_handler(i, is_top=True),
+                outputs=[
+                    breadcrumb, candidate_html_before, gauge_plot, model_comparison_plot, timeline_plot, candidate_html_after,
+                    dashboard_view, category_view, candidate_view, selected_category
+                ]
+            )
+
+        for i, btn in enumerate(category_candidate_buttons):
+            btn.click(
+                fn=make_category_candidate_handler(i),
+                inputs=[selected_category],
+                outputs=[
+                    breadcrumb, candidate_html_before, gauge_plot, model_comparison_plot, timeline_plot, candidate_html_after,
+                    dashboard_view, category_view, candidate_view, selected_category
+                ]
+            )
+
+        candidate_selector.change(
+            fn=show_candidate,
+            inputs=[candidate_selector, selected_category],
+            outputs=[
+                breadcrumb, candidate_html_before, gauge_plot, model_comparison_plot, timeline_plot, candidate_html_after,
+                dashboard_view, category_view, candidate_view, selected_category
+            ]
+        )
+
+        back_to_dashboard_btn.click(
+            fn=show_dashboard,
+            outputs=[
+                exec_html, avg_time_display, time_dist_plot, quarterly_display, quarterly_plot, pipeline_plot, portfolio_plot,
+                dashboard_html, category_selector
+            ] +
+            [comp for pair in top_candidate_components for comp in [pair[0]]] +
+            [comp for pair in category_candidate_components for comp in [pair[0], pair[1]]] +
+            [dashboard_view, category_view, candidate_view, current_view, breadcrumb]
+        )
+
+        back_to_category_btn.click(
+            fn=show_category,
+            inputs=[selected_category],
+            outputs=[category_html, candidate_selector] +
+                    [comp for pair in category_candidate_components for comp in [pair[0], pair[1]]] +
+                    [dashboard_view, category_view, candidate_view, selected_category, current_view, breadcrumb]
+        )
+
+    return demo
+
+# ========================================
+# MAIN
+# ========================================
+
+if __name__ == "__main__":
+    print("\n" + "="*60)
+    print(f"🧬 {APP_NAME}")
+    print(f"Version: 3.4.0 - Clickable Card Overlay + UAB Green Primary Buttons")
+    print("="*60)
+    print(f"ML/DL Models Status: {' LOADED' if MODELS_AVAILABLE else '  NOT AVAILABLE'}")
+    if MODELS_AVAILABLE:
+        print(f"Available Diseases: {len(ml_components['le_disease'].classes_)}")
+        print(f"Available Targets: {len(ml_components['mlb'].classes_)}")
+    if drugs_df is not None:
+        print(f"Drugs Database:  {len(drugs_df)} drugs loaded")
+    if diseases_df is not None:
+        print(f"Diseases Database:  {len(diseases_df)} diseases loaded")
+    print(f"Disease ID Mappings: {len(DISEASE_ID_MAPPING)} SUD categories mapped")
+    print("="*60 + "\n")
+
+    demo = create_interface()
+    demo.launch()