Update app.py

app.py

@@ -1,123 +1,148 @@
-# -----------------------------
 # IMPORTS & CONFIGURATION
 # -----------------------------
 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 typing import Optional, Dict, List, Any
+from openai import OpenAI
 
-# Configure logging for detailed diagnostics
+# Configure advanced logging for full traceability and diagnostics
 logging.basicConfig(
     level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s',
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
     handlers=[logging.FileHandler("pris_debug.log"), logging.StreamHandler()]
 )
 logger = logging.getLogger("PRIS")
 
 # -----------------------------
-# FALLBACK / SCRAPED DATA
+# GLOBAL CONSTANTS
 # -----------------------------
-# Fallback data for compound profiling (simulated 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"
-    },
-    "ibuprofen": {
-        "molecular_formula": "C13H18O2",
-        "iupac_name": "2-(4-isobutylphenyl)propanoic acid",
-        "canonical_smiles": "CC(C)Cc1ccc(cc1)C(C)C(=O)O",
-        "molecular_weight": "206.28",
-        "logp": "3.97"
-    }
+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 (simulated scraped data)
-FALLBACK_CLINICAL_DATA = {
-    "nct1": [
-        {
-            "protocolSection": {
-                "identificationModule": {"briefTitle": "A Study of Novel Therapeutics in Diabetes"},
-                "statusModule": {"overallStatus": "Completed"},
-                "designModule": {"phases": ["Phase II"], "enrollmentInfo": {"count": "120"}}
-            }
-        },
-        {
-            "protocolSection": {
-                "identificationModule": {"briefTitle": "Evaluation of Biomarkers in Diabetic Patients"},
-                "statusModule": {"overallStatus": "Recruiting"},
-                "designModule": {"phases": ["Phase I"], "enrollmentInfo": {"count": "60"}}
-            }
-        }
-    ],
-    "cancer": [
-        {
-            "protocolSection": {
-                "identificationModule": {"briefTitle": "Immunotherapy Trials in Advanced Cancer"},
-                "statusModule": {"overallStatus": "Active, not recruiting"},
-                "designModule": {"phases": ["Phase III"], "enrollmentInfo": {"count": "250"}}
-            }
-        }
-    ]
+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 using local fallback data.
-    This engine simulates data retrieval without any external API calls.
-    """
+    """Core engine for integrating diverse pharmaceutical datasets and performing advanced analyses."""
+    
     def __init__(self):
-        # In a live system, API clients would be initialized here.
-        pass
+        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]:
+        """
+        Enterprise-grade API request handler with detailed error logging.
+        """
+        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.
-        Checks input validity and returns fallback data if available.
+        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 {}
-        
-        key = identifier.lower().strip()
-        if key in FALLBACK_COMPOUND_DATA:
-            logger.info(f"Using fallback data for compound '{identifier}'.")
-            return FALLBACK_COMPOUND_DATA[key]
-        else:
-            msg = f"No compound data found for '{identifier}'. Please verify the compound name or SMILES."
-            logger.error(msg)
-            st.error(msg)
-            return {}
+            return None
+
+        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 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 if the user input is a valid compound identifier.
+        Determines whether the user input is a valid chemical compound identifier.
+        Accepts both conventional compound names and SMILES strings.
         Rejects inputs containing known disease terms.
         """
         input_lower = user_input.lower().strip()
+        # Known disease terms that should not be processed as compounds
         disease_terms = ['diabetes', 'cancer', 'hypertension', 'asthma']
         if any(term in input_lower for term in disease_terms):
             return False
-        # Accept input with 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
-        # Otherwise, accept if input is alphanumeric with spaces/hyphens
+        
+        # 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
+        
         return False
 
 # -----------------------------
@@ -125,83 +150,105 @@ class PharmaResearchEngine:
 # -----------------------------
 class ClinicalIntelligence:
     """
-    Module for clinical trial analytics 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 data based on the query.
-        Returns fallback data if available.
-        """
-        key = query.lower().strip()
-        if key in FALLBACK_CLINICAL_DATA:
-            logger.info(f"Using fallback clinical data for query '{query}'.")
-            return FALLBACK_CLINICAL_DATA[key]
-        else:
-            msg = f"No clinical trial data available for '{query}'."
-            logger.error(msg)
-            st.error("Failed to retrieve clinical trials. Please try a different 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 that returns a pre-defined drug development strategy.
+    GPT-4 powered module for generating advanced, cutting-edge drug development strategies.
     """
+    
     def __init__(self):
-        # No external AI API is used in offline mode.
-        pass
-
+        self.engine = PharmaResearchEngine()
+        
     def generate_strategy(self, target: str, strategy: str) -> str:
-        """
-        Returns a comprehensive, simulated strategy for drug development.
-        """
-        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 of current literature to understand the molecular mechanisms of {target}.
-- **Preclinical Studies:** Validate targets using state-of-the-art in vitro and in vivo models.
-- **Omics Integration:** Analyze genomic and proteomic data to identify actionable targets.
-- **Collaborative Research:** Partner with leading academic and clinical institutions.
+**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:** Enhance lead compounds to improve potency, selectivity, and pharmacokinetics.
-- **High-Throughput Screening:** Utilize modern screening techniques for iterative lead refinement.
-- **In Vivo Efficacy:** Conduct thorough animal studies to assess safety and efficacy.
-- **Intellectual Property:** Secure robust patents through 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 studies.
-- **Phase II:** Efficacy and side-effect profiling.
-- **Phase III:** Large-scale trials comparing with current standards.
-- **Phase IV:** Post-marketing surveillance.
-- **Adaptive Designs:** Incorporate adaptive trial designs for 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:** Initiate early dialogue with regulatory authorities.
-- **IND Submission:** Prepare robust submissions with complete preclinical data.
-- **Continuous Engagement:** Maintain ongoing communication with regulators.
-- **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:** Analyze market trends and unmet needs.
-- **Patient Segmentation:** Identify target patient demographics.
-- **Pricing & Reimbursement:** Develop strategic pricing and reimbursement plans.
-- **Go-To-Market Strategy:** Formulate a comprehensive marketing and sales plan.
-"""
-        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
 # -----------------------------
 class PharmaResearchInterface:
     """
-    Streamlit interface for the Pharma Research Intelligence Suite using fallback data.
+    Next-generation Streamlit interface for the Pharma Research Intelligence Suite.
+    Provides an integrated, intuitive dashboard for advanced pharmaceutical data analytics and AI-driven strategy generation.
     """
+    
     def __init__(self):
-        self.engine = PharmaResearchEngine()
         self.clinical_intel = ClinicalIntelligence()
         self.ai_innovator = AIDrugInnovator()
         self._configure_page()
@@ -213,17 +260,17 @@ class PharmaResearchInterface:
             initial_sidebar_state="expanded"
         )
         st.markdown("""
-        <style>
-            .main {background-color: #f0f2f6; padding: 20px;}
-            .stAlert {padding: 20px; font-size: 1.1em;}
-            .reportview-container .markdown-text-container {font-family: 'Helvetica Neue', Arial, sans-serif;}
-        </style>
-        """, unsafe_allow_html=True)
+            <style>
+            .main {background-color: #f0f2f6;}
+            .stAlert {padding: 20px;}
+            .reportview-container .markdown-text-container {font-family: 'Helvetica Neue', Arial, sans-serif}
+            </style>
+            """, unsafe_allow_html=True)
 
     def render(self):
         st.title("Next-Generation Pharmaceutical Research Intelligence Suite")
         self._render_navigation()
-
+        
     def _render_navigation(self):
         tabs = st.tabs([
             "🚀 Drug Innovation",
@@ -248,20 +295,21 @@ class PharmaResearchInterface:
         col1, col2 = st.columns([1, 3])
         with col1:
             target = st.text_input("Target Pathobiology:", placeholder="e.g., EGFR mutant NSCLC")
-            paradigm = 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, paradigm)
+                    blueprint = self.ai_innovator.generate_strategy(target, strategy)
                     st.markdown(blueprint, unsafe_allow_html=True)
 
     def _trial_analytics(self):
         st.header("Clinical Trial Landscape Analysis")
-        query = st.text_input("Search Clinical Trials:", placeholder="Enter condition, intervention, or NCT number")
+        trial_query = st.text_input("Search Clinical Trials:", placeholder="Enter condition, intervention, or NCT number")
         if st.button("Analyze Trial Landscape"):
             with st.spinner("Fetching trial data..."):
-                trials = self.clinical_intel.get_trial_landscape(query)
+                trials = self.clinical_intel.get_trial_landscape(trial_query)
                 if trials:
-                    st.subheader("Top Clinical Trials")
+                    st.subheader("Top 5 Clinical Trials")
                     trial_data = []
                     for study in trials:
                         title = study.get("protocolSection", {}).get("identificationModule", {}).get("briefTitle", "N/A")
@@ -288,16 +336,16 @@ class PharmaResearchInterface:
 
     def _compound_profiler(self):
         st.header("Advanced Multi-Omics Compound Profiler")
-        compound = st.text_input("Analyze Compound:", placeholder="Enter drug name or SMILES (e.g., Aspirin)")
+        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")
@@ -314,21 +362,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"):
-            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 our simulated GPT-4 engine 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..."):
@@ -340,4 +387,4 @@ class PharmaResearchInterface:
 # -----------------------------
 if __name__ == "__main__":
     interface = PharmaResearchInterface()
-    interface.render()
+    interface.render()