Update app.py

app.py

@@ -1,3 +1,11 @@
+"""
+Pharma Research Intelligence Suite (PRIS)
+A Next-Generation Platform for AI-Driven Drug Discovery and Development
+"""
+
+# -----------------------------
+# IMPORTS & CONFIGURATION
+# -----------------------------
 import streamlit as st
 import requests
 from rdkit import Chem
@@ -5,276 +13,347 @@ from rdkit.Chem import Draw
 import pandas as pd
 import matplotlib.pyplot as plt
 import seaborn as sns
+from fpdf import FPDF
+import tempfile
+import logging
+import os
+import plotly.graph_objects as go
+import networkx as nx
+from typing import Optional, Dict, List, Any, Tuple
 from openai import OpenAI
-from typing import Optional, Dict, List, Any
 
-# ======================
-# Configuration
-# ======================
-st.set_page_config(
-    page_title="PRIS 2.0 - Pharma Research Platform",
-    page_icon="🧬",
-    layout="wide"
+# Configure professional logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[logging.FileHandler("pris_debug.log")]
 )
+logger = logging.getLogger("PRIS")
 
-# ======================
-# API Configuration
-# ======================
-CLINICAL_TRIALS_API = "https://clinicaltrials.gov/api/v2/studies"
-FDA_API = "https://api.fda.gov/drug/label.json"
-PUBCHEM_API = "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{}/JSON"
+# -----------------------------
+# GLOBAL CONSTANTS
+# -----------------------------
+API_ENDPOINTS = {
+    # Clinical Data Services
+    "clinical_trials": "https://clinicaltrials.gov/api/v2/studies",
+    "fda_drug_approval": "https://api.fda.gov/drug/label.json",
+    "faers_adverse_events": "https://api.fda.gov/drug/event.json",
+    
+    # Chemical & Biological Data
+    "pubchem": "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{}/JSON",
+    "pubmed": "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi",
+    
+    # Pharmacogenomics Resources
+    "pharmgkb_variant_clinical_annotations": "https://api.pharmgkb.org/v1/data/variant/{}/clinicalAnnotations",
+    "pharmgkb_gene": "https://api.pharmgkb.org/v1/data/gene/{}",
+    "pharmgkb_gene_variants": "https://api.pharmgkb.org/v1/data/gene/{}/variants",
+    
+    # Semantic Medical Resources
+    "bioportal_search": "https://data.bioontology.org/search",
+    
+    # Drug Classification Systems
+    "rxnorm_rxcui": "https://rxnav.nlm.nih.gov/REST/rxcui.json",
+    "rxnorm_properties": "https://rxnav.nlm.nih.gov/REST/rxcui/{}/properties.json",
+    "rxclass_by_drug": "https://rxnav.nlm.nih.gov/REST/class/byDrugName.json"
+}
 
-# ======================
-# Core Services
-# ======================
-class PharmaResearchService:
-    """Enterprise API integration layer with advanced resilience"""
+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"]
     
-    def __init__(self):
-        self.session = requests.Session()
-        self.session.headers.update({
-            "User-Agent": "PRIS/2.0 (Enterprise Pharma Analytics)",
-            "Accept": "application/json"
-        })
+    # Validate essential configurations
+    if not all([OPENAI_API_KEY, BIOPORTAL_API_KEY, PUB_EMAIL, OPENFDA_KEY]):
+        raise APIConfigurationError("Missing one or more required API credentials")
+        
+except (KeyError, APIConfigurationError) as e:
+    st.error(f"Critical configuration error: {str(e)}")
+    st.stop()
+
+# -----------------------------
+# CORE INFRASTRUCTURE
+# -----------------------------
+class PharmaResearchEngine:
+    """Core engine for pharmaceutical data integration and analysis"""
     
-    def get_clinical_trials(self, query: str) -> List[Dict]:
-        """Get clinical trials with robust error handling"""
+    def __init__(self):
+        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 advanced resilience"""
         try:
-            response = self.session.get(
-                CLINICAL_TRIALS_API,
-                params={"query": query, "format": "json", "limit": 5},
-                timeout=10
+            response = requests.get(
+                endpoint,
+                params=params,
+                headers={**DEFAULT_HEADERS, **(headers or {})},
+                timeout=(3.05, 15)
             )
             response.raise_for_status()
-            data = response.json()
-            return data.get("studies", [])[:5]
+            return response.json()
+        except requests.exceptions.HTTPError as e:
+            logger.error(f"HTTP Error {e.response.status_code} for {endpoint}")
+            st.error(f"API Error: {e.response.status_code} - {e.response.reason}")
         except Exception as e:
-            st.error(f"Clinical trials API error: {str(e)}")
-            return []
+            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) -> Optional[Dict]:
+        """Retrieve comprehensive chemical profile"""
+        pubchem_data = self.api_request(
+            API_ENDPOINTS["pubchem"].format(identifier)
+        )
+        
+        if not pubchem_data or not pubchem_data.get("PC_Compounds"):
+            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 _extract_property(self, compound: Dict, prop_name: str) -> str:
+        """Helper for property extraction from PubChem data"""
+        for prop in compound.get("props", []):
+            if prop.get("urn", {}).get("label") == prop_name:
+                return prop["value"]["sval"]
+        return "N/A"
+
+# -----------------------------
+# INTELLIGENCE MODULES
+# -----------------------------
+class ClinicalIntelligence:
+    """Handles clinical trial and regulatory data analysis"""
+    
+    def __init__(self):
+        self.engine = PharmaResearchEngine()
+    
+    def get_trial_landscape(self, query: str) -> List[Dict]:
+        """Analyze clinical trial landscape for given query"""
+        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)
+        return trials.get("studies", [])[:5]
 
     def get_fda_approval(self, drug_name: str) -> Optional[Dict]:
-        """Retrieve FDA approval information"""
-        try:
-            response = self.session.get(
-                FDA_API,
-                params={
-                    "api_key": st.secrets["OPENFDA_KEY"],
-                    "search": f'openfda.brand_name:"{drug_name}"',
-                    "limit": 1
-                },
-                timeout=10
-            )
-            response.raise_for_status()
-            data = response.json()
-            return data.get("results", [None])[0]
-        except Exception as e:
-            st.error(f"FDA API error: {str(e)}")
+        """Retrieve FDA approval information for a drug"""
+        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]
+        return None
 
-    def get_compound_data(self, name: str) -> Optional[Dict]:
-        """Get PubChem compound data"""
+class AIDrugInnovator:
+    """GPT-4 powered drug development strategist"""
+    
+    def __init__(self):
+        self.engine = PharmaResearchEngine()
+        
+    def generate_strategy(self, target: str, strategy: str) -> str:
+        """Generate AI-driven development strategy"""
+        prompt = f"""As Chief Scientific Officer of a top pharmaceutical company, develop a {strategy} strategy for {target}.
+        Include:
+        - Target validation approach
+        - Lead optimization tactics
+        - Clinical trial design
+        - Regulatory pathway analysis
+        - Commercial potential assessment
+        Format in Markdown with clear sections."""
+        
         try:
-            response = self.session.get(
-                PUBCHEM_API.format(name),
-                timeout=10
+            response = self.engine.openai_client.chat.completions.create(
+                model="gpt-4",
+                messages=[{"role": "user", "content": prompt}],
+                temperature=0.7,
+                max_tokens=1500
             )
-            response.raise_for_status()
-            data = response.json()
-            return data.get("PC_Compounds", [{}])[0]
+            return response.choices[0].message.content
         except Exception as e:
-            st.error(f"PubChem API error: {str(e)}")
-            return None
+            logger.error(f"AI Strategy Error: {str(e)}")
+            return "Strategy generation failed. Please check API configuration."
 
-# ======================
-# UI Components
-# ======================
-class PharmaDashboard:
-    """Professional pharmaceutical research dashboard"""
+# -----------------------------
+# STREAMLIT INTERFACE
+# -----------------------------
+class PharmaResearchInterface:
+    """Modern UI for pharmaceutical research platform"""
     
     def __init__(self):
-        self.service = PharmaResearchService()
-        self._configure_styles()
-    
-    def _configure_styles(self):
-        """Inject custom CSS for professional appearance"""
+        self.clinical_intel = ClinicalIntelligence()
+        self.ai_innovator = AIDrugInnovator()
+        self._configure_page()
+
+    def _configure_page(self):
+        """Setup Streamlit page configuration"""
+        st.set_page_config(
+            page_title="PRIS - Pharma Research Intelligence Suite",
+            layout="wide",
+            initial_sidebar_state="expanded"
+        )
         st.markdown("""
             <style>
-            .main {background-color: #f8f9fa;}
-            .block-container {padding-top: 2rem;}
-            .header {color: #2c3e50; border-bottom: 2px solid #3498db;}
-            .metric {background-color: white; padding: 1.5rem; border-radius: 10px; box-shadow: 0 2px 4px rgba(0,0,0,0.1);}
-            .plot-container {background-color: white; padding: 1rem; border-radius: 10px; margin-top: 1rem;}
+            .main {background-color: #f9f9f9;}
+            .stAlert {padding: 20px;}
+            .reportview-container .markdown-text-container {font-family: 'Arial'}
             </style>
-        """, unsafe_allow_html=True)
-    
+            """, unsafe_allow_html=True)
+
     def render(self):
         """Main application interface"""
-        st.markdown("<h1 class='header'>PRIS 2.0 - Pharma Research Platform</h1>", unsafe_allow_html=True)
+        st.title("Pharma Research Intelligence Suite")
+        self._render_navigation()
         
-        tab1, tab2, tab3 = st.tabs([
-            "🧪 Compound Analyzer", 
-            "📊 Clinical Trials", 
-            "📜 Regulatory Info"
+    def _render_navigation(self):
+        """Dynamic tab-based navigation system"""
+        tabs = st.tabs([
+            "🚀 Drug Innovation",
+            "📈 Trial Analytics",
+            "🧪 Compound Profiler",
+            "📜 Regulatory Hub",
+            "🤖 AI Strategist"
         ])
         
-        with tab1:
-            self._render_compound_analyzer()
-        with tab2:
-            self._render_clinical_trials()
-        with tab3:
-            self._render_regulatory_info()
-    
-    def _render_compound_analyzer(self):
-        """Compound analysis section"""
-        st.subheader("Molecular Analysis")
-        col1, col2 = st.columns([1, 2])
-        
-        with col1:
-            compound = st.text_input("Enter compound name:", "Aspirin")
-            if st.button("Analyze"):
-                with st.spinner("Analyzing compound..."):
-                    data = self.service.get_compound_data(compound)
-                    if data:
-                        self._display_compound_info(data)
-                    else:
-                        st.warning("Compound not found")
+        with tabs[0]: self._drug_innovation()
+        with tabs[1]: self._trial_analytics()
+        with tabs[2]: self._compound_profiler()
+        with tabs[3]: self._regulatory_hub()
+        with tabs[4]: self._ai_strategist()
 
-        with col2:
-            if "mol_image" in st.session_state:
-                st.image(st.session_state.mol_image, caption="Molecular Structure")
-    
-    def _display_compound_info(self, data: Dict):
-        """Show compound information"""
-        properties = self._extract_properties(data)
+    def _drug_innovation(self):
+        """Drug development strategy interface"""
+        st.header("AI-Powered Drug Innovation Engine")
+        col1, col2 = st.columns([1, 3])
         
-        col1, col2, col3 = st.columns(3)
         with col1:
-            st.markdown(f"**Molecular Formula**  \n{properties['formula']}")
-        with col2:
-            st.markdown(f"**Molecular Weight**  \n{properties['weight']}")
-        with col3:
-            st.markdown(f"**IUPAC Name**  \n{properties['iupac']}")
-        
-        # Generate molecular structure
-        mol = Chem.MolFromSmiles(properties['smiles'])
-        if mol:
-            img = Draw.MolToImage(mol, size=(400, 300))
-            st.session_state.mol_image = img
-    
-    def _extract_properties(self, data: Dict) -> Dict:
-        """Extract chemical properties from PubChem data"""
-        return {
-            "formula": next(
-                (p["value"]["sval"] for p in data.get("props", []) 
-                 if p.get("urn", {}).get("label") == "Molecular Formula"),
-                "N/A"
-            ),
-            "weight": next(
-                (p["value"]["sval"] for p in data.get("props", [])
-                 if p.get("urn", {}).get("label") == "Molecular Weight"),
-                "N/A"
-            ),
-            "iupac": next(
-                (p["value"]["sval"] for p in data.get("props", [])
-                 if p.get("urn", {}).get("name") == "Preferred"),
-                "N/A"
-            ),
-            "smiles": next(
-                (p["value"]["sval"] for p in data.get("props", [])
-                 if p.get("name") == "Canonical SMILES"),
-                "N/A"
-            )
-        }
-    
-    def _render_clinical_trials(self):
-        """Clinical trials analysis section"""
-        st.subheader("Clinical Trial Explorer")
-        query = st.text_input("Search for trials:", "Diabetes")
+            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"])
+            if st.button("Generate Development Blueprint"):
+                with st.spinner("Formulating strategic plan..."):
+                    blueprint = self.ai_innovator.generate_strategy(target, strategy)
+                    st.markdown(blueprint, unsafe_allow_html=True)
+
+    def _trial_analytics(self):
+        """Clinical trial analytics interface"""
+        st.header("Clinical Trial Landscape Analysis")
+        trial_query = st.text_input("Search Clinical Trials:", placeholder="Enter condition, intervention, or NCT number")
         
-        if st.button("Search Trials"):
-            with st.spinner("Searching clinical trials..."):
-                trials = self.service.get_clinical_trials(query)
+        if st.button("Analyze Trial Landscape"):
+            with st.spinner("Fetching trial data..."):
+                trials = self.clinical_intel.get_trial_landscape(trial_query)
+                
                 if trials:
-                    self._display_trial_results(trials)
+                    st.subheader("Top 5 Clinical Trials")
+                    trial_data = []
+                    for study in trials:
+                        trial_data.append({
+                            "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")
+                        })
+                    
+                    # Display as a DataFrame
+                    df = pd.DataFrame(trial_data)
+                    st.dataframe(df)
+                    
+                    # Visualization
+                    st.subheader("Trial Phase Distribution")
+                    phase_counts = df["Phase"].value_counts()
+                    fig, ax = plt.subplots()
+                    sns.barplot(x=phase_counts.index, y=phase_counts.values, ax=ax)
+                    ax.set_xlabel("Trial Phase")
+                    ax.set_ylabel("Number of Trials")
+                    st.pyplot(fig)
                 else:
-                    st.warning("No trials found for this query")
-    
-    def _display_trial_results(self, trials: List[Dict]):
-        """Display clinical trial results"""
-        df = pd.DataFrame([{
-            "NCT ID": t.get("protocolSection", {}).get("identificationModule", {}).get("nctId", "N/A"),
-            "Title": t.get("protocolSection", {}).get("identificationModule", {}).get("briefTitle", "N/A"),
-            "Status": t.get("protocolSection", {}).get("statusModule", {}).get("overallStatus", "N/A"),
-            "Phase": self._parse_phase(t),
-            "Enrollment": t.get("protocolSection", {}).get("designModule", {}).get("enrollmentInfo", {}).get("count", "N/A")
-        } for t in trials])
-        
-        st.dataframe(
-            df,
-            use_container_width=True,
-            hide_index=True,
-            column_config={
-                "NCT ID": st.column_config.TextColumn(width="medium"),
-                "Title": st.column_config.TextColumn(width="large"),
-                "Status": st.column_config.TextColumn(width="small"),
-                "Phase": st.column_config.TextColumn(width="small"),
-                "Enrollment": st.column_config.NumberColumn(format="%d")
-            }
-        )
+                    st.warning("No clinical trials found for the query.")
+
+    def _compound_profiler(self):
+        """Advanced chemical analysis interface"""
+        st.header("Multi-Omics Compound Profiler")
+        compound = st.text_input("Analyze Compound:", placeholder="Enter drug name or SMILES")
         
-        # Phase distribution visualization
-        st.subheader("Trial Phase Distribution")
-        self._plot_phase_distribution(df)
-    
-    def _parse_phase(self, trial: Dict) -> str:
-        """Extract and format trial phase"""
-        phases = trial.get("protocolSection", {}).get("designModule", {}).get("phases", [])
-        return phases[0] if phases else "N/A"
-    
-    def _plot_phase_distribution(self, df: pd.DataFrame):
-        """Create phase distribution visualization"""
-        fig, ax = plt.subplots(figsize=(8, 4))
-        sns.countplot(
-            data=df,
-            x="Phase",
-            order=sorted(df["Phase"].unique()),
-            palette="Blues_d",
-            ax=ax
-        )
-        ax.set_title("Clinical Trial Phases")
-        ax.set_xlabel("")
-        ax.set_ylabel("Number of Trials")
-        st.pyplot(fig)
-    
-    def _render_regulatory_info(self):
-        """Regulatory information section"""
-        st.subheader("Regulatory Intelligence")
-        drug_name = st.text_input("Enter drug name:", "Aspirin")
+        if compound:
+            with st.spinner("Decoding molecular profile..."):
+                profile = PharmaResearchEngine().get_compound_profile(compound)
+                
+            if profile:
+                col1, col2 = st.columns(2)
+                with col1:
+                    st.subheader("Structural Insights")
+                    mol = Chem.MolFromSmiles(profile['canonical_smiles'])
+                    if mol:
+                        img = Draw.MolToImage(mol, size=(400, 300))
+                        st.image(img, caption="2D Molecular Structure")
+                
+                with col2:
+                    st.subheader("Physicochemical Profile")
+                    st.metric("Molecular Weight", profile['molecular_weight'])
+                    st.metric("LogP", profile['logp'])
+                    st.metric("IUPAC Name", profile['iupac_name'])
+                    st.code(f"SMILES: {profile['canonical_smiles']}")
+
+    def _regulatory_hub(self):
+        """Regulatory intelligence interface"""
+        st.header("Regulatory Intelligence Hub")
+        st.write("This section provides 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("Search Regulatory Data"):
-            with st.spinner("Retrieving FDA information..."):
-                fda_data = self.service.get_fda_approval(drug_name)
+        if st.button("Fetch Regulatory Data"):
+            with st.spinner("Retrieving regulatory information..."):
+                fda_data = self.clinical_intel.get_fda_approval(drug_name)
                 if fda_data:
-                    self._display_fda_info(fda_data)
+                    st.subheader("FDA Approval Details")
+                    st.json(fda_data)
                 else:
-                    st.warning("No FDA data found for this drug")
-    
-    def _display_fda_info(self, data: Dict):
-        """Display FDA approval information"""
-        openfda = data.get("openfda", {})
-        st.markdown(f"""
-            **Brand Name**: {', '.join(openfda.get('brand_name', ['N/A']))}  
-            **Manufacturer**: {', '.join(openfda.get('manufacturer_name', ['N/A']))}  
-            **Approval Date**: {data.get('effective_time', 'N/A')}  
-            **Dosage Form**: {', '.join(openfda.get('dosage_form', ['N/A']))}
-        """)
+                    st.warning("No FDA data found for the specified drug.")
+
+    def _ai_strategist(self):
+        """AI-driven drug strategy interface"""
+        st.header("AI Drug Development Strategist")
+        st.write("Leverage GPT-4 for innovative drug development strategies.")
+        target = st.text_input("Enter Target Disease or Pathway:", placeholder="e.g., KRAS G12C mutation")
         
-        st.subheader("Indications and Usage")
-        st.write(data.get("indications_and_usage", ["No information available"])[0])
+        if st.button("Generate AI Strategy"):
+            with st.spinner("Generating AI-driven strategy..."):
+                strategy = self.ai_innovator.generate_strategy(target, "First-in-class")
+                st.markdown(strategy, unsafe_allow_html=True)
 
-# ======================
-# Application Entry
-# ======================
+# -----------------------------
+# MAIN EXECUTION
+# -----------------------------
 if __name__ == "__main__":
-    app = PharmaDashboard()
-    app.render()
+    interface = PharmaResearchInterface()
+    interface.render()