Update app.py

app.py

@@ -1,158 +1,309 @@
 import streamlit as st
-from smolagents import CodeAgent, ChatAgent
+from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel
 from rdkit import Chem
-from rdkit.Chem import AllChem, Draw, Descriptors
-import py3Dmol
-from streamlit.components.v1 import html
-import pubchempy as pcp
+from rdkit.Chem import Draw
+from fpdf import FPDF
+import tempfile
+import time
 import requests
+import xml.etree.ElementTree as ET
+import json
 import pandas as pd
-import numpy as np
-from io import BytesIO
-from st_cytoscape import cytoscape
-
-# Initialize AI Research Team
-class PharmaAITeam:
-    def __init__(self):
-        self.medicinal_chemist = CodeAgent(
-            system="You are a senior medicinal chemist with 15+ years in lead optimization",
-            tools=[MolecularDynamicsTool()]
-        )
-        self.clinical_strategist = ChatAgent(
-            system="You are a clinical trial design expert with FDA/EMA experience"
-        )
-        self.bioinformatician = CodeAgent(
-            system="You are a computational biology expert specializing in target validation",
-            tools=[GenomeAnalysisTool()]
-        )
-
-# AI-Powered Drug Discovery Platform
-st.set_page_config(page_title="NeuroPharm AI", layout="wide", page_icon="🧠")
-st.title("🧠 NeuroPharm AI: Next-Gen CNS Drug Discovery")
-
-# --- Innovative Modules ---
-with st.expander("🚀 AI Research Assistant", expanded=True):
-    col1, col2 = st.columns([3,2])
-    with col1:
-        research_query = st.text_input("Ask your research question:", 
-                                     placeholder="Design a novel dopamine D3 selective agonist with reduced off-target effects")
-    with col2:
-        st.write("")
-        if st.button("Generate Expert Response"):
-            with st.spinner("Consulting AI research team..."):
-                team = PharmaAITeam()
-                chem_response = team.medicinal_chemist.run(research_query)
-                clinical_context = team.clinical_strategist.run(f"Provide clinical development considerations for: {research_query}")
-                
-                st.markdown(f"""
-                **Medicinal Chemistry Insights**
-                ```{chem_response}```
+import matplotlib.pyplot as plt
+import seaborn as sns
+from typing import Optional, Dict, List, Any
+
+
+# API Endpoints (Centralized Configuration)
+API_ENDPOINTS = {
+    "clinical_trials": "https://clinicaltrials.gov/api/query/full_studies",
+    "pubchem": "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{}/JSON",
+    "who_drugs": "https://health-products.canada.ca/api/drug/product",
+    "ema_reports": "https://www.ema.europa.eu/api/search/medicines",
+    "fda_drug_approval": "https://api.fda.gov/drug/label.json?search=openfda.brand_name:{}",
+    "faers_adverse_events": "https://api.fda.gov/drug/event.json?search=patient.drug.medicinalproduct:{}",
+    "pharmgkb": "https://api.pharmgkb.org/v1/site/variant/{}/clinicalAnnotations"
+}
+
+
+# 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]:
+    """Handles API requests with robust error handling."""
+    try:
+        response = requests.get(endpoint, params=params, 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.")
+        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 'name' in prop and prop['name'] == 'Canonical SMILES':
+                return prop['value']['sval']
+    return None
+
+
+def _draw_molecule(smiles: str) -> Optional[any]:
+    """Generates a 2D molecule image from SMILES."""
+    try:
+        mol = Chem.MolFromSmiles(smiles)
+        if mol:
+            img = Draw.MolToImage(mol)
+            return img
+        else:
+            st.error("Invalid SMILES string.")
+            return None
+    except Exception as e:
+        st.error(f"Error generating molecule image: {str(e)}")
+        return None
+
+
+def _get_clinical_trials(query: str) -> Optional[Dict]:
+    """Queries clinicaltrials.gov with search term."""
+    if query.upper().startswith("NCT") and query[3:].isdigit():  # Check if it's an NCT number
+        params = {
+            "id": query,
+            "fmt": "json"
+        }
+    else:
+        params = {
+            "expr": query,
+            "min_rnk": 1,
+            "max_rnk": 5,
+            "fmt": "json"
+        }
+    return _query_api(API_ENDPOINTS["clinical_trials"], params)
+
+def _get_fda_approval(drug_name: str) -> Optional[Dict]:
+    """Retrieves FDA approval info."""
+    url = API_ENDPOINTS["fda_drug_approval"].format(drug_name)
+    data = _query_api(url)
+    return data['results'][0] if data and 'results' in data and data['results'] else None
+
+
+def _analyze_adverse_events(drug_name: str) -> Optional[Dict]:
+    """Fetches and analyzes adverse event reports from FAERS."""
+    url = API_ENDPOINTS["faers_adverse_events"].format(drug_name)
+    return _query_api(url)
+
+
+def _get_pharmgkb_data(gene:str) -> Optional[Dict]:
+    """Fetches pharmacogenomic data from PharmGKB."""
+    url = "https://api.pharmgkb.org/v1/data/variant/{}/clinicalAnnotations".format(gene)
+    return _query_api(url)
+
+
+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):
+    """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
+
+# --- Streamlit App Configuration ---
+st.set_page_config(page_title="Pharma Research Expert Platform", layout="wide")
+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"])
+
+# --- Tab 1: Drug Development ---
+with tabs[0]:
+    st.header("AI-Driven Drug Development Strategy")
+    target = st.text_input("Target Disease/Pathway:", placeholder="Enter biological target or disease mechanism")
+    target_gene = st.text_input("Target Gene (for pharmacogenomics)", placeholder="Enter the gene associated with target")
+    strategy = st.selectbox("Development Strategy:", ["First-in-class", "Me-too", "Repurposing", "Biologic"])
+    
+    if st.button("Generate Development Plan"):
+        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. """
+            plan = content_agent.run(plan_prompt)
+            
+            st.subheader("Comprehensive Development Plan")
+            st.markdown(plan)
+            
+            # Regulatory information
+            if target:
+                fda_info = _get_fda_approval(target.split()[0])  # Simple name extraction for FDA search
+
+                if fda_info:
+                    st.subheader("FDA Regulatory Insights")
+                    st.json(fda_info)
+                else:
+                    st.write("No relevant FDA data found.")
+            else:
+                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)
+            else:
+                st.write("No relevant pharmacogenomic data found.")
+
+
+# --- 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("Aggregating global trial data..."):
+            trials = _get_clinical_trials(trial_query)
+            if trials and trials['FullStudiesResponse']['FullStudies']:
+                st.subheader("Recent Clinical Trials")
+                trial_data = []
+                for study in trials['FullStudiesResponse']['FullStudies'][:5]:
+                    protocol = study['Study']['ProtocolSection']
+                    trial_data.append({
+                        "Title": protocol['IdentificationModule']['OfficialTitle'],
+                        "Status": protocol['StatusModule']['OverallStatus'],
+                        "Phase": protocol['DesignModule']['PhaseList']['Phase'][0],
+                        "Enrollment": protocol['StatusModule']['EnrollmentCount']
+                    })
                 
-                **Clinical Development Strategy**
-                ```{clinical_context}```
-                """)
-
-# --- Quantum Molecular Studio ---
-st.subheader("🔬 Quantum Molecular Studio")
-col1, col2, col3 = st.columns([2,3,2])
-
-with col1:
-    compound = st.text_input("Enter compound:", "Risperidone")
-    if st.button("Run Quantum Analysis"):
-        with st.spinner("Performing QM/MM simulations..."):
-            mol = pcp.get_compounds(compound, 'name')[0]
-            st.session_state.mol3d = AllChem.AddHs(Chem.MolFromSmiles(mol.canonical_smiles))
-            AllChem.EmbedMolecule(st.session_state.mol3d, randomSeed=0xf00d)
-            AllChem.MMFFOptimizeMolecule(st.session_state.mol3d)
+                trial_df = _display_dataframe(trial_data, list(trial_data[0].keys())) if trial_data else None
+
+                if trial_df is not None:
+                    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']:
+                        st.subheader("Adverse Event Profile (Top 5 Reports)")
+                        
+                        ae_results = ae_data['results'][:5]
+                        ae_df = pd.DataFrame(ae_results)
+                        st.dataframe(ae_df)
+                        
+                        #Visualization of adverse events
+                        if 'patient' in ae_df 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}))
+
+                            except Exception as e:
+                                st.error(f"Error processing adverse events data: {e}")
+            else:
+                st.warning("No clinical trials found for the given search term.")
+
+
+# --- 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 global databases..."):
+            # SMILES resolution
+            smiles = compound_input if Chem.MolFromSmiles(compound_input) else _get_pubchem_smiles(compound_input)
+            
+            if smiles:
+                img = _draw_molecule(smiles)
+                if img:
+                    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}
+                    """)
+            else:
+                st.error("Physicochemical properties not found.")
+
+
+# --- Tab 4: Regulatory Intelligence ---
+with tabs[3]:
+    st.header("Global Regulatory Monitoring")
+    drug_name = st.text_input("Drug Product:", placeholder="Enter generic or brand name")
+    
+    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})
+            who = _query_api(API_ENDPOINTS["who_drugs"], {"name": drug_name})
             
-            # Generate interactive 3D viewer
-            viewer = py3Dmol.view(width=400, height=300)
-            viewer.addModel(Chem.MolToMolBlock(st.session_state.mol3d), 'mol')
-            viewer.setStyle({'stick': {}, 'sphere': {'radius': 0.3}})
-            viewer.zoomTo()
-            html(viewer._make_html())
-
-            # Generate pharmacological profile
-            descriptors = {
-                'QPlogPo/w': np.random.uniform(2,5),
-                'CNS Activity': np.random.choice(['High', 'Medium', 'Low']),
-                'Blood-Brain Barrier': 'Yes' if Descriptors.MolLogP(st.session_state.mol3d) > 2 else 'No'
-            }
-            st.session_state.descriptors = descriptors
-
-with col2:
-    if 'mol3d' in st.session_state:
-        st.markdown("**Quantum Properties Prediction**")
-        cyto_elements = [
-            {'data': {'id': 'HOMO', 'label': f'HOMO: {np.random.uniform(-9,-5):.2f} eV'}},
-            {'data': {'id': 'LUMO', 'label': f'LUMO: {np.random.uniform(-3,1):.2f} eV'}},
-            {'data': {'source': 'HOMO', 'target': 'LUMO'}}
-        ]
-        cytoscape(
-            elements=cyto_elements,
-            layout={'name': 'circle'},
-            stylesheet=[{
-                'selector': 'node',
-                'style': {'label': 'data(label)', 'font-size': '20px'}
-            }],
-            height="300px"
-        )
-
-with col3:
-    if 'descriptors' in st.session_state:
-        st.markdown("**Pharmacokinetic Profile**")
-        for k, v in st.session_state.descriptors.items():
-            st.metric(k, v)
-        st.plotly_chart(px.bar(
-            x=list(st.session_state.descriptors.keys()),
-            y=[1, 0.7, 0.9],
-            title="Blood-Brain Barrier Penetration Potential"
-        ))
-
-# --- Neural Target Mapping ---
-st.subheader("🧫 Neuro-Target Interaction Network")
-if st.button("Map CNS Targets"):
-    with st.spinner("Analyzing human brain proteome..."):
-        nodes = [
-            {'data': {'id': 'D2', 'label': 'Dopamine D2'}},
-            {'data': {'id': '5HT2A', 'label': '5-HT2A'}},
-            {'data': {'id': 'H1', 'label': 'Histamine H1'}},
-            {'data': {'id': compound, 'label': compound}}
-        ]
-        edges = [
-            {'data': {'source': compound, 'target': 'D2', 'label': 'Kd=4.2nM'}},
-            {'data': {'source': compound, 'target': '5HT2A', 'label': 'Kd=18nM'}},
-            {'data': {'source': compound, 'target': 'H1', 'label': 'Kd=2.1μM'}}
-        ]
-        cytoscape(
-            elements=nodes + edges,
-            layout={'name': 'cose'},
-            stylesheet=[
-                {
-                    'selector': 'node',
-                    'style': {'label': 'data(label)', 'shape': 'hexagon'}
-                },
-                {
-                    'selector': 'edge',
-                    'style': {'label': 'data(label)', 'curve-style': 'bezier'}
-                }
-            ],
-            height="400px"
-        )
-
-# --- Virtual Clinical Trial Simulator ---
-st.subheader("📈 AI Clinical Trial Predictor")
-col1, col2 = st.columns(2)
-with col1:
-    phase = st.selectbox("Trial Phase", ["Phase I", "Phase II", "Phase III"])
-    population = st.slider("Patient Population", 50, 5000, 200)
-with col2:
-    endpoints = st.multiselect("Endpoints", ["PANSS", "MADRS", "CGI-S", "Neurocognitive Battery"])
-    if st.button("Predict Trial Outcome"):
-        with st.spinner("Running Monte Carlo simulations..."):
-            success_prob = np.random.uniform(0.3, 0.8)
-            st.metric("Predicted Success Probability", f"{success_prob:.0%}")
-            st.altair_chart(alt.Chart(pd.DataFrame({
-                'Week': range(1,13),
-                'Improvement': np.cumsum(np.random.normal(0.5, 0.2, 12))
-            })).mark_line().encode(x='Week', y='Improvement'))
+            st.subheader("Regulatory Status")
+            col1, col2, col3 = st.columns(3)
+            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")
+            with col2:
+                st.markdown("**EMA Status**")
+                st.write(ema['results'][0]['currentStatus'] if ema and 'results' in ema and ema['results'] else "Not approved")
+            with col3:
+                st.markdown("**WHO Essential Medicine**")
+                st.write("Yes" if who else "No")
+
+        # 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: {ema['results'][0]['currentStatus'] if ema and 'results' in ema and ema['results'] else 'Not Approved'}\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(
+                        label="Download Regulatory Report (PDF)",
+                        data=file,
+                        file_name=f"{drug_name}_regulatory_report.pdf",
+                        mime="application/pdf")