Update app.py

app.py

@@ -1,356 +1,551 @@
-
-
-# -----------------------------
-# IMPORTS & CONFIGURATION
-# -----------------------------
 import streamlit as st
 import requests
-from rdkit import Chem
-from rdkit.Chem import Draw
 import pandas as pd
 import matplotlib.pyplot as plt
 import seaborn as sns
+from rdkit import Chem
+from rdkit.Chem import Draw
 from fpdf import FPDF
 import tempfile
 import logging
 import os
 import plotly.graph_objects as go
 import networkx as nx
-from typing import Optional, Dict, List, Any, Tuple
-from openai import OpenAI
+from typing import Optional, Dict, List, Any
+from datetime import datetime
 
-# Configure professional logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[logging.FileHandler("pris_debug.log")]
-)
-logger = logging.getLogger("PRIS")
-
-# -----------------------------
-# GLOBAL CONSTANTS
-# -----------------------------
+# -------------------------------
+# STREAMLIT CONFIGURATION & LOGGING
+# -------------------------------
+st.set_page_config(page_title="Pharma Research Expert Platform", layout="wide")
+logging.basicConfig(level=logging.ERROR)
+
+# -------------------------------
+# API ENDPOINTS (Stable Sources Only)
+# -------------------------------
 API_ENDPOINTS = {
-    # Clinical Data Services
     "clinical_trials": "https://clinicaltrials.gov/api/v2/studies",
-    "fda_drug_approval": "https://api.fda.gov/drug/label.json",
-    "faers_adverse_events": "https://api.fda.gov/drug/event.json",
-    
-    # Chemical & Biological Data
     "pubchem": "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{}/JSON",
     "pubmed": "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi",
-    
-    # Pharmacogenomics Resources
-    "pharmgkb_variant_clinical_annotations": "https://api.pharmgkb.org/v1/data/variant/{}/clinicalAnnotations",
-    "pharmgkb_gene": "https://api.pharmgkb.org/v1/data/gene/{}",
+    "fda_drug_approval": "https://api.fda.gov/drug/label.json",
+    "faers_adverse_events": "https://api.fda.gov/drug/event.json",
+    # PharmGKB endpoints for gene variants (if available)
     "pharmgkb_gene_variants": "https://api.pharmgkb.org/v1/data/gene/{}/variants",
-    
-    # Semantic Medical Resources
+    # BioPortal for ontology searches
     "bioportal_search": "https://data.bioontology.org/search",
-    
-    # Drug Classification Systems
+    # RxNorm & RxClass endpoints
     "rxnorm_rxcui": "https://rxnav.nlm.nih.gov/REST/rxcui.json",
     "rxnorm_properties": "https://rxnav.nlm.nih.gov/REST/rxcui/{}/properties.json",
     "rxclass_by_drug": "https://rxnav.nlm.nih.gov/REST/class/byDrugName.json"
 }
 
-DEFAULT_HEADERS = {
-    "User-Agent": "PharmaResearchIntelligenceSuite/1.0 (Professional Use)",
-    "Accept": "application/json"
+# -------------------------------
+# TRADE-TO-GENERIC MAPPING (FALLBACK)
+# -------------------------------
+TRADE_TO_GENERIC = {
+    "tylenol": "acetaminophen",
+    "advil": "ibuprofen",
+    # Extend with additional mappings as desired
 }
 
-# -----------------------------
-# SECRETS MANAGEMENT
-# -----------------------------
-class APIConfigurationError(Exception):
-    """Custom exception for missing API configurations"""
-    pass
-
-try:
-    OPENAI_API_KEY = st.secrets["OPENAI_API_KEY"]
-    BIOPORTAL_API_KEY = st.secrets["BIOPORTAL_API_KEY"]
-    PUB_EMAIL = st.secrets["PUB_EMAIL"]
-    OPENFDA_KEY = st.secrets["OPENFDA_KEY"]
-    
-    # Validate essential configurations
-    if not all([OPENAI_API_KEY, BIOPORTAL_API_KEY, PUB_EMAIL, OPENFDA_KEY]):
-        raise APIConfigurationError("Missing one or more required API credentials")
-        
-except (KeyError, APIConfigurationError) as e:
-    st.error(f"Critical configuration error: {str(e)}")
-    st.stop()
-
-# -----------------------------
-# CORE INFRASTRUCTURE
-# -----------------------------
-class PharmaResearchEngine:
-    """Core engine for pharmaceutical data integration and analysis"""
-    
-    def __init__(self):
-        self.openai_client = OpenAI(api_key=OPENAI_API_KEY)
-        
-    @staticmethod
-    def api_request(endpoint: str, 
-                    params: Optional[Dict] = None,
-                    headers: Optional[Dict] = None) -> Optional[Dict]:
-        """Enterprise-grade API request handler with advanced resilience"""
-        try:
-            response = requests.get(
-                endpoint,
-                params=params,
-                headers={**DEFAULT_HEADERS, **(headers or {})},
-                timeout=(3.05, 15)
-            )
-            response.raise_for_status()
-            return response.json()
-        except requests.exceptions.HTTPError as e:
-            logger.error(f"HTTP Error {e.response.status_code} for {endpoint}")
-            st.error(f"API Error: {e.response.status_code} - {e.response.reason}")
-        except Exception as e:
-            logger.error(f"Network error for {endpoint}: {str(e)}")
-            st.error(f"Network error: {str(e)}")
-        return None
+# -------------------------------
+# SECRETS RETRIEVAL
+# -------------------------------
+OPENAI_API_KEY = st.secrets.get("OPENAI_API_KEY")
+BIOPORTAL_API_KEY = st.secrets.get("BIOPORTAL_API_KEY")
+PUB_EMAIL = st.secrets.get("PUB_EMAIL")
+OPENFDA_KEY = st.secrets.get("OPENFDA_KEY")
+
+if not PUB_EMAIL:
+    st.error("PUB_EMAIL is not configured in secrets.")
+if not BIOPORTAL_API_KEY:
+    st.error("BIOPORTAL_API_KEY is not configured in secrets.")
+if not OPENFDA_KEY:
+    st.error("OPENFDA_KEY is not configured in secrets.")
+if not OPENAI_API_KEY:
+    st.error("OPENAI_API_KEY is not configured in secrets.")
 
-    def get_compound_profile(self, identifier: str) -> Optional[Dict]:
-        """Retrieve comprehensive chemical profile"""
-        pubchem_data = self.api_request(
-            API_ENDPOINTS["pubchem"].format(identifier)
+# -------------------------------
+# INITIALIZE OPENAI (GPT-4) CLIENT
+# -------------------------------
+from openai import OpenAI
+openai_client = OpenAI(api_key=OPENAI_API_KEY)
+
+def generate_ai_content(prompt: str) -> str:
+    """Call GPT-4 to generate innovative insights."""
+    try:
+        response = openai_client.chat.completions.create(
+            model="gpt-4",
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=300
         )
-        
-        if not pubchem_data or not pubchem_data.get("PC_Compounds"):
-            return None
-            
-        compound = pubchem_data["PC_Compounds"][0]
-        return {
-            'molecular_formula': self._extract_property(compound, 'Molecular Formula'),
-            'iupac_name': self._extract_property(compound, 'IUPAC Name'),
-            'canonical_smiles': self._extract_property(compound, 'Canonical SMILES'),
-            'molecular_weight': self._extract_property(compound, 'Molecular Weight'),
-            'logp': self._extract_property(compound, 'LogP')
-        }
-
-    def _extract_property(self, compound: Dict, prop_name: str) -> str:
-        """Helper for property extraction from PubChem data"""
-        for prop in compound.get("props", []):
-            if prop.get("urn", {}).get("label") == prop_name:
+        return response.choices[0].message.content.strip()
+    except Exception as e:
+        st.error(f"GPT-4 generation error: {e}")
+        logging.error(e)
+        return "AI content generation failed."
+
+# -------------------------------
+# UTILITY FUNCTIONS WITH CACHING
+# -------------------------------
+@st.cache_data(show_spinner=False)
+def query_api(endpoint: str, params: Optional[Dict] = None, headers: Optional[Dict] = None) -> Optional[Dict]:
+    """Wrapper for HTTP GET requests with error handling."""
+    try:
+        response = requests.get(endpoint, params=params, headers=headers, timeout=15)
+        response.raise_for_status()
+        return response.json()
+    except Exception as e:
+        st.error(f"API error for {endpoint}: {e}")
+        logging.error(f"API error for {endpoint}: {e}")
+    return None
+
+@st.cache_data(show_spinner=False)
+def get_pubchem_smiles(drug_name: str) -> Optional[str]:
+    """Retrieve canonical SMILES using PubChem."""
+    url = API_ENDPOINTS["pubchem"].format(drug_name)
+    data = query_api(url)
+    if data and data.get("PC_Compounds"):
+        for prop in data["PC_Compounds"][0].get("props", []):
+            if prop.get("name") == "Canonical SMILES":
                 return prop["value"]["sval"]
-        return "N/A"
+    return None
+
+def draw_molecule(smiles: str) -> Optional[Any]:
+    """Generate a 2D molecule image using RDKit."""
+    try:
+        mol = Chem.MolFromSmiles(smiles)
+        if mol:
+            return Draw.MolToImage(mol)
+        else:
+            st.error("Invalid SMILES string provided.")
+    except Exception as e:
+        st.error(f"Error drawing molecule: {e}")
+        logging.error(e)
+    return None
+
+@st.cache_data(show_spinner=False)
+def get_pubchem_drug_details(drug_name: str) -> Optional[Dict[str, str]]:
+    """Retrieve drug details from PubChem."""
+    url = API_ENDPOINTS["pubchem"].format(drug_name)
+    data = query_api(url)
+    details = {}
+    if data and data.get("PC_Compounds"):
+        compound = data["PC_Compounds"][0]
+        for prop in compound.get("props", []):
+            urn = prop.get("urn", {})
+            if urn.get("label") == "Molecular Formula":
+                details["Molecular Formula"] = prop["value"]["sval"]
+            if urn.get("name") == "Preferred":
+                details["IUPAC Name"] = prop["value"]["sval"]
+            if prop.get("name") == "Canonical SMILES":
+                details["Canonical SMILES"] = prop["value"]["sval"]
+        return details
+    return None
+
+@st.cache_data(show_spinner=False)
+def get_clinical_trials(query: str) -> Optional[Dict]:
+    """Query ClinicalTrials.gov."""
+    if query.upper().startswith("NCT") and query[3:].isdigit():
+        params = {"id": query, "fmt": "json"}
+    else:
+        params = {"query.term": query, "retmax": 10, "retmode": "json"}
+    return query_api(API_ENDPOINTS["clinical_trials"], params)
+
+@st.cache_data(show_spinner=False)
+def get_pubmed(query: str) -> Optional[Dict]:
+    """Query PubMed."""
+    params = {"db": "pubmed", "term": query, "retmax": 10, "retmode": "json", "email": PUB_EMAIL}
+    return query_api(API_ENDPOINTS["pubmed"], params)
+
+@st.cache_data(show_spinner=False)
+def get_fda_approval(drug_name: str) -> Optional[Dict]:
+    """Retrieve FDA approval info using openFDA."""
+    if not OPENFDA_KEY:
+        st.error("OpenFDA key not configured.")
+        return None
+    query = f'openfda.brand_name:"{drug_name}"'
+    params = {"api_key": OPENFDA_KEY, "search": query, "limit": 1}
+    data = query_api(API_ENDPOINTS["fda_drug_approval"], params)
+    if data and data.get("results"):
+        return data["results"][0]
+    return None
 
-# -----------------------------
-# INTELLIGENCE MODULES
-# -----------------------------
-class ClinicalIntelligence:
-    """Handles clinical trial and regulatory data analysis"""
+@st.cache_data(show_spinner=False)
+def analyze_adverse_events(drug_name: str, limit: int = 5) -> Optional[Dict]:
+    """Retrieve FAERS adverse events."""
+    if not OPENFDA_KEY:
+        st.error("OpenFDA key not configured.")
+        return None
+    query = f'patient.drug.medicinalproduct:"{drug_name}"'
+    params = {"api_key": OPENFDA_KEY, "search": query, "limit": limit}
+    return query_api(API_ENDPOINTS["faers_adverse_events"], params)
+
+@st.cache_data(show_spinner=False)
+def get_pharmgkb_variants_for_gene(pharmgkb_gene_id: str) -> Optional[List[str]]:
+    """Return variant IDs for a PharmGKB gene accession."""
+    if not pharmgkb_gene_id.startswith("PA"):
+        st.warning("Enter a valid PharmGKB gene accession (e.g., PA1234).")
+        return None
+    endpoint = API_ENDPOINTS["pharmgkb_gene_variants"].format(pharmgkb_gene_id)
+    data = query_api(endpoint)
+    if data and data.get("data"):
+        return [variant["id"] for variant in data["data"]]
+    st.warning(f"No variants found for PharmGKB gene {pharmgkb_gene_id}.")
+    return None
+
+@st.cache_data(show_spinner=False)
+def get_rxnorm_rxcui(drug_name: str) -> Optional[str]:
+    """Return RxCUI for a drug."""
+    url = f"{API_ENDPOINTS['rxnorm_rxcui']}?name={drug_name}"
+    data = query_api(url)
+    if data and "idGroup" in data and data["idGroup"].get("rxnormId"):
+        return data["idGroup"]["rxnormId"][0]
+    st.warning(f"No RxCUI found for {drug_name}.")
+    return None
+
+@st.cache_data(show_spinner=False)
+def get_rxnorm_properties(rxcui: str) -> Optional[Dict]:
+    """Return RxNorm properties for a given RxCUI."""
+    url = API_ENDPOINTS["rxnorm_properties"].format(rxcui)
+    return query_api(url)
+
+@st.cache_data(show_spinner=False)
+def get_rxclass_by_drug_name(drug_name: str) -> Optional[Dict]:
+    """Return RxClass information for a drug."""
+    url = f"{API_ENDPOINTS['rxclass_by_drug']}?drugName={drug_name}"
+    data = query_api(url)
+    if data and "classMember" in data:
+        return data
+    return None
+
+# -------------------------------
+# AI-DRIVEN DRUG INSIGHTS
+# -------------------------------
+def generate_drug_insights(drug_name: str) -> str:
+    """
+    Gather FDA, PubChem, RxNorm, and RxClass data (using generic fallback) and build a GPT‑4 prompt
+    for an innovative, bullet‑point drug analysis.
+    """
+    query_name = TRADE_TO_GENERIC.get(drug_name.lower(), drug_name)
     
-    def __init__(self):
-        self.engine = PharmaResearchEngine()
+    # Get FDA data
+    fda_info = get_fda_approval(query_name)
+    fda_status = "Not Approved"
+    if fda_info and fda_info.get("openfda", {}).get("brand_name"):
+        fda_status = ", ".join(fda_info["openfda"]["brand_name"])
     
-    def get_trial_landscape(self, query: str) -> List[Dict]:
-        """Analyze clinical trial landscape for given query"""
-        params = {"query.term": query, "retmax": 10} if not query.startswith("NCT") else {"id": query}
-        trials = self.engine.api_request(API_ENDPOINTS["clinical_trials"], params=params)
-        return trials.get("studies", [])[:5]
-
-    def get_fda_approval(self, drug_name: str) -> Optional[Dict]:
-        """Retrieve FDA approval information for a drug"""
-        if not OPENFDA_KEY:
-            st.error("OpenFDA API key not configured.")
-            return None
-        
-        params = {
-            "api_key": OPENFDA_KEY,
-            "search": f'openfda.brand_name:"{drug_name}"',
-            "limit": 1
-        }
-        
-        data = self.engine.api_request(
-            API_ENDPOINTS["fda_drug_approval"],
-            params=params
-        )
-        
-        if data and data.get("results"):
-            return data["results"][0]
-        return None
+    # Get PubChem details
+    pubchem_details = get_pubchem_drug_details(query_name)
+    if pubchem_details:
+        formula = pubchem_details.get("Molecular Formula", "N/A")
+        iupac = pubchem_details.get("IUPAC Name", "N/A")
+        canon_smiles = pubchem_details.get("Canonical SMILES", "N/A")
+    else:
+        formula = iupac = canon_smiles = "Not Available"
+    
+    # RxNorm and RxClass
+    rxnorm_id = get_rxnorm_rxcui(query_name)
+    if rxnorm_id:
+        rx_props = get_rxnorm_properties(rxnorm_id)
+        rxnorm_info = f"RxCUI: {rxnorm_id}\nProperties: {rx_props}"
+    else:
+        rxnorm_info = "No RxNorm data available."
+    
+    rxclass_data = get_rxclass_by_drug_name(query_name)
+    rxclass_info = rxclass_data if rxclass_data else "No RxClass data available."
+    
+    # Construct prompt for GPT-4
+    prompt = (
+        f"Please provide an advanced, innovative drug analysis report for '{drug_name}' "
+        f"(generic: {query_name}).\n\n"
+        f"**FDA Approval Status:** {fda_status}\n"
+        f"**PubChem Details:** Molecular Formula: {formula}, IUPAC Name: {iupac}, Canonical SMILES: {canon_smiles}\n"
+        f"**RxNorm Info:** {rxnorm_info}\n"
+        f"**RxClass Info:** {rxclass_info}\n\n"
+        f"Include the following in bullet points:\n"
+        f"- Pharmacogenomic considerations (including genetic variants that might affect metabolism and toxicity).\n"
+        f"- Potential repurposing opportunities based on drug mechanism.\n"
+        f"- Regulatory insights and challenges, particularly for expanding indications or personalized medicine.\n"
+        f"- Innovative suggestions for future research and data integration approaches.\n"
+    )
+    return generate_ai_content(prompt)
+
+# -------------------------------
+# STREAMLIT APP LAYOUT
+# -------------------------------
+tabs = st.tabs([
+    "💊 Drug Development",
+    "📊 Trial Analytics",
+    "🧬 Molecular Profiling",
+    "📜 Regulatory Intelligence",
+    "📚 Literature Search",
+    "📈 Dashboard",
+    "🧪 Drug Data Integration",
+    "🤖 AI Insights"
+])
 
-class AIDrugInnovator:
-    """GPT-4 powered drug development strategist"""
+# ----- Tab 1: Drug Development -----
+with tabs[0]:
+    st.header("AI-Driven Drug Development Strategy")
+    target = st.text_input("Target Disease/Pathway:", placeholder="Enter disease mechanism or target")
+    target_gene = st.text_input("Target Gene (PharmGKB Accession):", placeholder="e.g., PA1234")
+    strategy = st.selectbox("Development Strategy:", ["First-in-class", "Me-too", "Repurposing", "Biologic"])
     
-    def __init__(self):
-        self.engine = PharmaResearchEngine()
-        
-    def generate_strategy(self, target: str, strategy: str) -> str:
-        """Generate AI-driven development strategy"""
-        prompt = f"""As Chief Scientific Officer of a top pharmaceutical company, develop a {strategy} strategy for {target}.
-        Include:
-        - Target validation approach
-        - Lead optimization tactics
-        - Clinical trial design
-        - Regulatory pathway analysis
-        - Commercial potential assessment
-        Format in Markdown with clear sections."""
-        
-        try:
-            response = self.engine.openai_client.chat.completions.create(
-                model="gpt-4",
-                messages=[{"role": "user", "content": prompt}],
-                temperature=0.7,
-                max_tokens=1500
+    if st.button("Generate Development Plan"):
+        with st.spinner("Generating comprehensive development plan..."):
+            plan_prompt = (
+                f"Develop a detailed drug development plan for treating {target} using a {strategy} strategy. "
+                "Include sections on target validation, lead optimization, preclinical testing, clinical trial design, "
+                "regulatory strategy, market analysis, competitive landscape, and relevant pharmacogenomic considerations."
             )
-            return response.choices[0].message.content
-        except Exception as e:
-            logger.error(f"AI Strategy Error: {str(e)}")
-            return "Strategy generation failed. Please check API configuration."
-
-# -----------------------------
-# STREAMLIT INTERFACE
-# -----------------------------
-class PharmaResearchInterface:
-    """Modern UI for pharmaceutical research platform"""
-    
-    def __init__(self):
-        self.clinical_intel = ClinicalIntelligence()
-        self.ai_innovator = AIDrugInnovator()
-        self._configure_page()
-
-    def _configure_page(self):
-        """Setup Streamlit page configuration"""
-        st.set_page_config(
-            page_title="PRIS - Pharma Research Intelligence Suite",
-            layout="wide",
-            initial_sidebar_state="expanded"
-        )
-        st.markdown("""
-            <style>
-            .main {background-color: #f9f9f9;}
-            .stAlert {padding: 20px;}
-            .reportview-container .markdown-text-container {font-family: 'Arial'}
-            </style>
-            """, unsafe_allow_html=True)
-
-    def render(self):
-        """Main application interface"""
-        st.title("Pharma Research Intelligence Suite")
-        self._render_navigation()
-        
-    def _render_navigation(self):
-        """Dynamic tab-based navigation system"""
-        tabs = st.tabs([
-            "🚀 Drug Innovation",
-            "📈 Trial Analytics",
-            "🧪 Compound Profiler",
-            "📜 Regulatory Hub",
-            "🤖 AI Strategist"
-        ])
+            plan = generate_ai_content(plan_prompt)
+            st.subheader("Comprehensive Development Plan")
+            st.markdown(plan)
         
-        with tabs[0]: self._drug_innovation()
-        with tabs[1]: self._trial_analytics()
-        with tabs[2]: self._compound_profiler()
-        with tabs[3]: self._regulatory_hub()
-        with tabs[4]: self._ai_strategist()
-
-    def _drug_innovation(self):
-        """Drug development strategy interface"""
-        st.header("AI-Powered Drug Innovation Engine")
-        col1, col2 = st.columns([1, 3])
+        st.subheader("FDA Regulatory Insights")
+        if target:
+            fda_data = get_fda_approval(target.split()[0])
+            if fda_data:
+                st.json(fda_data)
+            else:
+                st.write("No FDA data found for the given target.")
         
-        with col1:
-            target = st.text_input("Target Pathobiology:", placeholder="e.g., EGFR mutant NSCLC")
-            strategy = st.selectbox("Development Paradigm:", 
-                                  ["First-in-class", "Fast-follower", "Biologic", "ADC", "Gene Therapy"])
-            if st.button("Generate Development Blueprint"):
-                with st.spinner("Formulating strategic plan..."):
-                    blueprint = self.ai_innovator.generate_strategy(target, strategy)
-                    st.markdown(blueprint, unsafe_allow_html=True)
-
-    def _trial_analytics(self):
-        """Clinical trial analytics interface"""
-        st.header("Clinical Trial Landscape Analysis")
-        trial_query = st.text_input("Search Clinical Trials:", placeholder="Enter condition, intervention, or NCT number")
-        
-        if st.button("Analyze Trial Landscape"):
-            with st.spinner("Fetching trial data..."):
-                trials = self.clinical_intel.get_trial_landscape(trial_query)
-                
-                if trials:
-                    st.subheader("Top 5 Clinical Trials")
-                    trial_data = []
-                    for study in trials:
-                        trial_data.append({
-                            "Title": study.get("protocolSection", {}).get("identificationModule", {}).get("briefTitle", "N/A"),
-                            "Status": study.get("protocolSection", {}).get("statusModule", {}).get("overallStatus", "N/A"),
-                            "Phase": study.get("protocolSection", {}).get("designModule", {}).get("phases", ["N/A"])[0],
-                            "Enrollment": study.get("protocolSection", {}).get("designModule", {}).get("enrollmentInfo", {}).get("count", "N/A")
-                        })
-                    
-                    # Display as a DataFrame
-                    df = pd.DataFrame(trial_data)
-                    st.dataframe(df)
-                    
-                    # Visualization
-                    st.subheader("Trial Phase Distribution")
-                    phase_counts = df["Phase"].value_counts()
-                    fig, ax = plt.subplots()
-                    sns.barplot(x=phase_counts.index, y=phase_counts.values, ax=ax)
-                    ax.set_xlabel("Trial Phase")
-                    ax.set_ylabel("Number of Trials")
-                    st.pyplot(fig)
+        st.subheader("Pharmacogenomic Considerations")
+        if target_gene:
+            if not target_gene.startswith("PA"):
+                st.warning("Enter a valid PharmGKB accession (e.g., PA1234).")
+            else:
+                variants = get_pharmgkb_variants_for_gene(target_gene)
+                if variants:
+                    st.write("PharmGKB Variants:")
+                    st.write(variants)
+                    for vid in variants[:3]:
+                        annotations = _get_pharmgkb_clinical_annotations(vid)
+                        st.write(f"Annotations for Variant {vid}:")
+                        st.json(annotations if annotations else {"message": "No annotations found."})
                 else:
-                    st.warning("No clinical trials found for the query.")
+                    st.write("No variants found for the specified PharmGKB gene accession.")
+        else:
+            st.write("Provide a PharmGKB gene accession to retrieve pharmacogenomic data.")
 
-    def _compound_profiler(self):
-        """Advanced chemical analysis interface"""
-        st.header("Multi-Omics Compound Profiler")
-        compound = st.text_input("Analyze Compound:", placeholder="Enter drug name or SMILES")
+# ----- Tab 2: Clinical Trial Analytics -----
+with tabs[1]:
+    st.header("Clinical Trial Landscape Analytics")
+    trial_query = st.text_input("Search Clinical Trials:", placeholder="Enter condition, intervention, or NCT number")
+    if st.button("Analyze Trial Landscape"):
+        with st.spinner("Fetching trial data..."):
+            trials = get_clinical_trials(trial_query)
+            if trials and trials.get("studies"):
+                trial_data = []
+                for study in trials["studies"][:5]:
+                    trial_data.append({
+                        "Title": study.get("protocolSection", {}).get("identificationModule", {}).get("briefTitle", "N/A"),
+                        "Status": study.get("protocolSection", {}).get("statusModule", {}).get("overallStatus", "N/A"),
+                        "Phase": study.get("protocolSection", {}).get("designModule", {}).get("phases", ["Not Available"])[0],
+                        "Enrollment": study.get("protocolSection", {}).get("designModule", {}).get("enrollmentInfo", {}).get("count", "N/A")
+                    })
+                _display_dataframe(trial_data, list(trial_data[0].keys()))
+            else:
+                st.warning("No clinical trials found for the query.")
         
-        if compound:
-            with st.spinner("Decoding molecular profile..."):
-                profile = PharmaResearchEngine().get_compound_profile(compound)
-                
-            if profile:
-                col1, col2 = st.columns(2)
-                with col1:
-                    st.subheader("Structural Insights")
-                    mol = Chem.MolFromSmiles(profile['canonical_smiles'])
-                    if mol:
-                        img = Draw.MolToImage(mol, size=(400, 300))
-                        st.image(img, caption="2D Molecular Structure")
-                
-                with col2:
-                    st.subheader("Physicochemical Profile")
-                    st.metric("Molecular Weight", profile['molecular_weight'])
-                    st.metric("LogP", profile['logp'])
-                    st.metric("IUPAC Name", profile['iupac_name'])
-                    st.code(f"SMILES: {profile['canonical_smiles']}")
-
-    def _regulatory_hub(self):
-        """Regulatory intelligence interface"""
-        st.header("Regulatory Intelligence Hub")
-        st.write("This section provides insights into FDA approvals and regulatory pathways.")
-        drug_name = st.text_input("Enter Drug Name for Regulatory Analysis:", placeholder="e.g., aspirin")
-        
-        if st.button("Fetch Regulatory Data"):
-            with st.spinner("Retrieving regulatory information..."):
-                fda_data = self.clinical_intel.get_fda_approval(drug_name)
-                if fda_data:
-                    st.subheader("FDA Approval Details")
-                    st.json(fda_data)
-                else:
-                    st.warning("No FDA data found for the specified drug.")
+        ae_data = analyze_adverse_events(trial_query)
+        if ae_data and ae_data.get("results"):
+            st.subheader("Adverse Event Profile (Top 5)")
+            ae_results = ae_data["results"][:5]
+            ae_df = pd.json_normalize(ae_results)
+            st.dataframe(ae_df)
+            if "patient.reaction.reactionmeddrapt" in ae_df.columns:
+                try:
+                    reactions = ae_df["patient.reaction.reactionmeddrapt"].explode().dropna()
+                    top_reactions = reactions.value_counts().nlargest(10)
+                    fig, ax = plt.subplots(figsize=(10, 6))
+                    sns.barplot(x=top_reactions.values, y=top_reactions.index, ax=ax)
+                    ax.set_title("Top Adverse Reactions")
+                    ax.set_xlabel("Frequency")
+                    ax.set_ylabel("Reaction")
+                    st.pyplot(fig)
+                except Exception as e:
+                    st.error(f"Error visualizing adverse events: {e}")
+        else:
+            st.write("No adverse event data available.")
 
-    def _ai_strategist(self):
-        """AI-driven drug strategy interface"""
-        st.header("AI Drug Development Strategist")
-        st.write("Leverage GPT-4 for innovative drug development strategies.")
-        target = st.text_input("Enter Target Disease or Pathway:", placeholder="e.g., KRAS G12C mutation")
-        
-        if st.button("Generate AI Strategy"):
-            with st.spinner("Generating AI-driven strategy..."):
-                strategy = self.ai_innovator.generate_strategy(target, "First-in-class")
-                st.markdown(strategy, unsafe_allow_html=True)
-
-# -----------------------------
-# MAIN EXECUTION
-# -----------------------------
-if __name__ == "__main__":
-    interface = PharmaResearchInterface()
-    interface.render()
+# ----- Tab 3: Molecular Profiling -----
+with tabs[2]:
+    st.header("Advanced Molecular Profiling")
+    compound_input = st.text_input("Compound Identifier:", placeholder="Enter drug name, SMILES, or INN")
+    if st.button("Analyze Compound"):
+        with st.spinner("Querying PubChem for molecular structure..."):
+            query_compound = TRADE_TO_GENERIC.get(compound_input.lower(), compound_input)
+            smiles = _get_pubchem_smiles(query_compound)
+            if smiles:
+                mol_image = draw_molecule(smiles)
+                if mol_image:
+                    st.image(mol_image, caption="2D Molecular Structure")
+            else:
+                st.error("Molecular structure not found. Try a more specific compound name.")
+        pubchem_data = query_api(API_ENDPOINTS["pubchem"].format(query_compound))
+        if pubchem_data and pubchem_data.get("PC_Compounds"):
+            st.subheader("Physicochemical Properties")
+            props = pubchem_data["PC_Compounds"][0].get("props", [])
+            mw = next((prop["value"]["sval"] for prop in props if prop.get("name") == "Molecular Weight"), "N/A")
+            logp = next((prop["value"]["sval"] for prop in props if prop.get("name") == "LogP"), "N/A")
+            st.write(f"**Molecular Weight:** {mw}")
+            st.write(f"**LogP:** {logp}")
+        else:
+            st.error("Physicochemical properties not available.")
+
+# ----- Tab 4: Regulatory Intelligence -----
+with tabs[3]:
+    st.header("Global Regulatory Monitoring")
+    st.markdown("**Note:** Due to persistent issues with EMA/WHO/DailyMed APIs, this section focuses on FDA data and PubChem drug details.")
+    drug_prod = st.text_input("Drug Product:", placeholder="Enter generic or brand name")
+    if st.button("Generate Regulatory Report"):
+        with st.spinner("Compiling regulatory data..."):
+            fda_data = get_fda_approval(drug_prod)
+            fda_status = "Not Approved"
+            if fda_data and fda_data.get("openfda", {}).get("brand_name"):
+                fda_status = ", ".join(fda_data["openfda"]["brand_name"])
+            pubchem_details = get_pubchem_drug_details(drug_prod)
+            if pubchem_details:
+                formula = pubchem_details.get("Molecular Formula", "N/A")
+                iupac = pubchem_details.get("IUPAC Name", "N/A")
+                canon_smiles = pubchem_details.get("Canonical SMILES", "N/A")
+            else:
+                formula = iupac = canon_smiles = "Not Available"
+            col1, col2 = st.columns(2)
+            with col1:
+                st.markdown("**FDA Status**")
+                st.write(fda_status)
+            with col2:
+                st.markdown("**Drug Details (PubChem)**")
+                st.write(f"**Molecular Formula:** {formula}")
+                st.write(f"**IUPAC Name:** {iupac}")
+                st.write(f"**Canonical SMILES:** {canon_smiles}")
+            report_text = (
+                f"### Regulatory Report for {drug_prod}\n\n"
+                f"**FDA Status:** {fda_status}\n\n"
+                f"**Molecular Formula:** {formula}\n\n"
+                f"**IUPAC Name:** {iupac}\n\n"
+                f"**Canonical SMILES:** {canon_smiles}\n"
+            )
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp:
+                pdf_file = _save_pdf_report(report_text, tmp.name)
+                if pdf_file:
+                    with open(pdf_file, "rb") as f:
+                        st.download_button("Download Regulatory Report (PDF)", data=f, file_name=f"{drug_prod}_report.pdf", mime="application/pdf")
+                    os.remove(pdf_file)
+
+# ----- Tab 5: Literature Search -----
+with tabs[4]:
+    st.header("Literature Search")
+    lit_query = st.text_input("Enter search query for PubMed:", placeholder="e.g., Alzheimer's disease genetics")
+    if st.button("Search PubMed"):
+        with st.spinner("Searching PubMed..."):
+            pubmed_results = get_pubmed(lit_query)
+            if pubmed_results and pubmed_results.get("esearchresult", {}).get("idlist"):
+                id_list = pubmed_results["esearchresult"]["idlist"]
+                st.subheader(f"Found {len(id_list)} PubMed Results")
+                for pmid in id_list:
+                    st.markdown(f"- [PMID: {pmid}](https://pubmed.ncbi.nlm.nih.gov/{pmid}/)")
+            else:
+                st.write("No PubMed results found.")
+    st.header("Ontology Search")
+    ont_query = st.text_input("Enter search query for Ontology:", placeholder="e.g., Alzheimer's disease")
+    ont_select = st.selectbox("Select Ontology", ["MESH", "NCIT", "GO", "SNOMEDCT"])
+    if st.button("Search BioPortal"):
+        with st.spinner("Searching BioPortal..."):
+            bioportal_results = _get_bioportal_data(ont_select, ont_query)
+            if bioportal_results and bioportal_results.get("collection"):
+                st.subheader(f"BioPortal Results for {ont_select}")
+                for item in bioportal_results["collection"]:
+                    label = item.get("prefLabel", "N/A")
+                    ont_id = item.get("@id", "N/A")
+                    st.markdown(f"- **{label}** ({ont_id})")
+            else:
+                st.write("No ontology results found.")
+
+# ----- Tab 6: Comprehensive Dashboard -----
+with tabs[5]:
+    st.header("Comprehensive Dashboard")
+    # Example KPIs (these could later be replaced by dynamic queries)
+    kpi_fda = 5000
+    kpi_trials = 12000
+    kpi_pubs = 250000
+    col1, col2, col3 = st.columns(3)
+    col1.metric("FDA Approved Drugs", kpi_fda)
+    col2.metric("Ongoing Trials", kpi_trials)
+    col3.metric("Publications", kpi_pubs)
+    st.subheader("Trend Analysis")
+    years = list(range(2000, 2026))
+    approvals = [kpi_fda // len(years)] * len(years)
+    fig_trend, ax_trend = plt.subplots(figsize=(10, 6))
+    sns.lineplot(x=years, y=approvals, marker="o", ax=ax_trend)
+    ax_trend.set_title("FDA Approvals Over Time")
+    ax_trend.set_xlabel("Year")
+    ax_trend.set_ylabel("Number of Approvals")
+    st.pyplot(fig_trend)
+    st.subheader("Gene-Variant-Drug Network (Sample)")
+    sample_gene = "CYP2C19"
+    sample_variants = ["rs4244285", "rs12248560"]
+    sample_annots = {"rs4244285": ["Clopidogrel", "Omeprazole"], "rs12248560": ["Sertraline"]}
+    try:
+        net_fig = _create_variant_network(sample_gene, sample_variants, sample_annots)
+        st.plotly_chart(net_fig, use_container_width=True)
+    except Exception as e:
+        st.error(f"Network graph error: {e}")
+
+# ----- Tab 7: Drug Data Integration -----
+with tabs[6]:
+    st.header("🧪 Drug Data Integration")
+    drug_integration = st.text_input("Enter Drug Name for API Integration:", placeholder="e.g., aspirin")
+    if st.button("Retrieve Drug Data"):
+        with st.spinner("Fetching drug data from multiple sources..."):
+            query_drug = TRADE_TO_GENERIC.get(drug_integration.lower(), drug_integration)
+            rxnorm_id = get_rxnorm_rxcui(query_drug)
+            rx_props = get_rxnorm_properties(rxnorm_id) if rxnorm_id else None
+            rxclass_info = get_rxclass_by_drug_name(query_drug)
+            st.subheader("RxNorm Data")
+            if rxnorm_id:
+                st.write(f"RxCUI for {drug_integration}: {rxnorm_id}")
+                st.json(rx_props if rx_props else {"message": "No RxNorm properties found."})
+            else:
+                st.write("No RxCUI found for the given drug name.")
+            st.subheader("RxClass Information")
+            if rxclass_info:
+                st.json(rxclass_info)
+            else:
+                st.write("No RxClass data found for the given drug.")
+            pubchem_info = get_pubchem_drug_details(query_drug)
+            st.subheader("PubChem Drug Details")
+            if pubchem_info:
+                st.write(f"**Molecular Formula:** {pubchem_info.get('Molecular Formula', 'N/A')}")
+                st.write(f"**IUPAC Name:** {pubchem_info.get('IUPAC Name', 'N/A')}")
+                st.write(f"**Canonical SMILES:** {pubchem_info.get('Canonical SMILES', 'N/A')}")
+            else:
+                st.write("No PubChem details found.")
+
+# ----- Tab 8: AI Insights -----
+with tabs[7]:
+    st.header("🤖 AI Insights")
+    ai_drug = st.text_input("Enter Drug Name for AI-Driven Analysis:", placeholder="e.g., tylenol")
+    if st.button("Generate AI Insights"):
+        with st.spinner("Generating AI-driven insights..."):
+            query_ai_drug = TRADE_TO_GENERIC.get(ai_drug.lower(), ai_drug)
+            insights_text = generate_drug_insights(query_ai_drug)
+            st.subheader("AI-Driven Drug Analysis")
+            st.markdown(insights_text)
+
+# -------------------------------
+# SIDEBAR INFORMATION
+# -------------------------------
+st.sidebar.header("About")
+st.sidebar.info("""
+**Pharma Research Expert Platform**
+
+An innovative, AI-driven tool for advanced drug discovery, clinical research, and regulatory analysis.
+
+**Developed by:** Your Name  
+**Contact:** [[email protected]](mailto:[email protected])
+Last updated: {}
+""".format(datetime.now().strftime("%Y-%m-%d")))