app.py

# -*- coding: utf-8 -*-
"""
Drug Discovery Predictor - Deployment Ready for Hugging Face Spaces
"""

import os
import gradio as gr
import joblib
import pandas as pd
import numpy as np
import tensorflow as tf
from tensorflow import keras
import torch
import torch.nn as nn
from PIL import Image, ImageDraw, ImageFont
import requests
from io import BytesIO
from functools import partial
import urllib.parse

# --- Global Setup ---
# Caching Setup for downloaded images
CACHE_DIR = "image_cache"
os.makedirs(CACHE_DIR, exist_ok=True)
print(f"Image cache directory created at: {CACHE_DIR}")

# --- 1. Define the PyTorch Model Class ---
# This class definition is required to load the saved PyTorch model state.
class MLPAgent(nn.Module):
    def __init__(self, input_dim, num_classes):
        super(MLPAgent, self).__init__()
        self.net = nn.Sequential(
            nn.Linear(input_dim, 128), nn.ReLU(), nn.Dropout(0.3),
            nn.Linear(128, 64), nn.ReLU(), nn.Dropout(0.2),
            nn.Linear(64, num_classes), nn.Softmax(dim=1)
        )
    def forward(self, x):
        return self.net(x)

# --- 2. Load all models and preprocessors ---
# This section runs once when the application starts.
try:
    rf_model = joblib.load("models/rf_model.joblib")
    scaler = joblib.load("models/scaler.joblib")
    le = joblib.load("models/le.joblib")
    keras_model = keras.models.load_model("models/keras_mlp.h5")
    num_classes = len(le.classes_)
    rl_agent = MLPAgent(input_dim=5, num_classes=num_classes)
    rl_agent.load_state_dict(torch.load("models/rl_upgraded_agent.pth"))
    rl_agent.eval()
    print("All models and preprocessors loaded successfully.")
    MODELS_LOADED = True
except Exception as e:
    print(f"Error loading models: {e}")
    MODELS_LOADED = False

# Mapping from protein targets to known chemical compounds for image search
PROTEIN_TO_COMPOUND_MAP = {
    "BACE1": "Verubecestat", "HDAC1": "Vorinostat", "EGFR": "Gefitinib",
    "DRD2": "Haloperidol", "HIV-1 RT": "Nevirapine", "AMPC": "Cefoxitin",
    "MMP-13": "Marimastat"
}

# --- 3. Image Pre-Fetching Logic ---
# To ensure fast performance, we download all images when the app starts.
def pre_fetch_images():
    print("\n--- Starting Image Pre-Fetching ---")
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
    }
    for compound_name in set(PROTEIN_TO_COMPOUND_MAP.values()):
        sanitized_name = "".join(c for c in compound_name if c.isalnum())
        local_image_path = os.path.join(CACHE_DIR, f"{sanitized_name}.png")
        
        if not os.path.exists(local_image_path):
            try:
                print(f"Downloading image for '{compound_name}'...")
                url_safe_name = urllib.parse.quote(compound_name)
                image_url = f"https://cactus.nci.nih.gov/chemical/structure/{url_safe_name}/image"
                
                response = requests.get(image_url, timeout=20, headers=headers)
                
                if response.status_code == 200 and 'image' in response.headers.get('Content-Type', ''):
                    image = Image.open(BytesIO(response.content))
                    image.save(local_image_path)
                    print(f"  ✅ Success: Saved '{compound_name}' to cache.")
                else:
                    print(f"  ❌ Failed for '{compound_name}': Server returned non-image content.")
            except Exception as e:
                print(f"  ❌ Failed for '{compound_name}': {e}")
        else:
            print(f"Image for '{compound_name}' already in cache. Skipping.")
    print("--- Image Pre-Fetching Complete ---\n")

# Run the pre-fetching function immediately
if MODELS_LOADED:
    pre_fetch_images()

# --- 4. Helper and Prediction Functions ---
def create_error_image(message):
    img = Image.new('RGB', (400, 300), color=(255, 255, 255))
    d = ImageDraw.Draw(img)
    try: # Use a common font
        font = ImageFont.truetype("DejaVuSans.ttf", 15)
    except IOError:
        font = ImageFont.load_default()
    d.text((10,10), message, fill=(200,0,0), font=font)
    return img

def get_compound_structure_image_from_cache(compound_name):
    sanitized_name = "".join(c for c in compound_name if c.isalnum())
    local_image_path = os.path.join(CACHE_DIR, f"{sanitized_name}.png")

    if os.path.exists(local_image_path):
        return Image.open(local_image_path)
    else:
        return create_error_image(f"Image for '{compound_name}'\nwas not found in local cache.")

def master_predict(model_choice, mol_weight, logp, hba, hbd, tpsa, rf_m, sc, l_enc, keras_m, rl_a):
    features = ['Molecular Weight', 'LogP', 'HBA', 'HBD', 'TPSA']
    input_df = pd.DataFrame([{'Molecular Weight': mol_weight, 'LogP': logp, 'HBA': hba, 'HBD': hbd, 'TPSA': tpsa}], columns=features)
    s_scaled = sc.transform(input_df)
    
    pred_rf_idx = rf_m.predict(s_scaled)[0]
    pred_rf_class = l_enc.inverse_transform([pred_rf_idx])[0]
    
    if model_choice == "Normal MLP":
        pred_prob = keras_m.predict(s_scaled, verbose=0)[0]
    else:
        with torch.no_grad():
            s_torch = torch.tensor(s_scaled, dtype=torch.float32)
            pred_prob = rl_a(s_torch).numpy()[0]
            
    top3_idx = np.argsort(pred_prob)[-3:][::-1]
    top3_predictions_data = []
    for i in top3_idx:
        protein_name = l_enc.inverse_transform([i])[0]
        probability = float(pred_prob[i])
        prob_percent = f"{probability:.2%}"
        top3_predictions_data.append([protein_name, probability, prob_percent])
        
    mlp_results_df = pd.DataFrame(top3_predictions_data, columns=["Protein", "Probability", "Probability %"])
    
    top_protein_name = mlp_results_df.iloc[0]["Protein"]
    compound_to_search = PROTEIN_TO_COMPOUND_MAP.get(top_protein_name, top_protein_name)
    structure_image = get_compound_structure_image_from_cache(compound_to_search)

    return pred_rf_class, mlp_results_df, structure_image

# --- 5. Build the Gradio Interface ---
with gr.Blocks(theme=gr.themes.Soft()) as iface:
    gr.Markdown("# Drug Discovery: Protein Target Predictor")
    if not MODELS_LOADED:
        gr.Markdown("## ERROR: MODELS FAILED TO LOAD. PLEASE CHECK THE REPOSITORY AND LOGS.")
    else:
        predict_with_models = partial(master_predict, rf_m=rf_model, sc=scaler, l_enc=le, keras_m=keras_model, rl_a=rl_agent)
        with gr.Row():
            with gr.Column(scale=1):
                gr.Markdown("### 1. Choose Your Model")
                model_choice = gr.Radio(["Normal MLP", "RL Upgraded MLP"], label="Select an MLP Model", value="Normal MLP")
                gr.Markdown("### 2. Input Molecular Properties")
                mw_slider = gr.Slider(100, 1000, value=350, step=1, label="Molecular Weight (g/mol)")
                logp_slider = gr.Slider(-5, 10, value=2.5, step=0.1, label="LogP (Lipophilicity)")
                hba_slider = gr.Slider(0, 20, value=4, step=1, label="HBA (Hydrogen Bond Acceptors)")
                hbd_slider = gr.Slider(0, 20, value=2, step=1, label="HBD (Hydrogen Bond Donors)")
                tpsa_slider = gr.Slider(0, 300, value=60, step=1, label="TPSA (Topological Polar Surface Area Ų)")
                submit_btn = gr.Button("Predict Target Protein", variant="primary")
            with gr.Column(scale=2):
                gr.Markdown("### 3. Prediction Results")
                out_rf = gr.Textbox(label="Random Forest Prediction (Most Likely Target)")
                out_mlp = gr.DataFrame(headers=["Protein", "Probability", "Probability %"], label="Top 3 MLP Predictions", datatype=["str", "number", "str"])
                out_image = gr.Image(label="2D Structure of an Associated Compound", type="pil")
                
        submit_btn.click(
            fn=predict_with_models,
            inputs=[model_choice, mw_slider, logp_slider, hba_slider, hbd_slider, tpsa_slider],
            outputs=[out_rf, out_mlp, out_image]
        )

# Launch the application
iface.launch()