Update app.py

app.py

@@ -1,3 +1,11 @@
+"""
+Pharma Research Intelligence Suite (PRIS)
+A Next-Generation Platform for AI-Driven Drug Discovery and Development
+"""
+
+# -----------------------------
+# IMPORTS & CONFIGURATION
+# -----------------------------
 import streamlit as st
 import requests
 from rdkit import Chem
@@ -11,619 +19,259 @@ import logging
 import os
 import plotly.graph_objects as go
 import networkx as nx
-from typing import Optional, Dict, List, Any
+from typing import Optional, Dict, List, Any, Tuple
+from openai import OpenAI
 
-# -----------------------------
-# SETUP
-# -----------------------------
-# Must be the very first Streamlit command
-st.set_page_config(page_title="Pharma Research Expert Platform", layout="wide")
-logging.basicConfig(level=logging.ERROR)
+# 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")
 
 # -----------------------------
-# API ENDPOINTS
+# GLOBAL CONSTANTS
 # -----------------------------
 API_ENDPOINTS = {
-    "clinical_trials": "https://clinicaltrials.gov/api/v2/studies",  # no email required
-    "pubchem": "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{}/JSON",
-    "pubmed": "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi",
+    # 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",
-    # PharmGKB endpoints – expecting a PharmGKB accession (e.g., PA1234)
+    
+    # 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/{}",
     "pharmgkb_gene_variants": "https://api.pharmgkb.org/v1/data/gene/{}/variants",
+    
+    # Semantic Medical Resources
     "bioportal_search": "https://data.bioontology.org/search",
-    # RxNorm endpoints
+    
+    # Drug Classification Systems
     "rxnorm_rxcui": "https://rxnav.nlm.nih.gov/REST/rxcui.json",
     "rxnorm_properties": "https://rxnav.nlm.nih.gov/REST/rxcui/{}/properties.json",
-    # RxClass endpoint – note: this endpoint sometimes returns 404 if no data are available.
     "rxclass_by_drug": "https://rxnav.nlm.nih.gov/REST/class/byDrugName.json"
 }
 
-# -----------------------------
-# Retrieve Secrets
-# -----------------------------
-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("PubMed email (PUB_EMAIL) is not configured.")
-if not BIOPORTAL_API_KEY:
-    st.error("BioPortal API key (BIOPORTAL_API_KEY) is not configured.")
-if not OPENFDA_KEY:
-    st.error("OpenFDA API key (OPENFDA_KEY) is not configured.")
-if not OPENAI_API_KEY:
-    st.error("OpenAI API key (OPENAI_API_KEY) is not configured.")
+DEFAULT_HEADERS = {
+    "User-Agent": "PharmaResearchIntelligenceSuite/1.0 (Professional Use)",
+    "Accept": "application/json"
+}
 
 # -----------------------------
-# Initialize OpenAI Client (GPT-4)
+# SECRETS MANAGEMENT
 # -----------------------------
-from openai import OpenAI
-openai_client = OpenAI(api_key=OPENAI_API_KEY)
-
-def generate_content(prompt: str) -> str:
-    """Generate content using GPT-4 via the OpenAI API."""
-    try:
-        completion = openai_client.chat.completions.create(
-            model="gpt-4",
-            messages=[{"role": "user", "content": prompt}],
-            max_tokens=300
-        )
-        return completion.choices[0].message.content.strip()
-    except Exception as e:
-        st.error(f"Error generating content: {e}")
-        logging.error(f"OpenAI generation error: {e}")
-        return "Content generation failed."
+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()
 
 # -----------------------------
-# Utility Functions
+# CORE INFRASTRUCTURE
 # -----------------------------
-def _query_api(endpoint: str, params: Optional[Dict] = None, headers: Optional[Dict] = None) -> Optional[Dict]:
-    """Handles API 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"Error for {endpoint}: {e}")
-    return None
-
-def _get_pubchem_smiles(drug_name: str) -> Optional[str]:
-    """Retrieve canonical SMILES string from 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 None
-
-def _draw_molecule(smiles: str) -> Optional[Any]:
-    """Draw a molecule image using RDKit."""
-    try:
-        mol = Chem.MolFromSmiles(smiles)
-        if mol:
-            return Draw.MolToImage(mol)
-        else:
-            st.error("Invalid SMILES provided.")
-    except Exception as e:
-        st.error(f"Error drawing molecule: {e}")
-        logging.error(e)
-    return None
-
-def _get_pubchem_drug_details(drug_name: str) -> Optional[Dict[str, str]]:
-    """Retrieve drug details (molecular formula, IUPAC name, canonical 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
-
-def _get_clinical_trials(query: str) -> Optional[Dict]:
-    """Query ClinicalTrials.gov (no email parameter needed)."""
-    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)
-
-def _get_pubmed(query: str) -> Optional[Dict]:
-    """Query PubMed using E-utilities."""
-    params = {"db": "pubmed", "term": query, "retmax": 10, "retmode": "json", "email": PUB_EMAIL}
-    return _query_api(API_ENDPOINTS["pubmed"], params)
-
-def _get_fda_approval(drug_name: str) -> Optional[Dict]:
-    """Retrieve FDA drug approval info using openFDA."""
-    if not OPENFDA_KEY:
-        st.error("OpenFDA API 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
-
-def _analyze_adverse_events(drug_name: str, limit: int = 5) -> Optional[Dict]:
-    """Fetch adverse events from FAERS."""
-    if not OPENFDA_KEY:
-        st.error("OpenFDA API 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)
-
-def _get_pharmgkb_clinical_annotations(variant_id: str) -> Optional[Dict]:
-    """Get clinical annotations for a PharmGKB variant."""
-    endpoint = API_ENDPOINTS["pharmgkb_variant_clinical_annotations"].format(variant_id)
-    data = _query_api(endpoint)
-    if data and data.get("data"):
-        return data
-    st.write(f"No clinical annotations found for variant {variant_id}.")
-    return None
-
-def _get_pharmgkb_variants_for_gene(pharmgkb_gene_id: str) -> Optional[List[str]]:
-    """Retrieve variant IDs for a PharmGKB gene accession (e.g., PA1234)."""
-    if not pharmgkb_gene_id.startswith("PA"):
-        st.warning("Please provide a valid PharmGKB 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
-
-def get_pharmgkb_gene_data(pharmgkb_gene_id: str) -> Optional[Dict]:
-    """Retrieve PharmGKB gene data."""
-    if not pharmgkb_gene_id.startswith("PA"):
-        st.warning("Please enter a valid PharmGKB gene accession (e.g., PA1234).")
-        return None
-    endpoint = API_ENDPOINTS["pharmgkb_gene"].format(pharmgkb_gene_id)
-    data = _query_api(endpoint)
-    if data and data.get("data"):
-        return data["data"][0]
-    st.write(f"No data found for PharmGKB gene {pharmgkb_gene_id}.")
-    return None
-
-def _get_bioportal_data(ontology: str, term: str) -> Optional[Dict]:
-    """Query BioPortal for ontology data."""
-    if not BIOPORTAL_API_KEY:
-        st.error("BioPortal API key not configured.")
-        return None
-    if not term:
-        st.error("Please provide a term for ontology search.")
+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
-    headers = {"Authorization": f"apikey token={BIOPORTAL_API_KEY}"}
-    params = {"q": term, "ontologies": ontology}
-    data = _query_api(API_ENDPOINTS["bioportal_search"], params, headers)
-    if data and data.get("collection"):
-        return data
-    st.warning("No BioPortal results found.")
-    return None
-
-def _save_pdf_report(report_content: str, filename: str):
-    """Save report content as a PDF."""
-    try:
-        pdf = FPDF()
-        pdf.add_page()
-        pdf.set_font("Arial", size=12)
-        pdf.multi_cell(0, 10, report_content)
-        pdf.output(filename)
-        return filename
-    except Exception as e:
-        st.error(f"Error saving PDF: {e}")
-        logging.error(e)
-    return None
 
-def _display_dataframe(data: List[Dict[str, Any]], columns: List[str]):
-    """Display a dataframe in Streamlit."""
-    if data:
-        df = pd.DataFrame(data, columns=columns)
-        st.dataframe(df)
-        return df
-    st.warning("No data available.")
-    return None
-
-def _create_variant_network(gene: str, variants: List[str], annotations: Dict) -> go.Figure:
-    """Create a network graph (gene-variant-drug)."""
-    G = nx.Graph()
-    G.add_node(gene, color="lightblue")
-    for variant in variants:
-        G.add_node(variant, color="lightgreen")
-        G.add_edge(gene, variant)
-        for drug in annotations.get(variant, []):
-            if drug and drug != "N/A":
-                G.add_node(drug, color="lightcoral")
-                G.add_edge(variant, drug)
-    pos = nx.spring_layout(G)
-    edge_x, edge_y = [], []
-    for edge in G.edges():
-        x0, y0 = pos[edge[0]]
-        x1, y1 = pos[edge[1]]
-        edge_x.extend([x0, x1, None])
-        edge_y.extend([y0, y1, None])
-    edge_trace = go.Scatter(
-        x=edge_x, y=edge_y, line=dict(width=0.5, color="#888"),
-        hoverinfo="none", mode="lines"
-    )
-    node_x, node_y, node_text, node_color = [], [], [], []
-    for node in G.nodes():
-        x, y = pos[node]
-        node_x.append(x)
-        node_y.append(y)
-        node_text.append(node)
-        node_color.append(G.nodes[node]["color"])
-    node_trace = go.Scatter(
-        x=node_x, y=node_y, mode="markers+text", hoverinfo="text",
-        text=node_text, textposition="bottom center",
-        marker=dict(showscale=False, colorscale="YlGnBu",
-                    color=node_color, size=10, line_width=2)
-    )
-    fig = go.Figure(
-        data=[edge_trace, node_trace],
-        layout=go.Layout(
-            title=dict(text="Gene-Variant-Drug Network", font=dict(size=16)),
-            showlegend=False, hovermode="closest",
-            margin=dict(b=20, l=5, r=5, t=40),
-            xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
-            yaxis=dict(showgrid=False, zeroline=False, showticklabels=False)
+    def get_compound_profile(self, identifier: str) -> Optional[Dict]:
+        """Retrieve comprehensive chemical profile"""
+        pubchem_data = self.api_request(
+            API_ENDPOINTS["pubchem"].format(identifier)
         )
-    )
-    return fig
-
-# -----------------------------
-# RxNorm & RxClass Functions
-# -----------------------------
-def get_rxnorm_rxcui(drug_name: str) -> Optional[str]:
-    """Retrieve the RxCUI for a drug name."""
-    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
-
-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)
-
-def get_rxclass_by_drug_name(drug_name: str) -> Optional[Dict]:
-    """Retrieve RxClass info for a drug by name; gracefully handle if not found."""
-    url = f"{API_ENDPOINTS['rxclass_by_drug']}?drugName={drug_name}"
-    data = _query_api(url)
-    if data and "classMember" in data:
-        return data
-    return None
+        
+        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 prop["value"]["sval"]
+        return "N/A"
 
 # -----------------------------
-# AI-Driven Drug Insights
+# INTELLIGENCE MODULES
 # -----------------------------
-def generate_drug_insights(drug_name: str) -> str:
-    """Gathers data from FDA, PubChem, RxNorm, and RxClass then uses GPT-4 to generate an innovative analysis."""
-    # FDA Data
-    fda_info = _get_fda_approval(drug_name)
-    fda_status = "Not Approved"
-    if fda_info and fda_info.get("openfda", {}).get("brand_name"):
-        fda_status = ", ".join(fda_info["openfda"]["brand_name"])
+class ClinicalIntelligence:
+    """Handles clinical trial and regulatory data analysis"""
     
-    # PubChem Details
-    pubchem_details = _get_pubchem_drug_details(drug_name)
-    if pubchem_details:
-        formula = pubchem_details.get("Molecular Formula", "N/A")
-        iupac = pubchem_details.get("IUPAC Name", "N/A")
-        canonical_smiles = pubchem_details.get("Canonical SMILES", "N/A")
-    else:
-        formula = iupac = canonical_smiles = "Not Available"
+    def __init__(self):
+        self.engine = PharmaResearchEngine()
     
-    # RxNorm Data
-    rxnorm_id = get_rxnorm_rxcui(drug_name)
-    if rxnorm_id:
-        rx_properties = get_rxnorm_properties(rxnorm_id)
-        rxnorm_info = f"RxCUI: {rxnorm_id}. Properties: {rx_properties}"
-    else:
-        rxnorm_info = "No RxNorm data available."
+    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]
+
+class AIDrugInnovator:
+    """GPT-4 powered drug development strategist"""
     
-    # RxClass Data
-    rxclass_data = get_rxclass_by_drug_name(drug_name)
-    rxclass_info = rxclass_data if rxclass_data else "No RxClass data available."
-    
-    # Construct a prompt for GPT-4
-    prompt = (
-        f"Drug Analysis Report for '{drug_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: {canonical_smiles}\n\n"
-        f"**RxNorm Data:** {rxnorm_info}\n\n"
-        f"**RxClass Data:** {rxclass_info}\n\n"
-        f"As an innovative pharmacogenomics researcher and AI expert, please provide a comprehensive analysis of '{drug_name}', "
-        f"including pharmacogenomic considerations, potential repurposing opportunities, regulatory insights, and suggestions for further research. "
-        f"Present your answer in bullet points."
-    )
-    
-    insights = generate_content(prompt)
-    return insights
+    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
+            )
+            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 APP TABS
+# STREAMLIT INTERFACE
 # -----------------------------
-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"])
+class PharmaResearchInterface:
+    """Modern UI for pharmaceutical research platform"""
     
-    if st.button("Generate Development Plan"):
-        with st.spinner("Generating plan..."):
-            plan_prompt = (
-                f"Develop a comprehensive drug development plan for treating {target} using a {strategy} strategy. "
-                "Include sections on target validation, lead optimization, preclinical testing, clinical trial design, "
-                "regulatory submission strategy, market analysis, and competitive landscape. Highlight key milestones and challenges."
-            )
-            plan = generate_content(plan_prompt)
-            st.subheader("Comprehensive Development Plan")
-            st.markdown(plan)
+    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()
         
-        st.subheader("FDA Regulatory Insights")
-        if target:
-            fda_info = _get_fda_approval(target.split()[0])
-            if fda_info:
-                st.json(fda_info)
-            else:
-                st.write("No FDA data found for the given target.")
+    def _render_navigation(self):
+        """Dynamic tab-based navigation system"""
+        tabs = st.tabs([
+            "🚀 Drug Innovation",
+            "📈 Trial Analytics",
+            "🧪 Compound Profiler",
+            "📜 Regulatory Hub",
+            "🤖 AI Strategist"
+        ])
         
-        st.subheader("Pharmacogenomic Considerations")
-        if target_gene:
-            if not target_gene.startswith("PA"):
-                st.warning("Please provide a valid PharmGKB accession (e.g., PA1234).")
-            else:
-                variant_ids = _get_pharmgkb_variants_for_gene(target_gene)
-                if variant_ids:
-                    annotations = {}
-                    for vid in variant_ids[:5]:
-                        pgx = _get_pharmgkb_clinical_annotations(vid)
-                        annotations[vid] = [anno.get("obj2Name", "N/A") for anno in pgx.get("data", [])] if pgx else []
-                        st.write(f"### Annotations for Variant: {vid}")
-                        st.json(pgx if pgx else {"message": "No annotations found."})
-                else:
-                    st.write("No variants found for the specified PharmGKB gene accession.")
-        else:
-            st.write("Enter 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")
-                    })
-                _display_dataframe(trial_data, list(trial_data[0].keys()))
-            else:
-                st.warning("No clinical trials found for the query.")
+        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])
         
-        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: 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..."):
-            if Chem.MolFromSmiles(compound_input):
-                smiles = compound_input
-            else:
-                smiles = _get_pubchem_smiles(compound_input)
-            if smiles:
-                img = _draw_molecule(smiles)
-                if img:
-                    st.image(img, caption="2D Molecular Structure")
-            else:
-                st.error("Structure not found. Please try a more specific compound name.")
-        pubchem_data = _query_api(API_ENDPOINTS["pubchem"].format(compound_input))
-        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}  \n**LogP:** {logp}")
-        else:
-            st.error("Physicochemical properties not available.")
-
-# ----- Tab 4: Regulatory Intelligence -----
-with tabs[3]:
-    st.header("Global Regulatory Monitoring")
-    st.markdown("**Note:** This section now focuses on FDA data and generic drug details from PubChem.")
-    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_info = _get_fda_approval(drug_prod)
-            fda_status = "Not Approved"
-            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(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: Dashboard -----
-with tabs[5]:
-    st.header("Comprehensive Dashboard")
-    # Placeholder KPIs – replace with real-time aggregated data if available
-    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)  # Sample static data
-    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..."):
-            rxnorm_id = get_rxnorm_rxcui(drug_integration)
-            if rxnorm_id:
-                rx_props = get_rxnorm_properties(rxnorm_id)
-            else:
-                rx_props = None
-            rxclass_info = get_rxclass_by_drug_name(drug_integration)
-            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.")
-            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(drug_integration)
-            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.")
+        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 _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")
+        
+        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']}")
 
-# ----- 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 insights..."):
-            insights_text = generate_drug_insights(ai_drug)
-            st.subheader("AI-Driven Drug Analysis")
-            st.markdown(insights_text)
+# -----------------------------
+# MAIN EXECUTION
+# -----------------------------
+if __name__ == "__main__":
+    interface = PharmaResearchInterface()
+    interface.render()