Update app.py

app.py

@@ -6,7 +6,7 @@ from fpdf import FPDF
 import tempfile
 import time
 import requests
-import xml.etree.ElementTree as ET
+from bs4 import BeautifulSoup
 import json
 import pandas as pd
 import matplotlib.pyplot as plt
@@ -14,108 +14,106 @@ import seaborn as sns
 from typing import Optional, Dict, List, Any
 import os
 import logging
+from transformers import pipeline
 
 # Setup logging
-logging.basicConfig(level=logging.ERROR) #Log only errors
+logging.basicConfig(level=logging.ERROR)  # Log only errors
 
 # API Endpoints (Centralized Configuration)
 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",
+    "pubmed": "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi",
     "who_drugs": "https://health-products.canada.ca/api/drug/product",
-    #"ema_reports": "https://www.ema.europa.eu/api/search/medicines", #Removed due to 403
-    "fda_drug_approval": "https://api.fda.gov/drug/label.json", # Updated this to use base API
-    "faers_adverse_events": "https://api.fda.gov/drug/event.json", # Updated this to use base API
-    "pharmgkb": "https://api.pharmgkb.org/v1/data/variant/{}/clinicalAnnotations",
-     "bioportal": "https://data.bioontology.org/ontologies"
+    "fda_drug_approval": "https://api.fda.gov/drug/label.json",
+    "faers_adverse_events": "https://api.fda.gov/drug/event.json",
+    "pharmgkb_variant_clinical_annotations": "https://api.pharmgkb.org/v1/data/variant/{}/clinicalAnnotations",
+    "pharmgkb_gene_variants": "https://api.pharmgkb.org/v1/data/gene/{}/variants",
+    "bioportal_search": "https://data.bioontology.org/search",
+    "dailymed": "https://dailymed.nlm.nih.gov/dailymed/services/v2/spls.json",
+    "drugbank": "https://go.drugbank.com/unearth/q?utf8=%E2%9C%93&searcher=drugs&query={}",
 }
 
-#Email addresses
-#Email addresses
-if "PUB_EMAIL" in st.secrets:
-    PUBMED_EMAIL = st.secrets["PUB_EMAIL"]
-else:
-    PUBMED_EMAIL = None
-    st.error("PubMed email not found in secrets. Please add the PUB_EMAIL to secrets.")
+# Email addresses and API Keys
+PUBMED_EMAIL = st.secrets.get("PUB_EMAIL")
 CLINICALTRIALS_EMAIL = PUBMED_EMAIL
 
-# Retrieve the BioPortal API Key from secrets
-if "BIOPORTAL_API_KEY" in st.secrets:
-    BIOPORTAL_API_KEY = st.secrets["BIOPORTAL_API_KEY"]
-else:
-    BIOPORTAL_API_KEY = None
-    st.error("BioPortal API key not found in secrets. Please add the BIOPORTAL_API_KEY to secrets.")
-
-# Retrieve the OpenFDA API Key from secrets
-if "OPENFDA_KEY" in st.secrets:
-    OPENFDA_KEY = st.secrets["OPENFDA_KEY"]
-else:
-    OPENFDA_KEY = None
-    st.error("OpenFDA API key not found in secrets. Please add the OPENFDA_KEY to secrets.")
-    
+BIOPORTAL_API_KEY = st.secrets.get("BIOPORTAL_API_KEY")
+SEMANTIC_SCHOLAR_API_KEY = st.secrets.get("SEMANTIC_SCHOLAR_API_KEY")
+OPENFDA_KEY = st.secrets.get("OPENFDA_KEY")
+
+# Check for essential secrets
+if not PUBMED_EMAIL:
+    st.error("PubMed email not found in secrets. Please add PUB_EMAIL to secrets.")
+if not BIOPORTAL_API_KEY:
+    st.error("BioPortal API key not found in secrets. Please add BIOPORTAL_API_KEY to secrets.")
+if not OPENFDA_KEY:
+    st.error("OpenFDA API key not found in secrets. Please add OPENFDA_KEY to secrets.")
+if not SEMANTIC_SCHOLAR_API_KEY:
+    st.warning("Semantic Scholar API key not found. Some features may be unavailable.")
+
 # Initialize AI Agent (Context-aware)
 content_agent = CodeAgent(tools=[DuckDuckGoSearchTool()], model=HfApiModel())
 
 # --- Utility Functions ---
-def _query_api(endpoint: str, params: Optional[Dict] = None) -> Optional[Dict]:
+def _query_api(endpoint: str, params: Optional[Dict] = None, headers: Optional[Dict] = None) -> Optional[Dict]:
     """Handles API requests with robust error handling."""
     try:
-        response = requests.get(endpoint, params=params, timeout=15)
+        response = requests.get(endpoint, params=params, headers=headers, timeout=15)
         response.raise_for_status()  # Raise HTTPError for bad responses (4xx or 5xx)
         return response.json()
-    except requests.exceptions.RequestException as e:
-        st.error(f"API request failed: {e} for endpoint {endpoint}. Please check connectivity and the endpoint.")
-        logging.error(f"API request failed: {e} for endpoint {endpoint}.")
-        return None
+    except requests.exceptions.HTTPError as http_err:
+        st.error(f"HTTP error occurred: {http_err} for endpoint {endpoint}.")
+        logging.error(f"HTTP error occurred: {http_err} for endpoint {endpoint}.")
+    except requests.exceptions.RequestException as req_err:
+        st.error(f"Request exception: {req_err} for endpoint {endpoint}.")
+        logging.error(f"Request exception: {req_err} for endpoint {endpoint}.")
+    except Exception as e:
+        st.error(f"An unexpected error occurred: {e} for endpoint {endpoint}.")
+        logging.error(f"Unexpected error: {e} for endpoint {endpoint}.")
+    return None
 
-def _query_pubmed(query: str, email: Optional[str] = PUBMED_EMAIL) -> Optional[Dict]:
-    """Queries PubMed with robust error handling."""
-    if not email:
-        st.error("PubMed email not configured.")
-        return None
-    
-    params = {
-        "db": "pubmed",
-        "term": query,
-        "retmax": 10,
-        "retmode": "json",
-        "email": email
-    }
-    data = _query_api(API_ENDPOINTS["pubmed"], params)
-    if data and 'esearchresult' in data:
-         return data
+def _get_pharmgkb_clinical_annotations(variant_id: str) -> Optional[Dict]:
+    """Fetches clinical annotations for a given variant from PharmGKB."""
+    endpoint = API_ENDPOINTS["pharmgkb_variant_clinical_annotations"].format(variant_id)
+    data = _query_api(endpoint)
+    if data and 'data' in data:
+        return data
     else:
+        st.write(f"No relevant pharmacogenomic data found for variant {variant_id}.")
         return None
 
-def _safe_get(endpoint: str, params: Optional[Dict] = None):
-    """Safely fetches data from an API."""
-    try:
-        response = requests.get(endpoint, params=params)
-        response.raise_for_status()  # Raises HTTPError for bad responses
-        return response.json()
-    except requests.exceptions.HTTPError as http_err:
-        st.error(f"HTTP error occurred: {http_err}")
-        logging.error(f"HTTP error occurred: {http_err}")
-        return None
-    except Exception as err:
-        st.error(f"Other error occurred: {err}")
-        logging.error(f"Other error occurred: {err}")
-        return None
+def _get_pharmgkb_variants_for_gene(gene_symbol: str) -> Optional[List[str]]:
+    """Retrieves variant IDs associated with a given gene from PharmGKB."""
+    # First, get the PharmGKB gene ID from the gene symbol
+    gene_search_endpoint = "https://api.pharmgkb.org/v1/data/gene"
+    params = {
+        "name": gene_symbol
+    }
+    gene_data = _query_api(gene_search_endpoint, params)
+    if gene_data and 'data' in gene_data and len(gene_data['data']) > 0:
+        gene_id = gene_data['data'][0]['id']
+        # Now, retrieve variants for this gene
+        variants_endpoint = API_ENDPOINTS["pharmgkb_gene_variants"].format(gene_id)
+        variants_data = _query_api(variants_endpoint)
+        if variants_data and 'data' in variants_data:
+            variant_ids = [variant['id'] for variant in variants_data['data']]
+            return variant_ids
+    st.warning(f"No variants found for gene: {gene_symbol}")
+    return None
 
 def _get_pubchem_smiles(drug_name: str) -> Optional[str]:
     """Retrieves SMILES from PubChem, returns None on failure."""
     url = API_ENDPOINTS["pubchem"].format(drug_name)
     data = _query_api(url)
-    if data and 'PC_Compounds' in data and data['PC_Compounds'][0]['props']:
-        #Check if props exists and find SMILES value
-        for prop in data['PC_Compounds'][0]['props']:
+    if data and 'PC_Compounds' in data and len(data['PC_Compounds']) > 0:
+        # Check if 'props' exists and find SMILES value
+        for prop in data['PC_Compounds'][0].get('props', []):
             if 'name' in prop and prop['name'] == 'Canonical SMILES':
                 return prop['value']['sval']
     return None
 
-
-def _draw_molecule(smiles: str) -> Optional[any]:
+def _draw_molecule(smiles: str) -> Optional[Any]:
     """Generates a 2D molecule image from SMILES."""
     try:
         mol = Chem.MolFromSmiles(smiles)
@@ -130,8 +128,7 @@ def _draw_molecule(smiles: str) -> Optional[any]:
         logging.error(f"Error generating molecule image: {str(e)}")
         return None
 
-
-def _get_clinical_trials(query: str, email:Optional[str] = CLINICALTRIALS_EMAIL) -> Optional[Dict]:
+def _get_clinical_trials(query: str, email: Optional[str] = CLINICALTRIALS_EMAIL) -> Optional[Dict]:
     """Queries clinicaltrials.gov with search term."""
     if not email:
         st.error("Clinical Trials email not configured.")
@@ -143,97 +140,298 @@ def _get_clinical_trials(query: str, email:Optional[str] = CLINICALTRIALS_EMAIL)
         }
     else:
         params = {
-            "query.term": query,
-            "fmt": "json",
-             "email": email
+            "term": query,
+            "retmax": 10,
+            "retmode": "json",
+            "email": email
         }
     return _query_api(API_ENDPOINTS["clinical_trials"], params)
 
-
-def _get_fda_approval(drug_name: str, api_key:Optional[str] = OPENFDA_KEY) -> Optional[Dict]:
+def _get_fda_approval(drug_name: str, api_key: Optional[str] = OPENFDA_KEY) -> Optional[Dict]:
     """Retrieves FDA approval info."""
     if not api_key:
-         st.error("OpenFDA key not configured.")
-         return None
-    url = f"{API_ENDPOINTS['fda_drug_approval']}?api_key={api_key}&search=openfda.brand_name:\"{drug_name}\""
-    data = _query_api(url)
-    if data and 'results' in data and data['results']:
+        st.error("OpenFDA key not configured.")
+        return None
+    query = f'openfda.brand_name:"{drug_name}"'
+    params = {
+        "api_key": api_key,
+        "search": query,
+        "limit": 1
+    }
+    data = _query_api(API_ENDPOINTS["fda_drug_approval"], params)
+    if data and 'results' in data and len(data['results']) > 0:
         return data['results'][0]
     else:
-      return None
+        return None
 
-def _analyze_adverse_events(drug_name: str, api_key:Optional[str] = OPENFDA_KEY, limit: int = 5) -> Optional[Dict]:
+def _analyze_adverse_events(drug_name: str, api_key: Optional[str] = OPENFDA_KEY, limit: int = 5) -> Optional[Dict]:
     """Fetches and analyzes adverse event reports from FAERS."""
     if not api_key:
         st.error("OpenFDA key not configured.")
         return None
-    url = f"{API_ENDPOINTS['faers_adverse_events']}?api_key={api_key}&search=patient.drug.medicinalproduct:\"{drug_name}\"&limit={limit}"
-    data = _query_api(url)
+    query = f'patient.drug.medicinalproduct:"{drug_name}"'
+    params = {
+        "api_key": api_key,
+        "search": query,
+        "limit": limit
+    }
+    data = _query_api(API_ENDPOINTS["faers_adverse_events"], params)
     if data and 'results' in data:
         return data
     else:
         return None
 
+def scrape_ema_drug_info(drug_name: str) -> Optional[Dict]:
+    """
+    Scrapes EMA website for drug information based on the drug name.
+    """
+    try:
+        # Construct the search URL
+        search_url = f"https://www.ema.europa.eu/en/search?text={drug_name.replace(' ', '+')}&type=Product"
+        
+        # Fetch the search results page
+        response = requests.get(search_url, timeout=10)
+        response.raise_for_status()
+        
+        # Parse the HTML content
+        soup = BeautifulSoup(response.text, 'html.parser')
+        
+        # Find the first search result link
+        result = soup.find('a', class_='search-result__title')
+        if not result:
+            st.warning(f"No EMA data found for '{drug_name}'.")
+            return None
+        
+        # Extract the href attribute for the drug's EMA page
+        drug_page_url = "https://www.ema.europa.eu" + result.get('href')
+        
+        # Fetch the drug's EMA page
+        drug_response = requests.get(drug_page_url, timeout=10)
+        drug_response.raise_for_status()
+        
+        drug_soup = BeautifulSoup(drug_response.text, 'html.parser')
+        
+        # Extract relevant information (e.g., approval status, indications)
+        approval_status = drug_soup.find('span', class_='product-status').get_text(strip=True) if drug_soup.find('span', class_='product-status') else "Not Available"
+        indications = drug_soup.find('div', class_='indications').get_text(strip=True) if drug_soup.find('div', class_='indications') else "Not Available"
+        
+        return {
+            "Drug Name": drug_name,
+            "EMA Approval Status": approval_status,
+            "Indications": indications,
+            "EMA Drug Page": drug_page_url
+        }
+    
+    except requests.exceptions.HTTPError as http_err:
+        st.error(f"HTTP error occurred while scraping EMA: {http_err}")
+        logging.error(f"HTTP error: {http_err}")
+    except Exception as e:
+        st.error(f"An error occurred while scraping EMA: {e}")
+        logging.error(f"Scraping error: {e}")
+    
+    return None
 
-def _get_pharmgkb_data(gene:str) -> Optional[Dict]:
-    """Fetches pharmacogenomic data from PharmGKB."""
-    url = f"https://api.pharmgkb.org/v1/data/variant/{gene}/clinicalAnnotations"
-    data = _query_api(url)
-    if data and 'clinicalAnnotations' in data:
-         return data
-    else:
-         return None
+def _get_dailymed_label(drug_name: str) -> Optional[Dict]:
+    """Retrieves drug label information from DailyMed."""
+    try:
+        base_url = API_ENDPOINTS["dailymed"]
+        params = {
+            "drug_name": drug_name,
+            "page": 1,
+            "pagesize": 1
+        }
+        data = _query_api(base_url, params)
+        if data and 'data' in data and len(data['data']) > 0:
+            label_url = data['data'][0]['url']
+            return {"Label URL": label_url}
+        else:
+            st.warning(f"No DailyMed label found for '{drug_name}'.")
+            return None
+    except Exception as e:
+        st.error(f"Error fetching DailyMed data: {e}")
+        logging.error(f"DailyMed error: {e}")
+        return None
 
 def _get_bioportal_data(ontology: str, term: str) -> Optional[Dict]:
     """Fetches data from BioPortal."""
     if not BIOPORTAL_API_KEY:
-      st.error("BioPortal API key not found. Please add the BIOPORTAL_API_KEY to secrets.")
-      return None
+        st.error("BioPortal API key not found. Please add the BIOPORTAL_API_KEY to secrets.")
+        return None
     if not term:
-      st.error("Please provide a search term.")
-      return None
+        st.error("Please provide a search term.")
+        return None
     
     headers = {
         "Authorization": f"apikey token={BIOPORTAL_API_KEY}"
-        }
+    }
     params = {
         "q": term,
         "ontologies": ontology
     }
 
-    url = f"{API_ENDPOINTS['bioportal']}/search"
+    endpoint = API_ENDPOINTS["bioportal_search"]
     try:
-        response = requests.get(url, headers=headers, params=params, timeout=15)
-        response.raise_for_status()
-        data = response.json()
+        data = _query_api(endpoint, params, headers)
         if data and 'collection' in data:
             return data
         else:
             st.warning("No results found for the BioPortal query.")
             return None
-    except requests.exceptions.RequestException as e:
+    except Exception as e:
         st.error(f"BioPortal API request failed: {e} Please check connectivity and ensure you have the correct API Key.")
         logging.error(f"BioPortal API request failed: {e}")
         return None
+
+def _get_semantic_scholar_papers(query: str, limit: int = 5) -> Optional[List[Dict]]:
+    """Fetches papers from Semantic Scholar based on the search query."""
+    try:
+        headers = {
+            "x-api-key": SEMANTIC_SCHOLAR_API_KEY
+        }
+        if not headers["x-api-key"]:
+            st.warning("Semantic Scholar API key not found. Please add it to secrets.")
+            return None
+        base_url = "https://api.semanticscholar.org/graph/v1/paper/search"
+        params = {
+            "query": query,
+            "limit": limit,
+            "fields": "title,authors,year,abstract,url"
+        }
+        data = _query_api(base_url, params, headers)
+        if data and 'data' in data:
+            return data['data']
+        else:
+            st.warning("No papers found for the given query.")
+            return None
+    except Exception as e:
+        st.error(f"Error fetching Semantic Scholar data: {e}")
+        logging.error(f"Semantic Scholar error: {e}")
+        return None
+
+def _get_pharmvar_haplotypes(gene_symbol: str) -> Optional[List[Dict]]:
+    """Fetches haplotype information from PharmVar for a given gene."""
+    try:
+        base_url = f"https://api.pharmvar.org/v1/gene/{gene_symbol}/haplotypes"
+        data = _query_api(base_url)
+        if data and 'data' in data:
+            return data['data']
+        else:
+            st.warning(f"No haplotype data found for gene '{gene_symbol}'.")
+            return None
+    except Exception as e:
+        st.error(f"Error fetching PharmVar data: {e}")
+        logging.error(f"PharmVar error: {e}")
+        return None
+
+def _create_variant_network(gene: str, variants: List[str], annotations: Dict):
+    """Creates an interactive network graph of gene-variant-drug relationships."""
+    import networkx as nx
+    import plotly.graph_objects as go
+    
+    G = nx.Graph()
+    G.add_node(gene, color='lightblue')
+    for variant in variants:
+        G.add_node(variant, color='lightgreen')
+        G.add_edge(gene, variant)
+        # Add connected drugs from annotations
+        for drug in annotations.get(variant, []):
+            if 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='<br>Gene-Variant-Drug Network',
+                    titlefont_size=16,
+                    showlegend=False,
+                    hovermode='closest',
+                    margin=dict(b=20,l=5,r=5,t=40),
+                    annotations=[ dict(
+                        text="Network visualization of gene-variant-drug relationships",
+                        showarrow=False,
+                        xref="paper", yref="paper",
+                        x=0.005, y=-0.002 ) ],
+                    xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+                    yaxis=dict(showgrid=False, zeroline=False, showticklabels=False))
+                 )
+    return fig
+
+def _summarize_abstract(abstract: str) -> str:
+    """Generates a summary of the given abstract using a pre-trained model."""
+    try:
+        summarizer = pipeline("summarization")
+        summary = summarizer(abstract, max_length=130, min_length=30, do_sample=False)
+        return summary[0]['summary_text']
+    except Exception as e:
+        st.error(f"Error summarizing abstract: {e}")
+        logging.error(f"NLP Summarization Error: {e}")
+        return "Summary not available."
+
 def _save_pdf_report(report_content: str, filename: str):
     """Saves content to a PDF file."""
-    pdf = FPDF()
-    pdf.add_page()
-    pdf.set_font("Arial", size=12)
-    pdf.multi_cell(0, 10, report_content)
-    pdf.output(filename)
-    return filename
-
-def _display_dataframe(data: list, columns: list):
+    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 report: {e}")
+        logging.error(f"Error saving PDF report: {e}")
+        return None
+
+def _display_dataframe(data: List[Dict[str, Any]], columns: List[str]):
     """Displays data in a dataframe format."""
     if data:
         df = pd.DataFrame(data, columns=columns)
         st.dataframe(df)
         return df
     else:
-         st.warning("No data found for dataframe creation.")
-         return None
+        st.warning("No data found for dataframe creation.")
+        return None
 
 # --- Streamlit App Configuration ---
 st.set_page_config(page_title="Pharma Research Expert Platform", layout="wide")
@@ -241,7 +439,7 @@ st.title("🔬 Pharma Research Expert Platform")
 st.markdown("An integrated platform for drug discovery, clinical research, and regulatory affairs.")
 
 # --- Tabs ---
-tabs = st.tabs(["💊 Drug Development", "📊 Trial Analytics", "🧬 Molecular Profiling", "📜 Regulatory Intelligence", "📚 Literature Search"])
+tabs = st.tabs(["💊 Drug Development", "📊 Trial Analytics", "🧬 Molecular Profiling", "📜 Regulatory Intelligence", "📚 Literature Search", "📈 Dashboard"])
 
 # --- Tab 1: Drug Development ---
 with tabs[0]:
@@ -254,7 +452,7 @@ with tabs[0]:
         with st.spinner("Analyzing target and competitive landscape..."):
             # AI-generated content with regulatory checks
             plan_prompt = f"""Develop a comprehensive drug development plan for the treatment of {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 potential challenges. """
+            Include sections on target validation, lead optimization, preclinical testing, clinical trial design, regulatory submission strategy, market analysis, and competitive landscape. Highlight key milestones and potential challenges."""
             plan = content_agent.run(plan_prompt)
             
             st.subheader("Comprehensive Development Plan")
@@ -270,16 +468,48 @@ with tabs[0]:
                 else:
                     st.write("No relevant FDA data found.")
             else:
-                st.write("Please enter a target to get relevant FDA data")
+                st.write("Please enter a target to get relevant FDA data.")
         
             # Pharmacogenomic integration
             st.subheader("Pharmacogenomic Considerations")
-            pgx_data = _get_pharmgkb_data(target_gene)
-            if pgx_data:
-                st.write(pgx_data)
+            if target_gene:
+                variant_ids = _get_pharmgkb_variants_for_gene(target_gene)
+                if variant_ids:
+                    annotations = {}
+                    for variant_id in variant_ids[:5]:  # Limit to first 5 variants for brevity
+                        pgx_data = _get_pharmgkb_clinical_annotations(variant_id)
+                        if pgx_data and 'data' in pgx_data:
+                            annotations[variant_id] = [annotation.get('obj2Name', 'N/A') for annotation in pgx_data['data']]
+                        else:
+                            annotations[variant_id] = []
+                    
+                    # Display annotations
+                    for variant_id in variant_ids[:5]:
+                        st.write(f"### Clinical Annotations for Variant: {variant_id}")
+                        pgx_data = _get_pharmgkb_clinical_annotations(variant_id)
+                        if pgx_data and 'data' in pgx_data:
+                            for annotation in pgx_data['data']:
+                                drug = annotation.get('obj2Name', 'N/A')
+                                if drug != 'N/A':
+                                    st.write(f"- **Drug:** {drug}")
+                        else:
+                            st.write(f"No clinical annotations found for variant {variant_id}.")
+                    
+                    # Fetch PharmVar haplotypes
+                    haplotypes = _get_pharmvar_haplotypes(target_gene)
+                    if haplotypes:
+                        st.subheader("PharmVar Haplotypes")
+                        for hap in haplotypes:
+                            st.write(f"- **Haplotype:** {hap.get('name', 'N/A')}")
+                            st.write(f"  - **Variant IDs:** {', '.join(hap.get('variantIds', []))}")
+                    
+                    # Display variant network
+                    fig = _create_variant_network(target_gene, variant_ids[:5], annotations)
+                    st.plotly_chart(fig, use_container_width=True)
+                else:
+                    st.write("No variants found for the specified gene.")
             else:
-                st.write("No relevant pharmacogenomic data found.")
-
+                st.write("Please enter a target gene to retrieve pharmacogenomic data.")
 
 # --- Tab 2: Clinical Trial Analytics ---
 with tabs[1]:
@@ -289,17 +519,16 @@ with tabs[1]:
     if st.button("Analyze Trial Landscape"):
         with st.spinner("Aggregating global trial data..."):
             trials = _get_clinical_trials(trial_query)
-            if trials and trials['studies']:
+            if trials and 'studies' in trials and len(trials['studies']) > 0:
                 st.subheader("Recent Clinical Trials")
                 trial_data = []
                 for study in trials['studies'][:5]:
-                   
                     trial_data.append({
-                        "Title": study['briefTitle'],
-                         "Status": study['overallStatus'],
-                         "Phase": study['phase'] if 'phase' in study else 'Not Available',
-                         "Enrollment": study['enrollmentCount'] if 'enrollmentCount' in study else 'Not Available'
-                   })
+                        "Title": study.get('briefTitle', 'N/A'),
+                        "Status": study.get('overallStatus', 'N/A'),
+                        "Phase": study.get('phase', 'Not Available'),
+                        "Enrollment": study.get('enrollmentCount', 'Not Available')
+                    })
                 
                 trial_df = _display_dataframe(trial_data, list(trial_data[0].keys())) if trial_data else None
 
@@ -307,51 +536,38 @@ with tabs[1]:
                     st.markdown("### Clinical Trial Summary (First 5 trials)")
                     st.dataframe(trial_df)
 
-
                     # Adverse events analysis
                     ae_data = _analyze_adverse_events(trial_query)
-                    if ae_data and ae_data['results']:
+                    if ae_data and 'results' in ae_data and len(ae_data['results']) > 0:
                         st.subheader("Adverse Event Profile (Top 5 Reports)")
                         
                         ae_results = ae_data['results'][:5]
-                        ae_df = pd.DataFrame(ae_results)
+                        ae_df = pd.json_normalize(ae_results)
                         st.dataframe(ae_df)
                         
-                        #Visualization of adverse events
-                        if 'patient' in ae_df and not ae_df.empty:
+                        # Visualization of adverse events
+                        if 'patient.reaction.reactionmeddrapt' in ae_df.columns and not ae_df.empty:
                             try:
-                                drug_events = []
-                                for patient in ae_df['patient']:
-                                    if isinstance(patient,dict) and 'drug' in patient:
-                                        for drug in patient['drug']:
-                                            if isinstance(drug,dict) and 'medicinalproduct' in drug and 'reaction' in patient:
-                                                reactions = [reaction.get('reactionmeddrapt','') for reaction in patient['reaction']]
-                                                for r in reactions:
-                                                    drug_events.append((drug.get('medicinalproduct', 'N/A'), r))
-                                    
-                                df_drug_events = pd.DataFrame(drug_events,columns=['Drug', 'Reaction'])
-                                # Aggregate and Visualize top reactions
-                                if not df_drug_events.empty:
-                                    top_reactions = df_drug_events['Reaction'].value_counts().nlargest(10)
-
-                                    fig, ax = plt.subplots(figsize=(10,6))
-                                    sns.barplot(x=top_reactions.index, y=top_reactions.values, ax=ax)
-                                    ax.set_xticklabels(ax.get_xticklabels(), rotation=45, ha="right")
-                                    plt.title('Top Adverse Reactions')
-                                    plt.xlabel('Adverse Reaction')
-                                    plt.ylabel('Frequency')
-                                    st.pyplot(fig)
-
-                                    #Display as dataframe
-                                    st.markdown("### Top 10 Adverse Reaction Summary")
-                                    st.dataframe(pd.DataFrame({'Reaction': top_reactions.index, 'Frequency': top_reactions.values}))
-
+                                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)
+                                plt.title('Top Adverse Reactions')
+                                plt.xlabel('Frequency')
+                                plt.ylabel('Adverse Reaction')
+                                st.pyplot(fig)
+
+                                # Display as dataframe
+                                st.markdown("### Top 10 Adverse Reaction Summary")
+                                st.dataframe(pd.DataFrame({'Reaction': top_reactions.index, 'Frequency': top_reactions.values}))
                             except Exception as e:
                                 st.error(f"Error processing adverse events data: {e}")
+                    else:
+                        st.write("No adverse event data found.")
             else:
                 st.warning("No clinical trials found for the given search term.")
 
-
 # --- Tab 3: Molecular Profiling ---
 with tabs[2]:
     st.header("Advanced Molecular Profiling")
@@ -360,8 +576,12 @@ with tabs[2]:
     
     if st.button("Analyze Compound"):
         with st.spinner("Querying global databases..."):
-            # SMILES resolution
-            smiles = compound_input if Chem.MolFromSmiles(compound_input) else _get_pubchem_smiles(compound_input)
+            # Determine if input is a SMILES string
+            smiles = None
+            if Chem.MolFromSmiles(compound_input):
+                smiles = compound_input
+            else:
+                smiles = _get_pubchem_smiles(compound_input)
             
             if smiles:
                 img = _draw_molecule(smiles)
@@ -369,22 +589,24 @@ with tabs[2]:
                     st.image(img, caption="2D Structure")
             else:
                 st.error("Compound structure not found in databases.")
-
+    
             # PubChem properties
-            pubchem_data = _query_api(API_ENDPOINTS["pubchem"].format(compound_input))
-            if pubchem_data and 'PC_Compounds' in pubchem_data and pubchem_data['PC_Compounds']:
-                st.subheader("Physicochemical Properties")
-                props = pubchem_data['PC_Compounds'][0]['props']
-                mw = next((prop['value']['sval'] for prop in props if 'name' in prop and prop['name'] == 'Molecular Weight'), 'N/A')
-                logp = next((prop['value']['sval'] for prop in props if 'name' in prop and prop['name'] == 'LogP'), 'N/A')
-
-                st.write(f"""
-                    Molecular Weight: {mw}
-                    LogP: {logp}
-                    """)
+            if compound_input:
+                pubchem_data = _query_api(API_ENDPOINTS["pubchem"].format(compound_input))
+                if pubchem_data and 'PC_Compounds' in pubchem_data and len(pubchem_data['PC_Compounds']) > 0:
+                    st.subheader("Physicochemical Properties")
+                    props = pubchem_data['PC_Compounds'][0].get('props', [])
+                    mw = next((prop['value']['sval'] for prop in props if 'name' in prop and prop['name'] == 'Molecular Weight'), 'N/A')
+                    logp = next((prop['value']['sval'] for prop in props if 'name' in prop and prop['name'] == 'LogP'), 'N/A')
+
+                    st.write(f"""
+                        **Molecular Weight:** {mw}
+                        **LogP:** {logp}
+                        """)
+                else:
+                    st.error("Physicochemical properties not found.")
             else:
-                st.error("Physicochemical properties not found.")
-
+                st.warning("Please enter a compound identifier.")
 
 # --- Tab 4: Regulatory Intelligence ---
 with tabs[3]:
@@ -393,34 +615,70 @@ with tabs[3]:
     
     if st.button("Generate Regulatory Report"):
         with st.spinner("Compiling global regulatory status..."):
-            # Multi-regional checks
-            fda = _get_fda_approval(drug_name)
-           # ema = _query_api(API_ENDPOINTS["ema_reports"], {"search": drug_name}) #Removed EMA due to 403 error
-            who = _query_api(API_ENDPOINTS["who_drugs"], {"name": drug_name})
+            # FDA Status
+            fda_info = _get_fda_approval(drug_name)
+            fda_status = "Not Approved"
+            if fda_info and 'openfda' in fda_info and 'brand_name' in fda_info['openfda']:
+                fda_status = ', '.join(fda_info['openfda']['brand_name'])
+            
+            # EMA Status via Scraping
+            ema_info = scrape_ema_drug_info(drug_name)
+            ema_status = ema_info['EMA Approval Status'] if ema_info else "Not Available"
+            
+            # WHO Essential Medicine
+            who = _query_api(API_ENDPOINTS["who_drugs"], params={"name": drug_name})
+            who_status = "Yes" if who else "No"
+            
+            # DailyMed Label
+            dailymed_info = _get_dailymed_label(drug_name)
+            dailymed_status = dailymed_info['Label URL'] if dailymed_info else "Not Available"
             
             st.subheader("Regulatory Status")
-            col1, col2, col3 = st.columns(3)
+            col1, col2, col3, col4 = st.columns(4)
             with col1:
                 st.markdown("**FDA Status**")
-                st.write(fda['openfda']['brand_name'][0] if fda and 'openfda' in fda and 'brand_name' in fda['openfda'] else "Not approved")
+                st.write(fda_status)
             with col2:
                 st.markdown("**EMA Status**")
-                #st.write(ema['results'][0]['currentStatus'] if ema and 'results' in ema and ema['results'] else "Not approved") #Removed EMA due to 403 error
-                st.write("Not Available")
+                st.write(ema_status)
             with col3:
                 st.markdown("**WHO Essential Medicine**")
-                st.write("Yes" if who else "No")
-
+                st.write(who_status)
+            with col4:
+                st.markdown("**DailyMed Label**")
+                st.write(dailymed_status)
+                if dailymed_info and 'Label URL' in dailymed_info:
+                    st.markdown(f"[View DailyMed Label]({dailymed_info['Label URL']})")
+        
+        # Display EMA Drug Page Link if available
+        if ema_info and 'EMA Drug Page' in ema_info:
+            st.markdown(f"[View EMA Drug Page]({ema_info['EMA Drug Page']})")
+        
         # Save the information to a PDF report
-        regulatory_content = f"### Regulatory Report\n\nFDA Status: {fda['openfda']['brand_name'][0] if fda and 'openfda' in fda and 'brand_name' in fda['openfda'] else 'Not Approved'}\n\nEMA Status: {'Not Available'}\n\nWHO Essential Medicine: {'Yes' if who else 'No'}"
-        report_file = _save_pdf_report(regulatory_content, f"{drug_name}_regulatory_report.pdf")
-        if report_file:
-            with open(report_file, "rb") as file:
-                st.download_button(
+        regulatory_content = f"""### Regulatory Report
+
+**FDA Status:** {fda_status}
+
+**EMA Status:** {ema_status}
+
+**WHO Essential Medicine:** {who_status}
+
+**DailyMed Label:** {dailymed_status}
+"""
+        if ema_info and 'EMA Drug Page' in ema_info:
+            regulatory_content += f"\n**EMA Drug Page:** {ema_info['EMA Drug Page']}\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")
+                        mime="application/pdf"
+                    )
+                os.remove(report_file)  # Clean up the temporary file
 
 # --- Tab 5: Literature Search ---
 with tabs[4]:
@@ -428,24 +686,131 @@ with tabs[4]:
     search_term = 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 = _query_pubmed(search_term)
-            if pubmed_data and 'esearchresult' in pubmed_data and 'idlist' in pubmed_data['esearchresult'] and pubmed_data['esearchresult']['idlist']:
+            pubmed_data = _get_pubmed(search_term)
+            if pubmed_data and 'esearchresult' in pubmed_data and 'idlist' in pubmed_data['esearchresult'] and len(pubmed_data['esearchresult']['idlist']) > 0:
                 st.subheader("PubMed Search Results")
                 st.write(f"Found {len(pubmed_data['esearchresult']['idlist'])} results for '{search_term}':")
                 for article_id in pubmed_data['esearchresult']['idlist']:
-                  st.write(f"- PMID: {article_id}")
+                    st.markdown(f"- [PMID: {article_id}](https://pubmed.ncbi.nlm.nih.gov/{article_id}/)")
             else:
                 st.write("No results found for that term.")
-
+    
+    # Enhanced Literature with Semantic Scholar
+    st.header("Semantic Scholar Literature Search")
+    semantic_query = st.text_input("Enter search query for Semantic Scholar:", placeholder="e.g., Alzheimer's disease genetics")
+    if st.button("Search Semantic Scholar"):
+        with st.spinner("Searching Semantic Scholar..."):
+            semantic_papers = _get_semantic_scholar_papers(semantic_query)
+            if semantic_papers:
+                st.subheader("Semantic Scholar Search Results")
+                for paper in semantic_papers:
+                    title = paper.get('title', 'N/A')
+                    authors = ', '.join([author['name'] for author in paper.get('authors', [])])
+                    year = paper.get('year', 'N/A')
+                    url = paper.get('url', '#')
+                    abstract = paper.get('abstract', 'No abstract available.')
+                    summary = _summarize_abstract(abstract) if abstract != 'No abstract available.' else "No summary available."
+                    
+                    st.markdown(f"### [{title}]({url})")
+                    st.write(f"**Authors:** {authors}")
+                    st.write(f"**Year:** {year}")
+                    st.write(f"**Abstract Summary:** {summary}")
+                    st.write("---")
+            else:
+                st.write("No results found for that term.")
+    
+    # Ontology Search
     st.header("Ontology Search")
     ontology_search_term = st.text_input("Enter Search query for Ontology:", placeholder="Enter disease or ontology")
-    ontology_select = st.selectbox("Select Ontology", ["MESH","NCIT","GO", "SNOMEDCT"])
+    ontology_select = st.selectbox("Select Ontology", ["MESH", "NCIT", "GO", "SNOMEDCT"])
     if st.button("Search BioPortal"):
         with st.spinner("Searching Ontology..."):
             bioportal_data = _get_bioportal_data(ontology_select, ontology_search_term)
-            if bioportal_data and 'collection' in bioportal_data:
+            if bioportal_data and 'collection' in bioportal_data and len(bioportal_data['collection']) > 0:
                 st.subheader(f"BioPortal Search Results for {ontology_select}")
                 for result in bioportal_data['collection']:
-                    st.write(f"- {result['prefLabel']} ({result['@id']})")
+                    label = result.get('prefLabel', 'N/A')
+                    ontology_id = result.get('@id', 'N/A')
+                    st.markdown(f"- **{label}** ({ontology_id})")
             else:
-                st.write("No results found")
+                st.write("No results found.")
+
+# --- Tab 6: Dashboard ---
+with tabs[5]:
+    st.header("Comprehensive Dashboard")
+    
+    # Sample KPI Counts (Replace with actual data)
+    fda_count = 5000  # Placeholder
+    ema_count = 3000
+    who_count = 1500
+    clinical_trials_count = 12000
+    publications_count = 250000
+    
+    def _create_kpi_dashboard(fda_count: int, ema_count: int, who_count: int, trials: int, publications: int):
+        """Creates KPI cards for the dashboard."""
+        col1, col2, col3, col4, col5 = st.columns(5)
+        col1.metric("FDA Approved Drugs", fda_count)
+        col2.metric("EMA Approved Drugs", ema_count)
+        col3.metric("WHO Essential Medicines", who_count)
+        col4.metric("Ongoing Clinical Trials", trials)
+        col5.metric("Publications Found", publications)
+    
+    _create_kpi_dashboard(fda_count, ema_count, who_count, clinical_trials_count, publications_count)
+    
+    # Trend Graphs
+    st.subheader("Trends Over Time")
+    # Example: Number of FDA approvals per year
+    years = list(range(2000, 2026))
+    fda_approvals = [fda_count // 26] * len(years)  # Placeholder data
+    
+    fig, ax = plt.subplots(figsize=(10,6))
+    sns.lineplot(x=years, y=fda_approvals, marker='o', ax=ax)
+    ax.set_title('FDA Drug Approvals Over Years')
+    ax.set_xlabel('Year')
+    ax.set_ylabel('Number of Approvals')
+    st.pyplot(fig)
+    
+    # Geographical Maps
+    st.subheader("Geographical Distribution of Clinical Trials")
+    # Placeholder: Actual implementation would require location data from ClinicalTrials.gov
+    # Example: Display a static map
+    st.write("Feature under development. Geographical data from clinical trials will be visualized here.")
+    
+    # Interactive Network Graph
+    st.subheader("Gene-Variant-Drug Network")
+    # Placeholder: Fetch sample gene, variants, and drugs
+    sample_gene = "CYP2C19"
+    sample_variants = ["rs4244285", "rs12248560"]
+    sample_annotations = {
+        "rs4244285": ["Clopidogrel", "Omeprazole"],
+        "rs12248560": ["Sertraline"]
+    }
+    
+    fig = _create_variant_network(sample_gene, sample_variants, sample_annotations)
+    st.plotly_chart(fig, use_container_width=True)
+
+# --- Additional Enhancements: User Authentication (Optional) ---
+# Implement user authentication if needed using streamlit-authenticator or Auth0
+
+# --- Additional Enhancements: Caching ---
+@st.cache_data(ttl=3600)
+def cached_get_pharmgkb_clinical_annotations(variant_id: str) -> Optional[Dict]:
+    """Cached version of fetching clinical annotations from PharmGKB."""
+    return _get_pharmgkb_clinical_annotations(variant_id)
+
+@st.cache_data(ttl=3600)
+def cached_get_pubchem_smiles(drug_name: str) -> Optional[str]:
+    """Cached version of retrieving SMILES from PubChem."""
+    return _get_pubchem_smiles(drug_name)
+
+# --- Final Touches ---
+st.sidebar.header("About")
+st.sidebar.info("""
+**Pharma Research Expert Platform**
+
+An integrated platform for drug discovery, clinical research, and regulatory affairs.
+
+**Developed by:** Your Name
+
+**Contact:** [[email protected]](mailto:[email protected])
+""")