Update app.py

app.py

@@ -3,15 +3,15 @@
 # -----------------------------
 import streamlit as st
 import requests
+from rdkit import Chem
+from rdkit.Chem import Draw
 import pandas as pd
 import matplotlib.pyplot as plt
 import seaborn as sns
 import logging
 import re
-import time
-from rdkit import Chem
-from rdkit.Chem import Draw
-from bs4 import BeautifulSoup  # For future scraping implementations if needed
+from typing import Optional, Dict, List, Any
+from openai import OpenAI
 
 # Configure advanced logging for full traceability and diagnostics
 logging.basicConfig(
@@ -22,79 +22,109 @@ logging.basicConfig(
 logger = logging.getLogger("PRIS")
 
 # -----------------------------
-# FALLBACK / SCRAPED DATA
+# GLOBAL CONSTANTS
 # -----------------------------
-# Fallback data for compound profiling (e.g., scraped or cached data)
-FALLBACK_COMPOUND_DATA = {
-    "aspirin": {
-        "molecular_formula": "C9H8O4",
-        "iupac_name": "2-acetoxybenzoic acid",
-        "canonical_smiles": "CC(=O)OC1=CC=CC=C1C(=O)O",  # Valid SMILES for Aspirin
-        "molecular_weight": "180.16",
-        "logp": "N/A"
-    }
+API_ENDPOINTS = {
+    "clinical_trials": "https://clinicaltrials.gov/api/v2/studies",
+    "fda_drug_approval": "https://api.fda.gov/drug/label.json",
+    "pubchem": "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{}/JSON",
+    # ... other endpoints omitted for brevity ...
 }
 
-# Fallback clinical trial data (e.g., sample scraped data)
-FALLBACK_CLINICAL_DATA = {
-    "nct1": [
-        {
-            "Title": "A Study of Novel Therapeutics in Diabetes",
-            "Status": "Completed",
-            "Phase": "Phase II",
-            "Enrollment": "120"
-        }
-    ]
+DEFAULT_HEADERS = {
+    "User-Agent": "PharmaResearchIntelligenceSuite/1.0 (Professional Use)",
+    "Accept": "application/json"
 }
 
+# -----------------------------
+# SECRETS MANAGEMENT
+# -----------------------------
+class APIConfigurationError(Exception):
+    """Custom exception for missing API configurations."""
+    pass
+
+try:
+    OPENAI_API_KEY = st.secrets["OPENAI_API_KEY"]
+    BIOPORTAL_API_KEY = st.secrets["BIOPORTAL_API_KEY"]
+    PUB_EMAIL = st.secrets["PUB_EMAIL"]
+    OPENFDA_KEY = st.secrets["OPENFDA_KEY"]
+    
+    if not all([OPENAI_API_KEY, BIOPORTAL_API_KEY, PUB_EMAIL, OPENFDA_KEY]):
+        raise APIConfigurationError("One or more required API credentials are missing.")
+except (KeyError, APIConfigurationError) as e:
+    st.error(f"Critical configuration error: {str(e)}")
+    st.stop()
+
 # -----------------------------
 # CORE INFRASTRUCTURE
 # -----------------------------
 class PharmaResearchEngine:
-    """
-    Core engine for integrating pharmaceutical datasets using fallback/scraped data.
-    No external APIs are required; fallback data is used instead.
-    """
+    """Core engine for integrating diverse pharmaceutical datasets and performing advanced analyses."""
     
     def __init__(self):
-        # In a production environment, this is where an AI client would be initialized.
-        pass
-
-    def api_request(self, endpoint: str, params: dict = None, headers: dict = None) -> dict:
+        self.openai_client = OpenAI(api_key=OPENAI_API_KEY)
+        
+    @staticmethod
+    def api_request(endpoint: str, 
+                    params: Optional[Dict] = None,
+                    headers: Optional[Dict] = None) -> Optional[Dict]:
         """
-        Dummy API request handler. In this implementation, live API calls are bypassed.
-        Instead, the method always returns an empty dictionary.
+        Enterprise-grade API request handler with detailed error logging.
         """
-        logger.info(f"Simulated API request to {endpoint} with params {params}")
-        # Simulate a network delay
-        time.sleep(0.5)
-        return {}  # Always empty because no API is actually used
+        try:
+            response = requests.get(
+                endpoint,
+                params=params,
+                headers={**DEFAULT_HEADERS, **(headers or {})},
+                timeout=(3.05, 15)
+            )
+            response.raise_for_status()  # Raises HTTPError for 4xx/5xx responses
+            return response.json()
+        except requests.exceptions.HTTPError as e:
+            logger.error(f"HTTP Error {e.response.status_code} for {endpoint} with params {params}")
+            st.error(f"API Error: {e.response.status_code} - {e.response.reason}")
+        except Exception as e:
+            logger.error(f"Network error for {endpoint}: {str(e)}")
+            st.error(f"Network error: {str(e)}")
+        return None
 
-    def get_compound_profile(self, identifier: str) -> dict:
+    def get_compound_profile(self, identifier: str) -> Optional[Dict]:
         """
-        Retrieve a comprehensive compound profile.
-        This function first checks if the input is valid, then returns fallback data.
+        Retrieve comprehensive chemical profile data from PubChem for a given compound.
+        Accepts both common compound names and SMILES strings.
         """
         if not self._is_valid_compound_input(identifier):
             msg = (f"The input '{identifier}' appears to reference a disease term rather than a chemical compound. "
                    "For disease-related inquiries, please use the Clinical Trial Analytics module.")
             logger.warning(msg)
             st.error(msg)
-            return {}
+            return None
 
-        # Attempt simulated API call (which in this case does nothing)
-        pubchem_data = self.api_request("https://pubchem.fakeendpoint/rest/pug/compound/name/{}/JSON".format(identifier))
-        
-        # If no data is returned from API simulation, use fallback scraped data
-        if identifier.lower() in FALLBACK_COMPOUND_DATA:
-            logger.info(f"Using fallback data for compound '{identifier}'.")
-            return FALLBACK_COMPOUND_DATA[identifier.lower()]
-        else:
-            logger.warning(f"No compound data found for '{identifier}'.")
+        pubchem_url = API_ENDPOINTS["pubchem"].format(identifier)
+        pubchem_data = self.api_request(pubchem_url)
+        if not pubchem_data or not pubchem_data.get("PC_Compounds"):
+            logger.warning(f"No compound data returned for identifier: {identifier}")
             st.error("No compound data found. Please verify your input (e.g., check for typos or use a recognized compound name).")
-            return {}
+            return None
+            
+        compound = pubchem_data["PC_Compounds"][0]
+        return {
+            'molecular_formula': self._extract_property(compound, 'Molecular Formula'),
+            'iupac_name': self._extract_property(compound, 'IUPAC Name'),
+            'canonical_smiles': self._extract_property(compound, 'Canonical SMILES'),
+            'molecular_weight': self._extract_property(compound, 'Molecular Weight'),
+            'logp': self._extract_property(compound, 'LogP')
+        }
 
-    def _is_valid_compound_input(self, user_input: str) -> bool:
+    def _extract_property(self, compound: Dict, prop_name: str) -> str:
+        """Helper to extract a specific property from PubChem compound data."""
+        for prop in compound.get("props", []):
+            if prop.get("urn", {}).get("label") == prop_name:
+                return prop["value"].get("sval", "N/A")
+        return "N/A"
+
+    @staticmethod
+    def _is_valid_compound_input(user_input: str) -> bool:
         """
         Determines whether the user input is a valid chemical compound identifier.
         Accepts both conventional compound names and SMILES strings.
@@ -106,11 +136,11 @@ class PharmaResearchEngine:
         if any(term in input_lower for term in disease_terms):
             return False
         
-        # Check for SMILES-specific characters (e.g., '=', '(', ')', '#')
+        # If the input contains characters common in SMILES (e.g., '=', '(', ')', '#'), treat as SMILES.
         if re.search(r"[=\(\)#]", user_input):
             return True
         
-        # If input is alphanumeric (with spaces or hyphens), assume it's a valid compound name.
+        # Otherwise, if input is alphanumeric with spaces or hyphens, assume it's a valid compound name.
         if re.match(r'^[A-Za-z0-9\s\-]+$', user_input):
             return True
         
@@ -121,79 +151,94 @@ class PharmaResearchEngine:
 # -----------------------------
 class ClinicalIntelligence:
     """
-    Module for clinical trial and regulatory intelligence using fallback data.
+    Module for clinical trial and regulatory intelligence.
+    Provides deep insights into trial landscapes and FDA approval data.
     """
     
     def __init__(self):
         self.engine = PharmaResearchEngine()
     
-    def get_trial_landscape(self, query: str) -> list:
-        """
-        Retrieve clinical trial information using fallback data.
-        If the query matches a known identifier, return fallback data.
-        """
-        # Simulate API call (which always fails in this offline mode)
-        trials = self.engine.api_request("https://clinicaltrials.fakeendpoint/api", params={"query": query})
-        
-        # Use fallback data if the query (e.g., "nct1") exists in our fallback dataset.
-        key = query.lower().strip()
-        if key in FALLBACK_CLINICAL_DATA:
-            logger.info(f"Using fallback clinical trial data for query '{query}'.")
-            return FALLBACK_CLINICAL_DATA[key]
-        else:
-            logger.error(f"No clinical trial data available for query '{query}'.")
+    def get_trial_landscape(self, query: str) -> List[Dict]:
+        params = {"query.term": query, "retmax": 10} if not query.startswith("NCT") else {"id": query}
+        trials = self.engine.api_request(API_ENDPOINTS["clinical_trials"], params=params)
+        if trials is None:
+            logger.error(f"Clinical trial API returned no data for query: {query}")
             st.error("Failed to retrieve clinical trials. Please try a different query or check your network connection.")
             return []
+        return trials.get("studies", [])[:5]
+
+    def get_fda_approval(self, drug_name: str) -> Optional[Dict]:
+        if not OPENFDA_KEY:
+            st.error("OpenFDA API key not configured.")
+            return None
+        
+        params = {
+            "api_key": OPENFDA_KEY,
+            "search": f'openfda.brand_name:"{drug_name}"',
+            "limit": 1
+        }
+        data = self.engine.api_request(API_ENDPOINTS["fda_drug_approval"], params=params)
+        if data and data.get("results"):
+            return data["results"][0]
+        logger.warning(f"No FDA data found for drug: {drug_name}")
+        st.error("No FDA regulatory data found for the specified drug.")
+        return None
 
 class AIDrugInnovator:
     """
-    Simulated AI module for generating drug development strategies.
-    In this offline mode, a pre-defined strategy is returned.
+    GPT-4 powered module for generating advanced, cutting-edge drug development strategies.
     """
     
     def __init__(self):
         self.engine = PharmaResearchEngine()
         
     def generate_strategy(self, target: str, strategy: str) -> str:
-        """
-        Return a robust, pre-defined strategic blueprint for drug development.
-        """
-        # Here, we simulate the GPT-4 response with a comprehensive text.
-        simulated_response = f"""
-# First-in-Class Strategy for {target.title()}
+        prompt = f"""As the Chief Scientific Officer at a leading pharmaceutical company, please develop a {strategy} strategy for the target: {target}.
+        
+**Target Validation Approach**  
+- Perform an exhaustive literature review to understand the molecular basis of the disease.  
+- Validate targets using in vitro and in vivo models.  
+- Integrate genomic and proteomic data to identify actionable targets.  
+- Collaborate with top-tier academic and clinical institutions.
 
-## Target Validation Approach
-- **Literature Review:** Perform an exhaustive review to understand the molecular underpinnings of {target}.
-- **Preclinical Models:** Validate targets using state-of-the-art in vitro and in vivo models.
-- **Omics Integration:** Leverage genomic, proteomic, and metabolomic data to pinpoint actionable targets.
-- **Collaborative Research:** Engage with leading academic and clinical institutions for validation.
+**Lead Optimization Tactics**  
+- Conduct chemical optimization to improve potency, selectivity, and pharmacokinetic properties.  
+- Utilize high-throughput screening and biological assays for iterative lead refinement.  
+- Perform rigorous in vivo efficacy and safety evaluations.  
+- Secure intellectual property through comprehensive patent landscaping.
 
-## Lead Optimization Tactics
-- **Chemical Optimization:** Refine lead compounds to improve potency, selectivity, and pharmacokinetic profiles.
-- **High-Throughput Screening:** Utilize cutting-edge assays for iterative lead refinement.
-- **In Vivo Efficacy:** Conduct rigorous animal studies to assess efficacy and safety.
-- **Patent Strategy:** Secure intellectual property with comprehensive patent landscaping.
+**Clinical Trial Design**  
+- Initiate Phase I trials focused on safety and dosage determination.  
+- Scale to Phase II for efficacy and side-effect profiling in a broader patient cohort.  
+- Execute large-scale Phase III trials to validate clinical benefits against current standards of care.  
+- Plan for Phase IV post-marketing surveillance for long-term outcome assessment.  
+- Incorporate adaptive trial designs to enhance responsiveness and efficiency.
 
-## Clinical Trial Design
-- **Phase I:** Safety and dosage trials with a focus on pharmacodynamics.
-- **Phase II:** Efficacy and side-effect profiling in an expanded cohort.
-- **Phase III:** Large-scale trials comparing with the current standard of care.
-- **Phase IV:** Post-marketing surveillance for long-term outcomes.
-- **Adaptive Designs:** Employ adaptive and basket trial designs to optimize trial efficiency.
+**Regulatory Pathway Analysis**  
+- Engage in early pre-IND consultations with regulatory authorities.  
+- Prepare robust IND submissions incorporating comprehensive preclinical data.  
+- Maintain continuous dialogue with regulators throughout clinical development.  
+- Strategize for expedited review pathways (e.g., Fast Track, Breakthrough Therapy).
 
-## Regulatory Pathway Analysis
-- **Pre-IND Consultation:** Early engagement with regulatory bodies to align on requirements.
-- **IND Preparation:** Develop robust IND submissions incorporating all preclinical data.
-- **Continuous Dialogue:** Maintain proactive communication with regulators throughout development.
-- **Expedited Programs:** Explore Fast Track and Breakthrough Therapy designations.
+**Commercial Potential Assessment**  
+- Conduct detailed market research to understand the competitive landscape and unmet needs.  
+- Segment patient populations to tailor therapeutic approaches.  
+- Devise dynamic pricing and reimbursement strategies aligned with payer requirements.  
+- Formulate a comprehensive go-to-market plan leveraging multi-channel marketing strategies.
 
-## Commercial Potential Assessment
-- **Market Research:** Conduct deep-dive analyses into market size, competition, and unmet needs.
-- **Patient Segmentation:** Identify target patient populations for tailored therapeutic approaches.
-- **Pricing & Reimbursement:** Develop dynamic pricing strategies and secure payer alignment.
-- **Go-To-Market:** Formulate a comprehensive multi-channel marketing strategy.
-"""
-        return simulated_response
+Please format your response in Markdown with clear section headers."""
+        try:
+            response = self.engine.openai_client.chat.completions.create(
+                model="gpt-4",
+                messages=[{"role": "user", "content": prompt}],
+                temperature=0.7,
+                max_tokens=1500
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            logger.error(f"AI Strategy Generation Error: {str(e)}")
+            st.error("Failed to generate strategy. Please check the API configuration or try again later.")
+            return "Strategy generation failed due to an internal error."
 
 # -----------------------------
 # STREAMLIT INTERFACE
@@ -201,13 +246,12 @@ class AIDrugInnovator:
 class PharmaResearchInterface:
     """
     Next-generation Streamlit interface for the Pharma Research Intelligence Suite.
-    Uses fallback and scraped data to simulate a fully operational research platform.
+    Provides an integrated, intuitive dashboard for advanced pharmaceutical data analytics and AI-driven strategy generation.
     """
     
     def __init__(self):
         self.clinical_intel = ClinicalIntelligence()
         self.ai_innovator = AIDrugInnovator()
-        self.engine = PharmaResearchEngine()
         self._configure_page()
 
     def _configure_page(self):
@@ -218,8 +262,8 @@ class PharmaResearchInterface:
         )
         st.markdown("""
             <style>
-            .main {background-color: #f0f2f6; padding: 20px;}
-            .stAlert {padding: 20px; font-size: 1.1em;}
+            .main {background-color: #f0f2f6;}
+            .stAlert {padding: 20px;}
             .reportview-container .markdown-text-container {font-family: 'Helvetica Neue', Arial, sans-serif}
             </style>
             """, unsafe_allow_html=True)
@@ -252,7 +296,8 @@ class PharmaResearchInterface:
         col1, col2 = st.columns([1, 3])
         with col1:
             target = st.text_input("Target Pathobiology:", placeholder="e.g., EGFR mutant NSCLC")
-            strategy = st.selectbox("Development Paradigm:", ["First-in-class", "Fast-follower", "Biologic", "ADC", "Gene Therapy"])
+            strategy = st.selectbox("Development Paradigm:", 
+                                     ["First-in-class", "Fast-follower", "Biologic", "ADC", "Gene Therapy"])
             if st.button("Generate Development Blueprint"):
                 with st.spinner("Formulating strategic plan..."):
                     blueprint = self.ai_innovator.generate_strategy(target, strategy)
@@ -265,8 +310,20 @@ class PharmaResearchInterface:
             with st.spinner("Fetching trial data..."):
                 trials = self.clinical_intel.get_trial_landscape(trial_query)
                 if trials:
-                    st.subheader("Top Clinical Trials")
-                    df = pd.DataFrame(trials)
+                    st.subheader("Top 5 Clinical Trials")
+                    trial_data = []
+                    for study in trials:
+                        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", ["N/A"])[0]
+                        enrollment = study.get("protocolSection", {}).get("designModule", {}).get("enrollmentInfo", {}).get("count", "N/A")
+                        trial_data.append({
+                            "Title": title,
+                            "Status": status,
+                            "Phase": phase,
+                            "Enrollment": enrollment
+                        })
+                    df = pd.DataFrame(trial_data)
                     st.dataframe(df)
                     st.subheader("Trial Phase Distribution")
                     phase_counts = df["Phase"].value_counts()
@@ -283,13 +340,13 @@ class PharmaResearchInterface:
         compound = st.text_input("Analyze Compound:", placeholder="Enter drug name or SMILES (e.g., Aspirin, CC(=O)OC1=CC=CC=C1C(=O)O)")
         if st.button("Profile Compound"):
             with st.spinner("Decoding molecular profile..."):
-                profile = self.engine.get_compound_profile(compound)
+                profile = PharmaResearchEngine().get_compound_profile(compound)
                 if profile:
                     col1, col2 = st.columns(2)
                     with col1:
                         st.subheader("Structural Insights")
                         smiles = profile.get('canonical_smiles', '')
-                        mol = Chem.MolFromSmiles(smiles) if smiles and smiles != "N/A" else None
+                        mol = Chem.MolFromSmiles(smiles) if smiles != "N/A" else None
                         if mol:
                             img = Draw.MolToImage(mol, size=(400, 300))
                             st.image(img, caption="2D Molecular Structure")
@@ -306,22 +363,20 @@ class PharmaResearchInterface:
 
     def _regulatory_hub(self):
         st.header("Regulatory Intelligence Hub")
-        st.write("Gain insights into FDA approvals and regulatory pathways (using local sample data).")
+        st.write("Gain insights into FDA approvals and regulatory pathways.")
         drug_name = st.text_input("Enter Drug Name for Regulatory Analysis:", placeholder="e.g., Aspirin")
         if st.button("Fetch Regulatory Data"):
-            # Since no API is available, we simulate regulatory data.
-            sample_regulatory_data = {
-                "drug_name": drug_name,
-                "approval_status": "Approved",
-                "approval_date": "1985-07-01",
-                "label": "Sample regulatory label information."
-            }
-            st.subheader("FDA Approval Details")
-            st.json(sample_regulatory_data)
+            with st.spinner("Retrieving regulatory information..."):
+                fda_data = self.clinical_intel.get_fda_approval(drug_name)
+                if fda_data:
+                    st.subheader("FDA Approval Details")
+                    st.json(fda_data)
+                else:
+                    st.warning("No FDA regulatory data found for the specified drug.")
 
     def _ai_strategist(self):
         st.header("AI Drug Development Strategist")
-        st.write("Leverage simulated GPT-4 to generate cutting-edge drug development strategies.")
+        st.write("Leverage GPT-4 to generate cutting-edge drug development strategies.")
         target = st.text_input("Enter Target Disease or Pathway:", placeholder="e.g., KRAS G12C mutation")
         if st.button("Generate AI Strategy"):
             with st.spinner("Generating AI-driven strategy..."):
@@ -333,4 +388,4 @@ class PharmaResearchInterface:
 # -----------------------------
 if __name__ == "__main__":
     interface = PharmaResearchInterface()
-    interface.render()
+    interface.render()