Update app.py

app.py

@@ -1,467 +1,285 @@
+"""
+Pharma Research Intelligence Suite (PRIS) v2.0
+Enterprise-Grade Drug Development Platform with Robust UI
+"""
+
 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
-from datetime import datetime
 from openai import OpenAI
+from typing import Optional, Dict, List, Any
 
-# -------------------------------
-# 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_trials": "https://clinicaltrials.gov/api/v2/studies",
-    "pubchem": "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{}/JSON",
-    "pubmed": "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi",
-    "fda_drug_approval": "https://api.fda.gov/drug/label.json",
-    "faers_adverse_events": "https://api.fda.gov/drug/event.json",
-    "rxnorm_rxcui": "https://rxnav.nlm.nih.gov/REST/rxcui.json",
-    "rxnorm_properties": "https://rxnav.nlm.nih.gov/REST/rxcui/{}/properties.json"
-    # RxClass and EMA endpoints are omitted due to reliability issues.
-}
-
-# -------------------------------
-# TRADE-TO-GENERIC MAPPING (FALLBACK)
-# -------------------------------
-TRADE_TO_GENERIC = {
-    "tylenol": "acetaminophen",
-    "panadol": "acetaminophen",
-    "asprin": "aspirin"
-}
-
-# -------------------------------
-# RETRIEVE SECRETS
-# -------------------------------
-OPENAI_API_KEY = st.secrets.get("OPENAI_API_KEY")
-OPENFDA_KEY = st.secrets.get("OPENFDA_KEY")
-PUB_EMAIL = st.secrets.get("PUB_EMAIL")
+# ======================
+# Configuration
+# ======================
+st.set_page_config(
+    page_title="PRIS 2.0 - Pharma Research Platform",
+    page_icon="🧬",
+    layout="wide"
+)
 
-if not PUB_EMAIL:
-    st.error("PUB_EMAIL 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.")
+# ======================
+# API Configuration
+# ======================
+CLINICAL_TRIALS_API = "https://clinicaltrials.gov/api/v2/studies"
+FDA_API = "https://api.fda.gov/drug/label.json"
+PUBCHEM_API = "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{}/JSON"
 
-# -------------------------------
-# INITIALIZE OPENAI (GPT‑4) CLIENT
-# -------------------------------
-openai_client = OpenAI(api_key=OPENAI_API_KEY)
+# ======================
+# Core Services
+# ======================
+class PharmaResearchService:
+    """Enterprise API integration layer with advanced resilience"""
+    
+    def __init__(self):
+        self.session = requests.Session()
+        self.session.headers.update({
+            "User-Agent": "PRIS/2.0 (Enterprise Pharma Analytics)",
+            "Accept": "application/json"
+        })
+    
+    def get_clinical_trials(self, query: str) -> List[Dict]:
+        """Get clinical trials with robust error handling"""
+        try:
+            response = self.session.get(
+                CLINICAL_TRIALS_API,
+                params={"query": query, "format": "json", "limit": 5},
+                timeout=10
+            )
+            response.raise_for_status()
+            data = response.json()
+            return data.get("studies", [])[:5]
+        except Exception as e:
+            st.error(f"Clinical trials API error: {str(e)}")
+            return []
 
-def generate_ai_content(prompt: str) -> str:
-    """Generate innovative drug insights using GPT‑4."""
-    try:
-        response = openai_client.chat.completions.create(
-            model="gpt-4",
-            messages=[{"role": "user", "content": prompt}],
-            max_tokens=300
-        )
-        return response.choices[0].message.content.strip()
-    except Exception as e:
-        st.error(f"GPT‑4 error: {e}")
-        logging.error(e)
-        return "AI content generation failed."
+    def get_fda_approval(self, drug_name: str) -> Optional[Dict]:
+        """Retrieve FDA approval information"""
+        try:
+            response = self.session.get(
+                FDA_API,
+                params={
+                    "api_key": st.secrets["OPENFDA_KEY"],
+                    "search": f'openfda.brand_name:"{drug_name}"',
+                    "limit": 1
+                },
+                timeout=10
+            )
+            response.raise_for_status()
+            data = response.json()
+            return data.get("results", [None])[0]
+        except Exception as e:
+            st.error(f"FDA API error: {str(e)}")
+            return None
 
-# -------------------------------
-# UTILITY FUNCTIONS (with caching)
-# -------------------------------
-@st.cache_data(show_spinner=False)
-def query_api(endpoint: str, params: Optional[Dict] = None) -> Optional[Dict]:
-    """Perform an HTTP GET request with error handling."""
-    try:
-        response = requests.get(endpoint, params=params, timeout=15)
-        response.raise_for_status()
-        return response.json()
-    except Exception as e:
-        logging.error(f"Error querying {endpoint}: {e}")
-        return None
+    def get_compound_data(self, name: str) -> Optional[Dict]:
+        """Get PubChem compound data"""
+        try:
+            response = self.session.get(
+                PUBCHEM_API.format(name),
+                timeout=10
+            )
+            response.raise_for_status()
+            data = response.json()
+            return data.get("PC_Compounds", [{}])[0]
+        except Exception as e:
+            st.error(f"PubChem API error: {str(e)}")
+            return None
 
-@st.cache_data(show_spinner=False)
-def get_pubchem_drug_details(drug_name: str) -> Optional[Dict[str, str]]:
-    """Retrieve drug details (molecular formula, IUPAC name, SMILES) 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
+# ======================
+# UI Components
+# ======================
+class PharmaDashboard:
+    """Professional pharmaceutical research dashboard"""
+    
+    def __init__(self):
+        self.service = PharmaResearchService()
+        self._configure_styles()
+    
+    def _configure_styles(self):
+        """Inject custom CSS for professional appearance"""
+        st.markdown("""
+            <style>
+            .main {background-color: #f8f9fa;}
+            .block-container {padding-top: 2rem;}
+            .header {color: #2c3e50; border-bottom: 2px solid #3498db;}
+            .metric {background-color: white; padding: 1.5rem; border-radius: 10px; box-shadow: 0 2px 4px rgba(0,0,0,0.1);}
+            .plot-container {background-color: white; padding: 1rem; border-radius: 10px; margin-top: 1rem;}
+            </style>
+        """, unsafe_allow_html=True)
+    
+    def render(self):
+        """Main application interface"""
+        st.markdown("<h1 class='header'>PRIS 2.0 - Pharma Research Platform</h1>", unsafe_allow_html=True)
+        
+        tab1, tab2, tab3 = st.tabs([
+            "🧪 Compound Analyzer", 
+            "📊 Clinical Trials", 
+            "📜 Regulatory Info"
+        ])
+        
+        with tab1:
+            self._render_compound_analyzer()
+        with tab2:
+            self._render_clinical_trials()
+        with tab3:
+            self._render_regulatory_info()
+    
+    def _render_compound_analyzer(self):
+        """Compound analysis section"""
+        st.subheader("Molecular Analysis")
+        col1, col2 = st.columns([1, 2])
+        
+        with col1:
+            compound = st.text_input("Enter compound name:", "Aspirin")
+            if st.button("Analyze"):
+                with st.spinner("Analyzing compound..."):
+                    data = self.service.get_compound_data(compound)
+                    if data:
+                        self._display_compound_info(data)
+                    else:
+                        st.warning("Compound not found")
 
-def draw_molecule(smiles: str) -> Optional[Any]:
-    """Generate and return a 2D molecular structure image using RDKit."""
-    try:
-        mol = Chem.MolFromSmiles(smiles)
+        with col2:
+            if "mol_image" in st.session_state:
+                st.image(st.session_state.mol_image, caption="Molecular Structure")
+    
+    def _display_compound_info(self, data: Dict):
+        """Show compound information"""
+        properties = self._extract_properties(data)
+        
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            st.markdown(f"**Molecular Formula**  \n{properties['formula']}")
+        with col2:
+            st.markdown(f"**Molecular Weight**  \n{properties['weight']}")
+        with col3:
+            st.markdown(f"**IUPAC Name**  \n{properties['iupac']}")
+        
+        # Generate molecular structure
+        mol = Chem.MolFromSmiles(properties['smiles'])
         if mol:
-            return Draw.MolToImage(mol)
-    except Exception as e:
-        logging.error(f"Error drawing molecule: {e}")
-    return None
-
-def save_pdf_report(content: str, filename: str) -> Optional[str]:
-    """Save a text report as a PDF file using FPDF."""
-    try:
-        pdf = FPDF()
-        pdf.add_page()
-        pdf.set_font("Arial", size=12)
-        pdf.multi_cell(0, 10, content)
-        pdf.output(filename)
-        return filename
-    except Exception as e:
-        logging.error(f"Error saving PDF: {e}")
-        return None
-
-@st.cache_data(show_spinner=False)
-def get_clinical_trials(query: str) -> Optional[Dict]:
-    """Query ClinicalTrials.gov using a term or NCT number."""
-    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 using the provided search term."""
-    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 data from openFDA."""
-    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
-
-@st.cache_data(show_spinner=False)
-def analyze_adverse_events(drug_name: str, limit: int = 5) -> Optional[Dict]:
-    """Retrieve adverse events from FAERS."""
-    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_rxnorm_rxcui(drug_name: str) -> Optional[str]:
-    """Retrieve RxCUI for a given drug using RxNorm."""
-    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]
-    return None
-
-@st.cache_data(show_spinner=False)
-def get_rxnorm_properties(rxcui: str) -> Optional[Dict]:
-    """Retrieve RxNorm properties for a given RxCUI."""
-    url = API_ENDPOINTS["rxnorm_properties"].format(rxcui)
-    return query_api(url)
-
-# -------------------------------
-# AI-DRIVEN DRUG INSIGHTS
-# -------------------------------
-def generate_drug_insights(drug_name: str) -> str:
-    """
-    Gather FDA, PubChem, and RxNorm data (using trade-to-generic fallback) and build a GPT‑4 prompt
-    for an innovative drug analysis report.
-    """
-    query_name = TRADE_TO_GENERIC.get(drug_name.lower(), drug_name)
-    fda_info = get_fda_approval(query_name)
-    fda_status = "Not Available"
-    if fda_info and fda_info.get("openfda", {}).get("brand_name"):
-        fda_status = ", ".join(fda_info["openfda"]["brand_name"])
-    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_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."
-    prompt = (
-        f"Provide an innovative, advanced analysis for '{drug_name}' (generic: {query_name}).\n\n"
-        f"**FDA Approval Status:** {fda_status}\n\n"
-        f"**PubChem Details:**\n"
-        f"- Molecular Formula: {formula}\n"
-        f"- IUPAC Name: {iupac}\n"
-        f"- Canonical SMILES: {canon_smiles}\n\n"
-        f"**RxNorm Info:** {rxnorm_info}\n\n"
-        f"Include bullet points on:\n"
-        f"- Pharmacogenomic considerations (e.g., genetic variations impacting drug metabolism or toxicity)\n"
-        f"- Potential repurposing opportunities based on drug mechanisms\n"
-        f"- Regulatory insights and challenges for personalized medicine\n"
-        f"- Recommendations for future research and data integration\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"
-])
-
-# ----- 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"])
+            img = Draw.MolToImage(mol, size=(400, 300))
+            st.session_state.mol_image = img
     
-    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 pharmacogenomic considerations."
+    def _extract_properties(self, data: Dict) -> Dict:
+        """Extract chemical properties from PubChem data"""
+        return {
+            "formula": next(
+                (p["value"]["sval"] for p in data.get("props", []) 
+                 if p.get("urn", {}).get("label") == "Molecular Formula"),
+                "N/A"
+            ),
+            "weight": next(
+                (p["value"]["sval"] for p in data.get("props", [])
+                 if p.get("urn", {}).get("label") == "Molecular Weight"),
+                "N/A"
+            ),
+            "iupac": next(
+                (p["value"]["sval"] for p in data.get("props", [])
+                 if p.get("urn", {}).get("name") == "Preferred"),
+                "N/A"
+            ),
+            "smiles": next(
+                (p["value"]["sval"] for p in data.get("props", [])
+                 if p.get("name") == "Canonical SMILES"),
+                "N/A"
             )
-            plan = generate_ai_content(plan_prompt)
-            st.subheader("Comprehensive Development Plan")
-            st.markdown(plan)
+        }
+    
+    def _render_clinical_trials(self):
+        """Clinical trials analysis section"""
+        st.subheader("Clinical Trial Explorer")
+        query = st.text_input("Search for trials:", "Diabetes")
         
-        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.")
+        if st.button("Search Trials"):
+            with st.spinner("Searching clinical trials..."):
+                trials = self.service.get_clinical_trials(query)
+                if trials:
+                    self._display_trial_results(trials)
+                else:
+                    st.warning("No trials found for this query")
+    
+    def _display_trial_results(self, trials: List[Dict]):
+        """Display clinical trial results"""
+        df = pd.DataFrame([{
+            "NCT ID": t.get("protocolSection", {}).get("identificationModule", {}).get("nctId", "N/A"),
+            "Title": t.get("protocolSection", {}).get("identificationModule", {}).get("briefTitle", "N/A"),
+            "Status": t.get("protocolSection", {}).get("statusModule", {}).get("overallStatus", "N/A"),
+            "Phase": self._parse_phase(t),
+            "Enrollment": t.get("protocolSection", {}).get("designModule", {}).get("enrollmentInfo", {}).get("count", "N/A")
+        } for t in trials])
         
-        st.subheader("Pharmacogenomic Considerations")
-        if target_gene:
-            if not target_gene.startswith("PA"):
-                st.warning("Enter a valid PharmGKB accession (e.g., PA1234).")
-            else:
-                # For demonstration, use dummy variant data.
-                variants = ["rsDummy1", "rsDummy2"]
-                sample_annots = {"rsDummy1": ["DrugA", "DrugB"], "rsDummy2": ["DrugC"]}
-                try:
-                    net_fig = create_variant_network(target_gene, variants, sample_annots)
-                    st.plotly_chart(net_fig, use_container_width=True)
-                except Exception as e:
-                    st.error(f"Network graph error: {e}")
-        else:
-            st.write("Provide a PharmGKB gene accession to retrieve pharmacogenomic data.")
-
-# ----- 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")
-                    })
-                df_trials = pd.DataFrame(trial_data)
-                st.dataframe(df_trials)
-            else:
-                st.warning("No clinical trials found for the query.")
+        st.dataframe(
+            df,
+            use_container_width=True,
+            hide_index=True,
+            column_config={
+                "NCT ID": st.column_config.TextColumn(width="medium"),
+                "Title": st.column_config.TextColumn(width="large"),
+                "Status": st.column_config.TextColumn(width="small"),
+                "Phase": st.column_config.TextColumn(width="small"),
+                "Enrollment": st.column_config.NumberColumn(format="%d")
+            }
+        )
         
-        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.")
-
-# ----- Tab 3: Advanced 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("Fetching molecular structure and properties from PubChem..."):
-            query_compound = TRADE_TO_GENERIC.get(compound_input.lower(), compound_input)
-            pubchem_info = get_pubchem_drug_details(query_compound)
-            if pubchem_info:
-                smiles = pubchem_info.get("Canonical SMILES", "N/A")
-                if smiles != "N/A":
-                    mol_image = draw_molecule(smiles)
-                    if mol_image:
-                        st.image(mol_image, caption="2D Molecular Structure")
+        # Phase distribution visualization
+        st.subheader("Trial Phase Distribution")
+        self._plot_phase_distribution(df)
+    
+    def _parse_phase(self, trial: Dict) -> str:
+        """Extract and format trial phase"""
+        phases = trial.get("protocolSection", {}).get("designModule", {}).get("phases", [])
+        return phases[0] if phases else "N/A"
+    
+    def _plot_phase_distribution(self, df: pd.DataFrame):
+        """Create phase distribution visualization"""
+        fig, ax = plt.subplots(figsize=(8, 4))
+        sns.countplot(
+            data=df,
+            x="Phase",
+            order=sorted(df["Phase"].unique()),
+            palette="Blues_d",
+            ax=ax
+        )
+        ax.set_title("Clinical Trial Phases")
+        ax.set_xlabel("")
+        ax.set_ylabel("Number of Trials")
+        st.pyplot(fig)
+    
+    def _render_regulatory_info(self):
+        """Regulatory information section"""
+        st.subheader("Regulatory Intelligence")
+        drug_name = st.text_input("Enter drug name:", "Aspirin")
+        
+        if st.button("Search Regulatory Data"):
+            with st.spinner("Retrieving FDA information..."):
+                fda_data = self.service.get_fda_approval(drug_name)
+                if fda_data:
+                    self._display_fda_info(fda_data)
                 else:
-                    st.error("Canonical SMILES not available for this compound.")
-                st.subheader("Physicochemical Properties")
-                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.error("PubChem details not available for the given compound.")
-
-# ----- Tab 4: Global Regulatory Monitoring -----
-with tabs[3]:
-    st.header("Global Regulatory Monitoring")
-    st.markdown("**Note:** This section focuses on FDA data and PubChem drug details due to API limitations for EMA/WHO/DailyMed.")
-    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 Available"
-            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.")
-
-# ----- Tab 6: Comprehensive Dashboard -----
-with tabs[5]:
-    st.header("Comprehensive Dashboard")
-    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)
-            if rxnorm_id:
-                rx_props = get_rxnorm_properties(rxnorm_id)
-                st.subheader("RxNorm Data")
-                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("PubChem Drug Details")
-            pubchem_info = get_pubchem_drug_details(query_drug)
-            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.")
-            st.subheader("RxClass Information")
-            st.write("RxClass data is currently unavailable via API. Consider alternative sources for drug class information.")
-
-# ----- 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)
+                    st.warning("No FDA data found for this drug")
+    
+    def _display_fda_info(self, data: Dict):
+        """Display FDA approval information"""
+        openfda = data.get("openfda", {})
+        st.markdown(f"""
+            **Brand Name**: {', '.join(openfda.get('brand_name', ['N/A']))}  
+            **Manufacturer**: {', '.join(openfda.get('manufacturer_name', ['N/A']))}  
+            **Approval Date**: {data.get('effective_time', 'N/A')}  
+            **Dosage Form**: {', '.join(openfda.get('dosage_form', ['N/A']))}
+        """)
+        
+        st.subheader("Indications and Usage")
+        st.write(data.get("indications_and_usage", ["No information available"])[0])
 
+# ======================
+# Application Entry
+# ======================
+if __name__ == "__main__":
+    app = PharmaDashboard()
+    app.render()