Update app.py

app.py

@@ -1,27 +1,27 @@
 import streamlit as st
 import requests
-from bs4 import BeautifulSoup
+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
-from typing import Optional, Dict, List, Any
 import os
 import plotly.graph_objects as go
 import networkx as nx
+from typing import Optional, Dict, List, Any
 
-# --- IMPORTANT: st.set_page_config MUST be the very first Streamlit command ---
+# -----------------------------
+# SETUP
+# -----------------------------
+# Must be the very first Streamlit command
 st.set_page_config(page_title="Pharma Research Expert Platform", layout="wide")
-
-# Setup logging
 logging.basicConfig(level=logging.ERROR)
 
 # -----------------------------
-# API Endpoints (Centralized Configuration)
+# API ENDPOINTS
 # -----------------------------
 API_ENDPOINTS = {
     "clinical_trials": "https://clinicaltrials.gov/api/v2/studies",  # no email required
@@ -29,7 +29,7 @@ API_ENDPOINTS = {
     "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",
-    # PharmGKB endpoints (expecting a PharmGKB accession, e.g. PA1234)
+    # PharmGKB endpoints – expecting a PharmGKB accession (e.g., PA1234)
     "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",
@@ -37,37 +37,37 @@ API_ENDPOINTS = {
     # RxNorm endpoints
     "rxnorm_rxcui": "https://rxnav.nlm.nih.gov/REST/rxcui.json",
     "rxnorm_properties": "https://rxnav.nlm.nih.gov/REST/rxcui/{}/properties.json",
-    # RxClass endpoint
+    # 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 from st.secrets
-# -----------------------------------
+# -----------------------------
+# 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 in secrets.")
+    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 in secrets.")
+    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 in secrets.")
+    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 in secrets.")
+    st.error("OpenAI API key (OPENAI_API_KEY) is not configured.")
 
-# -----------------------------------
-# Initialize OpenAI Client (Latest SDK, GPT‑4)
-# -----------------------------------
+# -----------------------------
+# Initialize OpenAI Client (GPT-4)
+# -----------------------------
 from openai import OpenAI
-client = OpenAI(api_key=OPENAI_API_KEY)
+openai_client = OpenAI(api_key=OPENAI_API_KEY)
 
 def generate_content(prompt: str) -> str:
-    """Generate content using GPT‑4 via the new OpenAI SDK."""
+    """Generate content using GPT-4 via the OpenAI API."""
     try:
-        completion = client.chat.completions.create(
+        completion = openai_client.chat.completions.create(
             model="gpt-4",
             messages=[{"role": "user", "content": prompt}],
             max_tokens=300
@@ -82,48 +82,41 @@ def generate_content(prompt: str) -> str:
 # Utility Functions
 # -----------------------------
 def _query_api(endpoint: str, params: Optional[Dict] = None, headers: Optional[Dict] = None) -> Optional[Dict]:
-    """Handles API requests with robust error handling."""
+    """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 requests.exceptions.HTTPError as http_err:
-        st.error(f"HTTP error: {http_err} for endpoint {endpoint}.")
-        logging.error(f"HTTP error: {http_err} for endpoint {endpoint}.")
-    except requests.exceptions.RequestException as req_err:
-        st.error(f"Request error: {req_err} for endpoint {endpoint}.")
-        logging.error(f"Request error: {req_err} for endpoint {endpoint}.")
     except Exception as e:
-        st.error(f"Unexpected error: {e} for endpoint {endpoint}.")
-        logging.error(f"Unexpected error: {e} for endpoint {endpoint}.")
+        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]:
-    """Retrieves a drug's SMILES string from PubChem."""
+    """Retrieve canonical SMILES string from PubChem."""
     url = API_ENDPOINTS["pubchem"].format(drug_name)
     data = _query_api(url)
-    if data and "PC_Compounds" in data and len(data["PC_Compounds"]) > 0:
+    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]:
-    """Generates a 2D image of a molecule from its SMILES string."""
+    """Draw a molecule image using RDKit."""
     try:
         mol = Chem.MolFromSmiles(smiles)
         if mol:
             return Draw.MolToImage(mol)
         else:
-            st.error("Invalid SMILES string.")
-            return None
+            st.error("Invalid SMILES provided.")
     except Exception as e:
         st.error(f"Error drawing molecule: {e}")
-        logging.error(f"Molecule drawing error: {e}")
-        return None
+        logging.error(e)
+    return None
 
 def _get_pubchem_drug_details(drug_name: str) -> Optional[Dict[str, str]]:
-    """Retrieves generic drug details (molecular formula, IUPAC name, and canonical SMILES) from PubChem."""
+    """Retrieve drug details (molecular formula, IUPAC name, canonical SMILES) from PubChem."""
     url = API_ENDPOINTS["pubchem"].format(drug_name)
     data = _query_api(url)
     details = {}
@@ -141,7 +134,7 @@ def _get_pubchem_drug_details(drug_name: str) -> Optional[Dict[str, str]]:
     return None
 
 def _get_clinical_trials(query: str) -> Optional[Dict]:
-    """Queries ClinicalTrials.gov using the 'query.term' parameter."""
+    """Query ClinicalTrials.gov (no email parameter needed)."""
     if query.upper().startswith("NCT") and query[3:].isdigit():
         params = {"id": query, "fmt": "json"}
     else:
@@ -149,12 +142,12 @@ def _get_clinical_trials(query: str) -> Optional[Dict]:
     return _query_api(API_ENDPOINTS["clinical_trials"], params)
 
 def _get_pubmed(query: str) -> Optional[Dict]:
-    """Queries PubMed using E-utilities."""
+    """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]:
-    """Retrieves FDA drug label approval info."""
+    """Retrieve FDA drug approval info using openFDA."""
     if not OPENFDA_KEY:
         st.error("OpenFDA API key not configured.")
         return None
@@ -166,7 +159,7 @@ def _get_fda_approval(drug_name: str) -> Optional[Dict]:
     return None
 
 def _analyze_adverse_events(drug_name: str, limit: int = 5) -> Optional[Dict]:
-    """Fetches adverse event reports from FAERS."""
+    """Fetch adverse events from FAERS."""
     if not OPENFDA_KEY:
         st.error("OpenFDA API key not configured.")
         return None
@@ -175,7 +168,7 @@ def _analyze_adverse_events(drug_name: str, limit: int = 5) -> Optional[Dict]:
     return _query_api(API_ENDPOINTS["faers_adverse_events"], params)
 
 def _get_pharmgkb_clinical_annotations(variant_id: str) -> Optional[Dict]:
-    """Fetches clinical annotations for a given variant from PharmGKB."""
+    """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"):
@@ -184,12 +177,9 @@ def _get_pharmgkb_clinical_annotations(variant_id: str) -> Optional[Dict]:
     return None
 
 def _get_pharmgkb_variants_for_gene(pharmgkb_gene_id: str) -> Optional[List[str]]:
-    """
-    Retrieves variant IDs for a gene using its PharmGKB accession.
-    If the accession does not start with "PA", warn the user.
-    """
+    """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 ID (e.g., PA1234).")
+        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)
@@ -199,11 +189,9 @@ def _get_pharmgkb_variants_for_gene(pharmgkb_gene_id: str) -> Optional[List[str]
     return None
 
 def get_pharmgkb_gene_data(pharmgkb_gene_id: str) -> Optional[Dict]:
-    """
-    Retrieves PharmGKB gene data using a PharmGKB accession.
-    """
+    """Retrieve PharmGKB gene data."""
     if not pharmgkb_gene_id.startswith("PA"):
-        st.warning("Please enter a valid PharmGKB gene accession ID (e.g., PA1234).")
+        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)
@@ -213,23 +201,23 @@ def get_pharmgkb_gene_data(pharmgkb_gene_id: str) -> Optional[Dict]:
     return None
 
 def _get_bioportal_data(ontology: str, term: str) -> Optional[Dict]:
-    """Fetches ontology data from BioPortal."""
+    """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 search term for ontology search.")
+        st.error("Please provide a term for ontology search.")
         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 results found for the BioPortal query.")
+    st.warning("No BioPortal results found.")
     return None
 
 def _save_pdf_report(report_content: str, filename: str):
-    """Saves report content as a PDF file."""
+    """Save report content as a PDF."""
     try:
         pdf = FPDF()
         pdf.add_page()
@@ -238,28 +226,28 @@ def _save_pdf_report(report_content: str, filename: str):
         pdf.output(filename)
         return filename
     except Exception as e:
-        st.error(f"Error saving PDF report: {e}")
-        logging.error(f"PDF save error: {e}")
-        return None
+        st.error(f"Error saving PDF: {e}")
+        logging.error(e)
+    return None
 
 def _display_dataframe(data: List[Dict[str, Any]], columns: List[str]):
-    """Displays a DataFrame in Streamlit."""
+    """Display a dataframe in Streamlit."""
     if data:
         df = pd.DataFrame(data, columns=columns)
         st.dataframe(df)
         return df
-    st.warning("No data available for display.")
+    st.warning("No data available.")
     return None
 
 def _create_variant_network(gene: str, variants: List[str], annotations: Dict) -> go.Figure:
-    """Creates an interactive network graph of gene-variant-drug relationships."""
+    """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 != "N/A":
+            if drug and drug != "N/A":
                 G.add_node(drug, color="lightcoral")
                 G.add_edge(variant, drug)
     pos = nx.spring_layout(G)
@@ -270,11 +258,8 @@ def _create_variant_network(gene: str, variants: List[str], annotations: Dict) -
         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"
+        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():
@@ -284,26 +269,16 @@ def _create_variant_network(gene: str, variants: List[str], annotations: Dict) -
         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
-        )
+        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",
+            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)
@@ -312,10 +287,10 @@ def _create_variant_network(gene: str, variants: List[str], annotations: Dict) -
     return fig
 
 # -----------------------------
-# New Functions: RxNorm and RxClass Integration
+# RxNorm & RxClass Functions
 # -----------------------------
 def get_rxnorm_rxcui(drug_name: str) -> Optional[str]:
-    """Retrieves the RxNorm Concept Unique Identifier (RxCUI) for a drug name."""
+    """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"):
@@ -324,20 +299,23 @@ def get_rxnorm_rxcui(drug_name: str) -> Optional[str]:
     return None
 
 def get_rxnorm_properties(rxcui: str) -> Optional[Dict]:
-    """Retrieves RxNorm properties for a given RxCUI."""
+    """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]:
-    """Retrieves RxClass information for a drug by name."""
+    """Retrieve RxClass info for a drug by name; gracefully handle if not found."""
     url = f"{API_ENDPOINTS['rxclass_by_drug']}?drugName={drug_name}"
-    return _query_api(url)
+    data = _query_api(url)
+    if data and "classMember" in data:
+        return data
+    return None
 
 # -----------------------------
-# New Function: Generate AI Insights for a Drug
+# AI-Driven Drug Insights
 # -----------------------------
 def generate_drug_insights(drug_name: str) -> str:
-    """Gathers FDA, PubChem, RxNorm, and RxClass data for a drug and uses GPT‑4 to generate innovative insights."""
+    """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"
@@ -363,12 +341,9 @@ def generate_drug_insights(drug_name: str) -> str:
     
     # RxClass Data
     rxclass_data = get_rxclass_by_drug_name(drug_name)
-    if rxclass_data and rxclass_data.get("classMember"):
-        rxclass_info = f"RxClass: {rxclass_data}"
-    else:
-        rxclass_info = "No RxClass data available."
+    rxclass_info = rxclass_data if rxclass_data else "No RxClass data available."
     
-    # Construct prompt for GPT‑4 with all the gathered data
+    # Construct a prompt for GPT-4
     prompt = (
         f"Drug Analysis Report for '{drug_name}':\n\n"
         f"**FDA Approval Status:** {fda_status}\n\n"
@@ -378,20 +353,16 @@ def generate_drug_insights(drug_name: str) -> str:
         f"  - Canonical SMILES: {canonical_smiles}\n\n"
         f"**RxNorm Data:** {rxnorm_info}\n\n"
         f"**RxClass Data:** {rxclass_info}\n\n"
-        f"As an advanced pharmacogenomics researcher and AI expert, please provide an innovative and comprehensive analysis of "
-        f"the drug '{drug_name}'. In your response, include:\n"
-        f"- Pharmacogenomic considerations\n"
-        f"- Potential repurposing opportunities\n"
-        f"- Regulatory insights and challenges\n"
-        f"- Suggestions for further research and data integration\n\n"
-        f"Present your answer in a clear, bullet-point format and feel free to add any novel ideas."
+        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
 
 # -----------------------------
-# Streamlit App Layout and Tabs
+# STREAMLIT APP TABS
 # -----------------------------
 tabs = st.tabs([
     "💊 Drug Development",
@@ -404,68 +375,54 @@ tabs = st.tabs([
     "🤖 AI Insights"
 ])
 
-# -----------------------------
-# Tab 1: Drug Development
-# -----------------------------
+# ----- 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="Enter PharmGKB accession (e.g., PA1234)")
+    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"])
     
     if st.button("Generate Development Plan"):
         with st.spinner("Generating plan..."):
             plan_prompt = (
-                f"Develop a comprehensive drug development plan for treating {target} "
-                f"using a {strategy} strategy. Include sections on target validation, lead optimization, "
-                f"preclinical testing, clinical trial design, regulatory submission strategy, market analysis, "
-                f"and competitive landscape. Highlight key milestones and challenges."
+                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)
         
-        # FDA Regulatory Insights
+        st.subheader("FDA Regulatory Insights")
         if target:
             fda_info = _get_fda_approval(target.split()[0])
-            st.subheader("FDA Regulatory Insights")
             if fda_info:
                 st.json(fda_info)
             else:
                 st.write("No FDA data found for the given target.")
         
-        # Pharmacogenomic Considerations via PharmGKB
         st.subheader("Pharmacogenomic Considerations")
         if target_gene:
             if not target_gene.startswith("PA"):
-                st.warning("Please provide a valid PharmGKB accession (e.g., PA1234) for the gene.")
+                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 variant_id in variant_ids[:5]:
-                        pgx_data = _get_pharmgkb_clinical_annotations(variant_id)
-                        if pgx_data and pgx_data.get("data"):
-                            annotations[variant_id] = [anno.get("obj2Name", "N/A") for anno in pgx_data["data"]]
-                        else:
-                            annotations[variant_id] = []
-                        st.write(f"### Clinical Annotations for Variant: {variant_id}")
-                        if pgx_data:
-                            st.json(pgx_data)
-                        else:
-                            st.write(f"No annotations for variant {variant_id}.")
+                    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("Please enter a PharmGKB accession for the target gene to retrieve pharmacogenomic data.")
+            st.write("Enter a PharmGKB gene accession to retrieve pharmacogenomic data.")
 
-# -----------------------------
-# Tab 2: Clinical Trial Analytics
-# -----------------------------
+# ----- 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)
@@ -476,15 +433,15 @@ with tabs[1]:
                         "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", "Not Available")
+                        "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 given query.")
+                st.warning("No clinical trials found for the query.")
         
         ae_data = _analyze_adverse_events(trial_query)
         if ae_data and ae_data.get("results"):
-            st.subheader("Adverse Event Profile (Top 5 Reports)")
+            st.subheader("Adverse Event Profile (Top 5)")
             ae_results = ae_data["results"][:5]
             ae_df = pd.json_normalize(ae_results)
             st.dataframe(ae_df)
@@ -503,17 +460,12 @@ with tabs[1]:
         else:
             st.write("No adverse event data available.")
 
-# -----------------------------
-# Tab 3: Molecular Profiling
-# -----------------------------
+# ----- 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..."):
-            smiles = None
-            # If input is a valid SMILES, use it; otherwise attempt to retrieve from PubChem.
             if Chem.MolFromSmiles(compound_input):
                 smiles = compound_input
             else:
@@ -521,10 +473,9 @@ with tabs[2]:
             if smiles:
                 img = _draw_molecule(smiles)
                 if img:
-                    st.image(img, caption="2D Structure")
+                    st.image(img, caption="2D Molecular Structure")
             else:
-                st.error("Compound structure not found in databases. Please provide a more specific compound name.")
-        
+                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")
@@ -535,32 +486,24 @@ with tabs[2]:
         else:
             st.error("Physicochemical properties not available.")
 
-# -----------------------------
-# Tab 4: Regulatory Intelligence
-# -----------------------------
+# ----- Tab 4: Regulatory Intelligence -----
 with tabs[3]:
     st.header("Global Regulatory Monitoring")
-    st.markdown("**Note:** Due to persistent issues with EMA, WHO, and DailyMed APIs, this section now focuses on FDA data and generic drug details from PubChem.")
-    drug_name = st.text_input("Drug Product:", placeholder="Enter generic or brand name")
-    
+    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 Data
-            fda_info = _get_fda_approval(drug_name)
+            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 Drug Details for Generic/Formula Info
-            pubchem_details = _get_pubchem_drug_details(drug_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")
-                canonical_smiles = pubchem_details.get("Canonical SMILES", "N/A")
+                canon_smiles = pubchem_details.get("Canonical SMILES", "N/A")
             else:
-                formula = iupac = canonical_smiles = "Not Available"
-            
-            st.subheader("Regulatory Status & Drug Details")
+                formula = iupac = canon_smiles = "Not Available"
             col1, col2 = st.columns(2)
             with col1:
                 st.markdown("**FDA Status**")
@@ -569,156 +512,119 @@ with tabs[3]:
                 st.markdown("**Drug Details (PubChem)**")
                 st.write(f"**Molecular Formula:** {formula}")
                 st.write(f"**IUPAC Name:** {iupac}")
-                st.write(f"**Canonical SMILES:** {canonical_smiles}")
-            
-            regulatory_content = (
-                f"### Regulatory Report for {drug_name}\n\n"
+                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:** {canonical_smiles}\n"
+                f"**Canonical SMILES:** {canon_smiles}\n"
             )
-            with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp_file:
-                report_file = _save_pdf_report(regulatory_content, tmp_file.name)
-                if report_file:
-                    with open(report_file, "rb") as file:
-                        st.download_button(
-                            label="Download Regulatory Report (PDF)",
-                            data=file,
-                            file_name=f"{drug_name}_regulatory_report.pdf",
-                            mime="application/pdf"
-                        )
-                    os.remove(report_file)
-
-# -----------------------------
-# Tab 5: Literature Search
-# -----------------------------
+            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")
-    search_term = st.text_input("Enter search query for PubMed:", placeholder="e.g., Alzheimer's disease genetics")
+    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_data = _get_pubmed(search_term)
-            if pubmed_data and pubmed_data.get("esearchresult", {}).get("idlist"):
-                idlist = pubmed_data["esearchresult"]["idlist"]
-                st.subheader(f"Found {len(idlist)} PubMed Results")
-                for article_id in idlist:
-                    st.markdown(f"- [PMID: {article_id}](https://pubmed.ncbi.nlm.nih.gov/{article_id}/)")
+            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")
-    ontology_search_term = st.text_input("Enter search query for Ontology:", placeholder="e.g., Alzheimer's disease")
-    ontology_select = st.selectbox("Select Ontology", ["MESH", "NCIT", "GO", "SNOMEDCT"])
+    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_data = _get_bioportal_data(ontology_select, ontology_search_term)
-            if bioportal_data and bioportal_data.get("collection"):
-                st.subheader(f"BioPortal Results for {ontology_select}")
-                for result in bioportal_data["collection"]:
-                    label = result.get("prefLabel", "N/A")
-                    ontology_id = result.get("@id", "N/A")
-                    st.markdown(f"- **{label}** ({ontology_id})")
+            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
-# -----------------------------
+# ----- Tab 6: Dashboard -----
 with tabs[5]:
     st.header("Comprehensive Dashboard")
-    
-    # Placeholder KPI counts (replace with real aggregated data if available)
-    fda_count = 5000       # Example value
-    trials_count = 12000   # Example value
-    pub_count = 250000     # Example value
-    
-    def _create_kpi_dashboard(fda: int, trials: int, pubs: int):
-        col1, col2, col3 = st.columns(3)
-        col1.metric("FDA Approved Drugs", fda)
-        col2.metric("Ongoing Trials", trials)
-        col3.metric("Publications", pubs)
-    
-    _create_kpi_dashboard(fda_count, trials_count, pub_count)
-    
+    # 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_per_year = [fda_count // len(years)] * len(years)  # Placeholder example data
-    fig, ax = plt.subplots(figsize=(10, 6))
-    sns.lineplot(x=years, y=approvals_per_year, marker="o", ax=ax)
-    ax.set_title("FDA Approvals Over Time")
-    ax.set_xlabel("Year")
-    ax.set_ylabel("Number of Approvals")
-    st.pyplot(fig)
-    
+    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_annotations = {
-        "rs4244285": ["Clopidogrel", "Omeprazole"],
-        "rs12248560": ["Sertraline"]
-    }
+    sample_annots = {"rs4244285": ["Clopidogrel", "Omeprazole"], "rs12248560": ["Sertraline"]}
     try:
-        network_fig = _create_variant_network(sample_gene, sample_variants, sample_annotations)
-        st.plotly_chart(network_fig, use_container_width=True)
+        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"Error generating network graph: {e}")
+        st.error(f"Network graph error: {e}")
 
-# -----------------------------
-# Tab 7: Drug Data Integration
-# -----------------------------
+# ----- Tab 7: Drug Data Integration -----
 with tabs[6]:
     st.header("🧪 Drug Data Integration")
-    drug_query = st.text_input("Enter Drug Name for API Integration:", placeholder="e.g., aspirin")
-    
+    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..."):
-            # RxNorm – Get RxCUI and then properties
-            rxnorm_id = get_rxnorm_rxcui(drug_query)
+        with st.spinner("Fetching drug data..."):
+            rxnorm_id = get_rxnorm_rxcui(drug_integration)
             if rxnorm_id:
-                rx_properties = get_rxnorm_properties(rxnorm_id)
+                rx_props = get_rxnorm_properties(rxnorm_id)
             else:
-                rx_properties = None
-            
-            # RxClass – Get classes related to the drug
-            rxclass_data = get_rxclass_by_drug_name(drug_query)
-            
+                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_query}: {rxnorm_id}")
-                if rx_properties:
-                    st.json(rx_properties)
-                else:
-                    st.write("No RxNorm properties found.")
+                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.write("No RxCUI found.")
             st.subheader("RxClass Information")
-            if rxclass_data and rxclass_data.get("classMember"):
-                st.json(rxclass_data)
+            if rxclass_info:
+                st.json(rxclass_info)
             else:
                 st.write("No RxClass data found for the given drug.")
-            
-            # PubChem Drug Details for generic information
-            pubchem_details = _get_pubchem_drug_details(drug_query)
+            pubchem_info = _get_pubchem_drug_details(drug_integration)
             st.subheader("PubChem Drug Details")
-            if pubchem_details:
-                st.write(f"**Molecular Formula:** {pubchem_details.get('Molecular Formula', 'N/A')}")
-                st.write(f"**IUPAC Name:** {pubchem_details.get('IUPAC Name', 'N/A')}")
-                st.write(f"**Canonical SMILES:** {pubchem_details.get('Canonical SMILES', 'N/A')}")
+            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 for the given drug.")
+                st.write("No PubChem details found.")
 
-# -----------------------------
-# Tab 8: AI Insights
-# -----------------------------
+# ----- Tab 8: AI Insights -----
 with tabs[7]:
     st.header("🤖 AI Insights")
-    ai_drug_query = st.text_input("Enter Drug Name for AI-Driven Analysis:", placeholder="e.g., aspirin")
+    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 insights..."):
-            insights = generate_drug_insights(ai_drug_query)
+        with st.spinner("Generating insights..."):
+            insights_text = generate_drug_insights(ai_drug)
             st.subheader("AI-Driven Drug Analysis")
-            st.markdown(insights)
-
+            st.markdown(insights_text)