Update app.py

app.py

@@ -21,21 +21,20 @@ st.set_page_config(page_title="Pharma Research Expert Platform", layout="wide")
 logging.basicConfig(level=logging.ERROR)
 
 # -------------------------------
-# API ENDPOINTS (Stable Sources Only)
+# API ENDPOINTS (Using only Stable Sources)
 # -------------------------------
 API_ENDPOINTS = {
-    "clinical_trials": "https://clinicaltrials.gov/api/v2/studies",
+    "clinical_trials": "https://clinicaltrials.gov/api/v2/studies",  # No email required now
     "pubchem": "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{}/JSON",
     "pubmed": "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi",
     "fda_drug_approval": "https://api.fda.gov/drug/label.json",
     "faers_adverse_events": "https://api.fda.gov/drug/event.json",
-    # PharmGKB endpoints for gene variants (if available)
+    # PharmGKB endpoint for gene variants (if available)
     "pharmgkb_gene_variants": "https://api.pharmgkb.org/v1/data/gene/{}/variants",
-    # BioPortal for ontology searches
-    "bioportal_search": "https://data.bioontology.org/search",
-    # RxNorm & RxClass 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 (may return no data, so we provide a fallback message)
     "rxclass_by_drug": "https://rxnav.nlm.nih.gov/REST/class/byDrugName.json"
 }
 
@@ -44,22 +43,20 @@ API_ENDPOINTS = {
 # -------------------------------
 TRADE_TO_GENERIC = {
     "tylenol": "acetaminophen",
+    "panadol": "acetaminophen",
     "advil": "ibuprofen",
-    # Extend with additional mappings as desired
+    # Add additional mappings as needed
 }
 
 # -------------------------------
-# SECRETS RETRIEVAL
+# 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")
+PUB_EMAIL = st.secrets.get("PUB_EMAIL")
 
 if not PUB_EMAIL:
     st.error("PUB_EMAIL is not configured in secrets.")
-if not BIOPORTAL_API_KEY:
-    st.error("BIOPORTAL_API_KEY is not configured in secrets.")
 if not OPENFDA_KEY:
     st.error("OPENFDA_KEY is not configured in secrets.")
 if not OPENAI_API_KEY:
@@ -72,7 +69,7 @@ from openai import OpenAI
 openai_client = OpenAI(api_key=OPENAI_API_KEY)
 
 def generate_ai_content(prompt: str) -> str:
-    """Call GPT-4 to generate innovative insights."""
+    """Generate innovative insights using GPT‑4."""
     try:
         response = openai_client.chat.completions.create(
             model="gpt-4",
@@ -81,52 +78,28 @@ def generate_ai_content(prompt: str) -> str:
         )
         return response.choices[0].message.content.strip()
     except Exception as e:
-        st.error(f"GPT-4 generation error: {e}")
+        st.error(f"GPT‑4 generation error: {e}")
         logging.error(e)
         return "AI content generation failed."
 
 # -------------------------------
-# UTILITY FUNCTIONS WITH CACHING
+# UTILITY FUNCTIONS (with caching)
 # -------------------------------
 @st.cache_data(show_spinner=False)
 def query_api(endpoint: str, params: Optional[Dict] = None, headers: Optional[Dict] = None) -> Optional[Dict]:
-    """Wrapper for HTTP GET requests with error handling."""
+    """HTTP GET with error handling and caching."""
     try:
         response = requests.get(endpoint, params=params, headers=headers, timeout=15)
         response.raise_for_status()
         return response.json()
     except Exception as e:
         st.error(f"API error for {endpoint}: {e}")
-        logging.error(f"API error for {endpoint}: {e}")
-    return None
-
-@st.cache_data(show_spinner=False)
-def get_pubchem_smiles(drug_name: str) -> Optional[str]:
-    """Retrieve canonical SMILES using PubChem."""
-    url = API_ENDPOINTS["pubchem"].format(drug_name)
-    data = query_api(url)
-    if data and data.get("PC_Compounds"):
-        for prop in data["PC_Compounds"][0].get("props", []):
-            if prop.get("name") == "Canonical SMILES":
-                return prop["value"]["sval"]
-    return None
-
-def draw_molecule(smiles: str) -> Optional[Any]:
-    """Generate a 2D molecule image using RDKit."""
-    try:
-        mol = Chem.MolFromSmiles(smiles)
-        if mol:
-            return Draw.MolToImage(mol)
-        else:
-            st.error("Invalid SMILES string provided.")
-    except Exception as e:
-        st.error(f"Error drawing molecule: {e}")
         logging.error(e)
     return None
 
 @st.cache_data(show_spinner=False)
 def get_pubchem_drug_details(drug_name: str) -> Optional[Dict[str, str]]:
-    """Retrieve drug details from PubChem."""
+    """Retrieve drug details (including molecular formula, IUPAC name, and SMILES) from PubChem."""
     url = API_ENDPOINTS["pubchem"].format(drug_name)
     data = query_api(url)
     details = {}
@@ -143,9 +116,23 @@ def get_pubchem_drug_details(drug_name: str) -> Optional[Dict[str, str]]:
         return details
     return None
 
+def save_pdf_report(report_content: str, filename: str) -> Optional[str]:
+    """Save a text report as a PDF file using FPDF."""
+    try:
+        pdf = FPDF()
+        pdf.add_page()
+        pdf.set_font("Arial", size=12)
+        pdf.multi_cell(0, 10, report_content)
+        pdf.output(filename)
+        return filename
+    except Exception as e:
+        st.error(f"Error saving PDF: {e}")
+        logging.error(e)
+    return None
+
 @st.cache_data(show_spinner=False)
 def get_clinical_trials(query: str) -> Optional[Dict]:
-    """Query ClinicalTrials.gov."""
+    """Query ClinicalTrials.gov (NCT number or term search)."""
     if query.upper().startswith("NCT") and query[3:].isdigit():
         params = {"id": query, "fmt": "json"}
     else:
@@ -154,16 +141,13 @@ def get_clinical_trials(query: str) -> Optional[Dict]:
 
 @st.cache_data(show_spinner=False)
 def get_pubmed(query: str) -> Optional[Dict]:
-    """Query PubMed."""
+    """Query PubMed using the given search term."""
     params = {"db": "pubmed", "term": query, "retmax": 10, "retmode": "json", "email": PUB_EMAIL}
     return query_api(API_ENDPOINTS["pubmed"], params)
 
 @st.cache_data(show_spinner=False)
 def get_fda_approval(drug_name: str) -> Optional[Dict]:
-    """Retrieve FDA approval info using openFDA."""
-    if not OPENFDA_KEY:
-        st.error("OpenFDA key not configured.")
-        return None
+    """Retrieve FDA drug approval data using openFDA."""
     query = f'openfda.brand_name:"{drug_name}"'
     params = {"api_key": OPENFDA_KEY, "search": query, "limit": 1}
     data = query_api(API_ENDPOINTS["fda_drug_approval"], params)
@@ -173,30 +157,14 @@ def get_fda_approval(drug_name: str) -> Optional[Dict]:
 
 @st.cache_data(show_spinner=False)
 def analyze_adverse_events(drug_name: str, limit: int = 5) -> Optional[Dict]:
-    """Retrieve FAERS adverse events."""
-    if not OPENFDA_KEY:
-        st.error("OpenFDA key not configured.")
-        return None
+    """Retrieve adverse event data from FAERS."""
     query = f'patient.drug.medicinalproduct:"{drug_name}"'
     params = {"api_key": OPENFDA_KEY, "search": query, "limit": limit}
     return query_api(API_ENDPOINTS["faers_adverse_events"], params)
 
-@st.cache_data(show_spinner=False)
-def get_pharmgkb_variants_for_gene(pharmgkb_gene_id: str) -> Optional[List[str]]:
-    """Return variant IDs for a PharmGKB gene accession."""
-    if not pharmgkb_gene_id.startswith("PA"):
-        st.warning("Enter a valid PharmGKB gene accession (e.g., PA1234).")
-        return None
-    endpoint = API_ENDPOINTS["pharmgkb_gene_variants"].format(pharmgkb_gene_id)
-    data = query_api(endpoint)
-    if data and data.get("data"):
-        return [variant["id"] for variant in data["data"]]
-    st.warning(f"No variants found for PharmGKB gene {pharmgkb_gene_id}.")
-    return None
-
 @st.cache_data(show_spinner=False)
 def get_rxnorm_rxcui(drug_name: str) -> Optional[str]:
-    """Return RxCUI for a drug."""
+    """Retrieve the RxCUI for a drug from RxNorm."""
     url = f"{API_ENDPOINTS['rxnorm_rxcui']}?name={drug_name}"
     data = query_api(url)
     if data and "idGroup" in data and data["idGroup"].get("rxnormId"):
@@ -206,36 +174,79 @@ def get_rxnorm_rxcui(drug_name: str) -> Optional[str]:
 
 @st.cache_data(show_spinner=False)
 def get_rxnorm_properties(rxcui: str) -> Optional[Dict]:
-    """Return RxNorm properties for a given RxCUI."""
+    """Retrieve RxNorm properties for a given RxCUI."""
     url = API_ENDPOINTS["rxnorm_properties"].format(rxcui)
     return query_api(url)
 
 @st.cache_data(show_spinner=False)
 def get_rxclass_by_drug_name(drug_name: str) -> Optional[Dict]:
-    """Return RxClass information for a drug."""
+    """Query RxClass for drug classification info. (Fallback if no data is returned.)"""
     url = f"{API_ENDPOINTS['rxclass_by_drug']}?drugName={drug_name}"
     data = query_api(url)
-    if data and "classMember" in data:
-        return data
-    return None
+    return data  # May return None if no data is found
+
+def create_variant_network(gene: str, variants: List[str], annotations: Dict[str, List[str]]) -> go.Figure:
+    """Generate a gene-variant-drug network graph using NetworkX and Plotly."""
+    G = nx.Graph()
+    G.add_node(gene, color="lightblue")
+    for variant in variants:
+        G.add_node(variant, color="lightgreen")
+        G.add_edge(gene, variant)
+        for drug in annotations.get(variant, []):
+            if drug and drug != "N/A":
+                G.add_node(drug, color="lightcoral")
+                G.add_edge(variant, drug)
+    pos = nx.spring_layout(G)
+    edge_x, edge_y = [], []
+    for edge in G.edges():
+        x0, y0 = pos[edge[0]]
+        x1, y1 = pos[edge[1]]
+        edge_x.extend([x0, x1, None])
+        edge_y.extend([y0, y1, None])
+    edge_trace = go.Scatter(
+        x=edge_x, y=edge_y, line=dict(width=1, 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].get("color", "gray"))
+    node_trace = go.Scatter(
+        x=node_x, y=node_y, mode="markers+text", hoverinfo="text",
+        text=node_text, textposition="bottom center",
+        marker=dict(color=node_color, size=12, line_width=2)
+    )
+    fig = go.Figure(data=[edge_trace, node_trace],
+                    layout=go.Layout(
+                        title=dict(text="Gene-Variant-Drug Network", font=dict(size=16)),
+                        showlegend=False,
+                        hovermode="closest",
+                        margin=dict(b=20, l=5, r=5, t=40),
+                        xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+                        yaxis=dict(showgrid=False, zeroline=False, showticklabels=False)
+                    ))
+    return fig
 
 # -------------------------------
 # AI-DRIVEN DRUG INSIGHTS
 # -------------------------------
 def generate_drug_insights(drug_name: str) -> str:
     """
-    Gather FDA, PubChem, RxNorm, and RxClass data (using generic fallback) and build a GPT‑4 prompt
+    Gather data from FDA, PubChem, RxNorm, and RxClass (using generic fallback) and build a GPT‑4 prompt
     for an innovative, bullet‑point drug analysis.
     """
     query_name = TRADE_TO_GENERIC.get(drug_name.lower(), drug_name)
     
-    # Get FDA data
+    # FDA Data
     fda_info = get_fda_approval(query_name)
     fda_status = "Not Approved"
     if fda_info and fda_info.get("openfda", {}).get("brand_name"):
         fda_status = ", ".join(fda_info["openfda"]["brand_name"])
     
-    # Get PubChem details
+    # PubChem Data
     pubchem_details = get_pubchem_drug_details(query_name)
     if pubchem_details:
         formula = pubchem_details.get("Molecular Formula", "N/A")
@@ -244,7 +255,7 @@ def generate_drug_insights(drug_name: str) -> str:
     else:
         formula = iupac = canon_smiles = "Not Available"
     
-    # RxNorm and RxClass
+    # RxNorm Data
     rxnorm_id = get_rxnorm_rxcui(query_name)
     if rxnorm_id:
         rx_props = get_rxnorm_properties(rxnorm_id)
@@ -252,22 +263,25 @@ def generate_drug_insights(drug_name: str) -> str:
     else:
         rxnorm_info = "No RxNorm data available."
     
+    # RxClass Data
     rxclass_data = get_rxclass_by_drug_name(query_name)
     rxclass_info = rxclass_data if rxclass_data else "No RxClass data available."
     
-    # Construct prompt for GPT-4
+    # Construct prompt for GPT‑4
     prompt = (
-        f"Please provide an advanced, innovative drug analysis report for '{drug_name}' "
-        f"(generic: {query_name}).\n\n"
-        f"**FDA Approval Status:** {fda_status}\n"
-        f"**PubChem Details:** Molecular Formula: {formula}, IUPAC Name: {iupac}, Canonical SMILES: {canon_smiles}\n"
-        f"**RxNorm Info:** {rxnorm_info}\n"
+        f"Provide an innovative, advanced drug analysis for '{drug_name}' (generic: {query_name}).\n\n"
+        f"**FDA Approval Status:** {fda_status}\n\n"
+        f"**PubChem Details:**\n"
+        f"- Molecular Formula: {formula}\n"
+        f"- IUPAC Name: {iupac}\n"
+        f"- Canonical SMILES: {canon_smiles}\n\n"
+        f"**RxNorm Info:** {rxnorm_info}\n\n"
         f"**RxClass Info:** {rxclass_info}\n\n"
-        f"Include the following in bullet points:\n"
-        f"- Pharmacogenomic considerations (including genetic variants that might affect metabolism and toxicity).\n"
-        f"- Potential repurposing opportunities based on drug mechanism.\n"
-        f"- Regulatory insights and challenges, particularly for expanding indications or personalized medicine.\n"
-        f"- Innovative suggestions for future research and data integration approaches.\n"
+        f"Include in bullet points:\n"
+        f"- Pharmacogenomic considerations (e.g. genetic variants impacting metabolism or toxicity)\n"
+        f"- Potential repurposing opportunities and innovative therapeutic insights\n"
+        f"- Regulatory challenges and suggestions for personalized medicine approaches\n"
+        f"- Forward‑looking recommendations for future research and integration of diverse data sources\n"
     )
     return generate_ai_content(prompt)
 
@@ -287,7 +301,7 @@ tabs = st.tabs([
 
 # ----- Tab 1: Drug Development -----
 with tabs[0]:
-    st.header("AI-Driven Drug Development Strategy")
+    st.header("AI‑Driven Drug Development Strategy")
     target = st.text_input("Target Disease/Pathway:", placeholder="Enter disease mechanism or target")
     target_gene = st.text_input("Target Gene (PharmGKB Accession):", placeholder="e.g., PA1234")
     strategy = st.selectbox("Development Strategy:", ["First-in-class", "Me-too", "Repurposing", "Biologic"])
@@ -297,7 +311,7 @@ with tabs[0]:
             plan_prompt = (
                 f"Develop a detailed drug development plan for treating {target} using a {strategy} strategy. "
                 "Include sections on target validation, lead optimization, preclinical testing, clinical trial design, "
-                "regulatory strategy, market analysis, competitive landscape, and relevant pharmacogenomic considerations."
+                "regulatory strategy, market analysis, competitive landscape, and pharmacogenomic considerations."
             )
             plan = generate_ai_content(plan_prompt)
             st.subheader("Comprehensive Development Plan")
@@ -320,10 +334,17 @@ with tabs[0]:
                 if variants:
                     st.write("PharmGKB Variants:")
                     st.write(variants)
+                    # Optionally, display network graph if variant annotations are available.
+                    sample_annots = {}
                     for vid in variants[:3]:
-                        annotations = _get_pharmgkb_clinical_annotations(vid)
-                        st.write(f"Annotations for Variant {vid}:")
-                        st.json(annotations if annotations else {"message": "No annotations found."})
+                        # Here you would normally fetch annotations.
+                        # For demonstration, we set a dummy list:
+                        sample_annots[vid] = ["DrugA", "DrugB"]
+                    try:
+                        net_fig = create_variant_network(target_gene, variants[:3], sample_annots)
+                        st.plotly_chart(net_fig, use_container_width=True)
+                    except Exception as e:
+                        st.error(f"Network graph error: {e}")
                 else:
                     st.write("No variants found for the specified PharmGKB gene accession.")
         else:
@@ -345,7 +366,8 @@ with tabs[1]:
                         "Phase": study.get("protocolSection", {}).get("designModule", {}).get("phases", ["Not Available"])[0],
                         "Enrollment": study.get("protocolSection", {}).get("designModule", {}).get("enrollmentInfo", {}).get("count", "N/A")
                     })
-                _display_dataframe(trial_data, list(trial_data[0].keys()))
+                df_trials = pd.DataFrame(trial_data)
+                st.dataframe(df_trials)
             else:
                 st.warning("No clinical trials found for the query.")
         
@@ -370,35 +392,34 @@ with tabs[1]:
         else:
             st.write("No adverse event data available.")
 
-# ----- Tab 3: Molecular Profiling -----
+# ----- Tab 3: Advanced Molecular Profiling -----
 with tabs[2]:
     st.header("Advanced Molecular Profiling")
     compound_input = st.text_input("Compound Identifier:", placeholder="Enter drug name, SMILES, or INN")
     if st.button("Analyze Compound"):
-        with st.spinner("Querying PubChem for molecular structure..."):
+        with st.spinner("Querying PubChem for molecular structure and properties..."):
+            # Use trade-to-generic mapping
             query_compound = TRADE_TO_GENERIC.get(compound_input.lower(), compound_input)
-            smiles = _get_pubchem_smiles(query_compound)
-            if smiles:
-                mol_image = draw_molecule(smiles)
-                if mol_image:
-                    st.image(mol_image, caption="2D Molecular Structure")
+            pubchem_info = get_pubchem_drug_details(query_compound)
+            if pubchem_info:
+                smiles = pubchem_info.get("Canonical SMILES")
+                if smiles and smiles != "N/A":
+                    mol_image = draw_molecule(smiles)
+                    if mol_image:
+                        st.image(mol_image, caption="2D Molecular Structure")
+                else:
+                    st.error("Canonical SMILES not found for this compound.")
+                st.subheader("Physicochemical Properties")
+                st.write(f"**Molecular Formula:** {pubchem_info.get('Molecular Formula', 'N/A')}")
+                st.write(f"**IUPAC Name:** {pubchem_info.get('IUPAC Name', 'N/A')}")
+                st.write(f"**Canonical SMILES:** {pubchem_info.get('Canonical SMILES', 'N/A')}")
             else:
-                st.error("Molecular structure not found. Try a more specific compound name.")
-        pubchem_data = query_api(API_ENDPOINTS["pubchem"].format(query_compound))
-        if pubchem_data and pubchem_data.get("PC_Compounds"):
-            st.subheader("Physicochemical Properties")
-            props = pubchem_data["PC_Compounds"][0].get("props", [])
-            mw = next((prop["value"]["sval"] for prop in props if prop.get("name") == "Molecular Weight"), "N/A")
-            logp = next((prop["value"]["sval"] for prop in props if prop.get("name") == "LogP"), "N/A")
-            st.write(f"**Molecular Weight:** {mw}")
-            st.write(f"**LogP:** {logp}")
-        else:
-            st.error("Physicochemical properties not available.")
+                st.error("PubChem details not available for the given compound.")
 
-# ----- Tab 4: Regulatory Intelligence -----
+# ----- Tab 4: Global Regulatory Monitoring -----
 with tabs[3]:
     st.header("Global Regulatory Monitoring")
-    st.markdown("**Note:** Due to persistent issues with EMA/WHO/DailyMed APIs, this section focuses on FDA data and PubChem drug details.")
+    st.markdown("**Note:** This section focuses on FDA data and PubChem drug details due to limitations with EMA/WHO/DailyMed APIs.")
     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..."):
@@ -430,7 +451,7 @@ with tabs[3]:
                 f"**Canonical SMILES:** {canon_smiles}\n"
             )
             with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp:
-                pdf_file = _save_pdf_report(report_text, tmp.name)
+                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")
@@ -450,25 +471,12 @@ with tabs[4]:
                     st.markdown(f"- [PMID: {pmid}](https://pubmed.ncbi.nlm.nih.gov/{pmid}/)")
             else:
                 st.write("No PubMed results found.")
-    st.header("Ontology Search")
-    ont_query = st.text_input("Enter search query for Ontology:", placeholder="e.g., Alzheimer's disease")
-    ont_select = st.selectbox("Select Ontology", ["MESH", "NCIT", "GO", "SNOMEDCT"])
-    if st.button("Search BioPortal"):
-        with st.spinner("Searching BioPortal..."):
-            bioportal_results = _get_bioportal_data(ont_select, ont_query)
-            if bioportal_results and bioportal_results.get("collection"):
-                st.subheader(f"BioPortal Results for {ont_select}")
-                for item in bioportal_results["collection"]:
-                    label = item.get("prefLabel", "N/A")
-                    ont_id = item.get("@id", "N/A")
-                    st.markdown(f"- **{label}** ({ont_id})")
-            else:
-                st.write("No ontology results found.")
+    # (Ontology search removed due to unreliable endpoints)
 
 # ----- Tab 6: Comprehensive Dashboard -----
 with tabs[5]:
     st.header("Comprehensive Dashboard")
-    # Example KPIs (these could later be replaced by dynamic queries)
+    # Static sample KPIs – these can be replaced with dynamic aggregated data in the future
     kpi_fda = 5000
     kpi_trials = 12000
     kpi_pubs = 250000
@@ -486,11 +494,12 @@ with tabs[5]:
     ax_trend.set_ylabel("Number of Approvals")
     st.pyplot(fig_trend)
     st.subheader("Gene-Variant-Drug Network (Sample)")
+    # Sample network using dummy data
     sample_gene = "CYP2C19"
     sample_variants = ["rs4244285", "rs12248560"]
     sample_annots = {"rs4244285": ["Clopidogrel", "Omeprazole"], "rs12248560": ["Sertraline"]}
     try:
-        net_fig = _create_variant_network(sample_gene, sample_variants, sample_annots)
+        net_fig = create_variant_network(sample_gene, sample_variants, sample_annots)
         st.plotly_chart(net_fig, use_container_width=True)
     except Exception as e:
         st.error(f"Network graph error: {e}")
@@ -533,6 +542,5 @@ with tabs[7]:
         with st.spinner("Generating AI-driven insights..."):
             query_ai_drug = TRADE_TO_GENERIC.get(ai_drug.lower(), ai_drug)
             insights_text = generate_drug_insights(query_ai_drug)
-            st.subheader("AI-Driven Drug Analysis")
+            st.subheader("AI‑Driven Drug Analysis")
             st.markdown(insights_text)
-