Update app.py

app.py

@@ -1,3 +1,18 @@
+"""
+Pharma Research Intelligence Suite (PRIS)
+==========================================
+A Next-Generation, AI-Integrated Platform for Accelerating Drug Discovery and Development
+
+This module integrates clinical, chemical, and regulatory data streams with advanced AI analysis
+to provide a comprehensive toolset for pharmaceutical research. The platform is built on a robust
+architecture to support multi-omics compound profiling, clinical trial analytics, regulatory intelligence,
+and AI-driven drug innovation strategies.
+
+Author: [Your Name]
+Date: 2025-01-31
+"""
+
+# -----------------------------
 # IMPORTS & CONFIGURATION
 # -----------------------------
 import streamlit as st
@@ -7,30 +22,54 @@ 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 re
-from typing import Optional, Dict, List, Any
+import os
+import plotly.graph_objects as go
+import networkx as nx
+from typing import Optional, Dict, List, Any, Tuple
 from openai import OpenAI
 
-# Configure advanced logging for full traceability and diagnostics
+# Advanced logging configuration: capturing detailed operational logs for debugging and audit trails.
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[logging.FileHandler("pris_debug.log"), logging.StreamHandler()]
+    handlers=[
+        logging.FileHandler("pris_debug.log", mode='w'),
+        logging.StreamHandler()
+    ]
 )
 logger = logging.getLogger("PRIS")
 
 # -----------------------------
 # GLOBAL CONSTANTS
 # -----------------------------
-API_ENDPOINTS = {
+API_ENDPOINTS: Dict[str, str] = {
+    # 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",
-    # ... other endpoints omitted for brevity ...
+    "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"
 }
 
-DEFAULT_HEADERS = {
+DEFAULT_HEADERS: Dict[str, str] = {
     "User-Agent": "PharmaResearchIntelligenceSuite/1.0 (Professional Use)",
     "Accept": "application/json"
 }
@@ -39,193 +78,230 @@ DEFAULT_HEADERS = {
 # SECRETS MANAGEMENT
 # -----------------------------
 class APIConfigurationError(Exception):
-    """Custom exception for missing API configurations."""
+    """Custom exception for missing or misconfigured API credentials."""
     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"]
-    
+    # Retrieve API credentials from the secure Streamlit secrets store.
+    OPENAI_API_KEY: str = st.secrets["OPENAI_API_KEY"]
+    BIOPORTAL_API_KEY: str = st.secrets["BIOPORTAL_API_KEY"]
+    PUB_EMAIL: str = st.secrets["PUB_EMAIL"]
+    OPENFDA_KEY: str = st.secrets["OPENFDA_KEY"]
+
+    # Ensure that all essential API keys are present.
     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)}")
+    logger.critical(f"Configuration error: {str(e)}")
     st.stop()
 
 # -----------------------------
 # CORE INFRASTRUCTURE
 # -----------------------------
 class PharmaResearchEngine:
-    """Core engine for integrating diverse pharmaceutical datasets and performing advanced analyses."""
+    """
+    Core engine for integrating and analyzing pharmaceutical data.
+    
+    This engine provides utility functions for API requests and chemical data extraction,
+    facilitating the seamless integration of multi-omics and clinical datasets.
+    """
     
-    def __init__(self):
+    def __init__(self) -> None:
+        # Initialize the OpenAI client with the provided API key.
         self.openai_client = OpenAI(api_key=OPENAI_API_KEY)
-        
+        logger.info("PharmaResearchEngine initialized with OpenAI client.")
+    
     @staticmethod
     def api_request(endpoint: str, 
-                    params: Optional[Dict] = None,
-                    headers: Optional[Dict] = None) -> Optional[Dict]:
+                    params: Optional[Dict[str, Any]] = None,
+                    headers: Optional[Dict[str, str]] = None) -> Optional[Dict[str, Any]]:
         """
-        Enterprise-grade API request handler with detailed error logging.
+        Perform a resilient API GET request.
+        
+        Args:
+            endpoint (str): The URL endpoint for the API.
+            params (Optional[Dict[str, Any]]): Query parameters to be included in the request.
+            headers (Optional[Dict[str, str]]): Additional headers to include in the request.
+        
+        Returns:
+            Optional[Dict[str, Any]]: JSON response from the API, or None if an error occurs.
         """
         try:
+            logger.debug(f"Requesting data from {endpoint} with params: {params}")
             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
+            response.raise_for_status()
+            logger.info(f"Successful API request to {endpoint}")
             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 requests.exceptions.HTTPError as http_err:
+            logger.error(f"HTTP Error {http_err.response.status_code} for {endpoint}: {http_err}")
+            st.error(f"API HTTP Error: {http_err.response.status_code} - {http_err.response.reason}")
         except Exception as e:
-            logger.error(f"Network error for {endpoint}: {str(e)}")
+            logger.error(f"Network error during API request to {endpoint}: {str(e)}")
             st.error(f"Network error: {str(e)}")
         return None
 
-    def get_compound_profile(self, identifier: str) -> Optional[Dict]:
+    def get_compound_profile(self, identifier: str) -> Optional[Dict[str, str]]:
         """
-        Retrieve comprehensive chemical profile data from PubChem for a given compound.
-        Accepts both common compound names and SMILES strings.
+        Retrieve a comprehensive chemical profile for a given compound.
+        
+        This method queries the PubChem API using a provided identifier (name or SMILES)
+        and extracts key molecular properties.
+        
+        Args:
+            identifier (str): The compound name or SMILES string.
+        
+        Returns:
+            Optional[Dict[str, str]]: A dictionary containing molecular formula, IUPAC name,
+            canonical SMILES, molecular weight, and LogP. Returns None if data is unavailable.
         """
-        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 None
-
-        pubchem_url = API_ENDPOINTS["pubchem"].format(identifier)
-        pubchem_data = self.api_request(pubchem_url)
+        formatted_endpoint = API_ENDPOINTS["pubchem"].format(identifier)
+        logger.info(f"Fetching compound profile from PubChem for identifier: {identifier}")
+        pubchem_data = self.api_request(formatted_endpoint)
+        
         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).")
+            logger.warning("No compound data found in PubChem response.")
             return None
             
         compound = pubchem_data["PC_Compounds"][0]
-        return {
+        profile = {
             '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')
         }
+        logger.debug(f"Extracted compound profile: {profile}")
+        return profile
 
-    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:
+    def _extract_property(self, compound: Dict[str, Any], prop_name: str) -> str:
         """
-        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
-        
-        # If the input contains characters common in SMILES (e.g., '=', '(', ')', '#'), treat as SMILES.
-        if re.search(r"[=\(\)#]", user_input):
-            return True
+        Helper function to extract a specific property from PubChem compound data.
         
-        # 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
+        Args:
+            compound (Dict[str, Any]): The compound data dictionary from PubChem.
+            prop_name (str): The name of the property to extract.
         
-        return False
+        Returns:
+            str: The extracted property value as a string, or "N/A" if not found.
+        """
+        for prop in compound.get("props", []):
+            if prop.get("urn", {}).get("label") == prop_name:
+                # Attempt to return the string value regardless of underlying type.
+                return str(prop["value"].get("sval", "N/A"))
+        logger.debug(f"Property '{prop_name}' not found for compound.")
+        return "N/A"
 
 # -----------------------------
 # INTELLIGENCE MODULES
 # -----------------------------
 class ClinicalIntelligence:
     """
-    Module for clinical trial and regulatory intelligence.
-    Provides deep insights into trial landscapes and FDA approval data.
+    Module for analyzing clinical trial landscapes and regulatory data.
+    
+    This class encapsulates methods for retrieving and processing clinical trial data
+    and FDA drug approval information.
     """
     
-    def __init__(self):
+    def __init__(self) -> None:
         self.engine = PharmaResearchEngine()
+        logger.info("ClinicalIntelligence module initialized.")
     
-    def get_trial_landscape(self, query: str) -> List[Dict]:
+    def get_trial_landscape(self, query: str) -> List[Dict[str, Any]]:
+        """
+        Analyze the clinical trial landscape for a specified query.
+        
+        Args:
+            query (str): A search term (condition, intervention, or NCT number) for clinical trials.
+        
+        Returns:
+            List[Dict[str, Any]]: A list of dictionaries representing the top clinical trials.
+        """
+        # Determine appropriate parameters based on query format.
         params = {"query.term": query, "retmax": 10} if not query.startswith("NCT") else {"id": query}
+        logger.info(f"Fetching clinical trials with query: {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]
+        
+        # Safely extract and return up to the first 5 trials.
+        trial_list = trials.get("studies", [])[:5] if trials else []
+        logger.debug(f"Retrieved {len(trial_list)} clinical trials for query '{query}'")
+        return trial_list
 
-    def get_fda_approval(self, drug_name: str) -> Optional[Dict]:
+    def get_fda_approval(self, drug_name: str) -> Optional[Dict[str, Any]]:
+        """
+        Retrieve FDA approval information for a specified drug.
+        
+        Args:
+            drug_name (str): The name of the drug to query.
+        
+        Returns:
+            Optional[Dict[str, Any]]: A dictionary containing FDA approval details or None if unavailable.
+        """
         if not OPENFDA_KEY:
             st.error("OpenFDA API key not configured.")
+            logger.error("Missing OpenFDA API key.")
             return None
         
-        params = {
+        params: Dict[str, Any] = {
             "api_key": OPENFDA_KEY,
             "search": f'openfda.brand_name:"{drug_name}"',
             "limit": 1
         }
+        logger.info(f"Fetching FDA approval data for drug: {drug_name}")
         data = self.engine.api_request(API_ENDPOINTS["fda_drug_approval"], params=params)
+        
         if data and data.get("results"):
+            logger.debug(f"FDA approval data retrieved for drug: {drug_name}")
             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.")
+        logger.warning(f"No FDA approval data found for drug: {drug_name}")
         return None
 
 class AIDrugInnovator:
     """
-    GPT-4 powered module for generating advanced, cutting-edge drug development strategies.
+    AI-Driven Drug Development Strategist powered by GPT-4.
+    
+    This module leverages advanced language models to generate innovative drug development
+    strategies tailored to specific targets and therapeutic paradigms.
     """
     
-    def __init__(self):
+    def __init__(self) -> None:
         self.engine = PharmaResearchEngine()
+        logger.info("AIDrugInnovator module initialized with GPT-4 integration.")
         
     def generate_strategy(self, target: str, strategy: str) -> str:
-        prompt = f"""As the Chief Scientific Officer at a leading pharmaceutical company, please develop a {strategy} strategy for the target: {target}.
+        """
+        Generate an AI-driven development strategy.
         
-**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.
-
-**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.
-
-**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.
-
-**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).
-
-**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.
-
-Please format your response in Markdown with clear section headers."""
+        Constructs a detailed prompt for GPT-4 to generate a strategic plan including
+        target validation, lead optimization, clinical trial design, regulatory analysis,
+        and commercial potential assessment.
+        
+        Args:
+            target (str): The target disease, pathway, or biological entity.
+            strategy (str): The desired development paradigm (e.g., "First-in-class").
+        
+        Returns:
+            str: A formatted strategic blueprint in Markdown.
+        """
+        prompt: str = (
+            f"As Chief Scientific Officer at a leading pharmaceutical company, "
+            f"develop a {strategy} development strategy for the target: {target}.\n\n"
+            "Include the following sections:\n"
+            "- **Target Validation Approach:** Describe methods to confirm the target's role in the disease.\n"
+            "- **Lead Optimization Tactics:** Outline strategies for refining lead compounds.\n"
+            "- **Clinical Trial Design:** Propose innovative trial designs and endpoints.\n"
+            "- **Regulatory Pathway Analysis:** Evaluate the regulatory strategy and compliance roadmap.\n"
+            "- **Commercial Potential Assessment:** Analyze market opportunity and competitive landscape.\n\n"
+            "Please format your response in Markdown with clear, well-defined sections."
+        )
+        
+        logger.info(f"Generating AI strategy for target: {target} using paradigm: {strategy}")
         try:
             response = self.engine.openai_client.chat.completions.create(
                 model="gpt-4",
@@ -233,45 +309,61 @@ Please format your response in Markdown with clear section headers."""
                 temperature=0.7,
                 max_tokens=1500
             )
-            return response.choices[0].message.content
+            generated_strategy = response.choices[0].message.content
+            logger.debug("AI strategy generation successful.")
+            return generated_strategy
         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."
+            logger.error(f"Error during AI strategy generation: {str(e)}")
+            return "Strategy generation failed. Please check API configuration and try again."
 
 # -----------------------------
 # STREAMLIT INTERFACE
 # -----------------------------
 class PharmaResearchInterface:
     """
-    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.
+    User Interface for the Pharma Research Intelligence Suite.
+    
+    This class configures and renders the Streamlit application, providing an interactive
+    environment for exploring drug innovation, clinical trial analytics, compound profiling,
+    regulatory insights, and AI-driven strategy generation.
     """
     
-    def __init__(self):
+    def __init__(self) -> None:
         self.clinical_intel = ClinicalIntelligence()
         self.ai_innovator = AIDrugInnovator()
         self._configure_page()
+        logger.info("PharmaResearchInterface initialized and page configured.")
 
-    def _configure_page(self):
+    def _configure_page(self) -> None:
+        """
+        Configure the Streamlit page settings and apply custom CSS styles.
+        """
         st.set_page_config(
-            page_title="PRIS - Next-Generation Pharmaceutical Research Suite",
+            page_title="PRIS - Pharma Research Intelligence Suite",
             layout="wide",
             initial_sidebar_state="expanded"
         )
         st.markdown("""
             <style>
-            .main {background-color: #f0f2f6;}
-            .stAlert {padding: 20px;}
-            .reportview-container .markdown-text-container {font-family: 'Helvetica Neue', Arial, sans-serif}
+            .main {background-color: #f9f9f9; padding: 20px;}
+            .stAlert {padding: 20px; border: 1px solid #e0e0e0; border-radius: 5px; background-color: #fff;}
+            .reportview-container .markdown-text-container {font-family: 'Arial', sans-serif; line-height: 1.6;}
             </style>
             """, unsafe_allow_html=True)
+        logger.info("Streamlit page configuration completed.")
 
-    def render(self):
-        st.title("Next-Generation Pharmaceutical Research Intelligence Suite")
+    def render(self) -> None:
+        """
+        Render the complete Streamlit user interface with multiple functional tabs.
+        """
+        st.title("Pharma Research Intelligence Suite")
         self._render_navigation()
+        logger.info("User interface rendered successfully.")
         
-    def _render_navigation(self):
+    def _render_navigation(self) -> None:
+        """
+        Create a dynamic, tab-based navigation layout for different modules.
+        """
         tabs = st.tabs([
             "🚀 Drug Innovation",
             "📈 Trial Analytics",
@@ -279,6 +371,7 @@ class PharmaResearchInterface:
             "📜 Regulatory Hub",
             "🤖 AI Strategist"
         ])
+        
         with tabs[0]:
             self._drug_innovation()
         with tabs[1]:
@@ -290,9 +383,13 @@ class PharmaResearchInterface:
         with tabs[4]:
             self._ai_strategist()
 
-    def _drug_innovation(self):
+    def _drug_innovation(self) -> None:
+        """
+        Render the drug innovation module that generates AI-powered development strategies.
+        """
         st.header("AI-Powered Drug Innovation Engine")
         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:", 
@@ -301,29 +398,35 @@ class PharmaResearchInterface:
                 with st.spinner("Formulating strategic plan..."):
                     blueprint = self.ai_innovator.generate_strategy(target, strategy)
                     st.markdown(blueprint, unsafe_allow_html=True)
+                    logger.info("Drug innovation strategy generated and displayed.")
 
-    def _trial_analytics(self):
+    def _trial_analytics(self) -> None:
+        """
+        Render the clinical trial analytics module to explore current trial landscapes.
+        """
         st.header("Clinical Trial Landscape Analysis")
         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(trial_query)
+                
                 if trials:
                     st.subheader("Top 5 Clinical Trials")
-                    trial_data = []
+                    trial_data: List[Dict[str, Any]] = []
                     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
+                            "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 the clinical trial data in a table.
                     df = pd.DataFrame(trial_data)
                     st.dataframe(df)
+                    
+                    # Generate and display a bar chart of trial phase distribution.
                     st.subheader("Trial Phase Distribution")
                     phase_counts = df["Phase"].value_counts()
                     fig, ax = plt.subplots()
@@ -331,60 +434,87 @@ class PharmaResearchInterface:
                     ax.set_xlabel("Trial Phase")
                     ax.set_ylabel("Number of Trials")
                     st.pyplot(fig)
+                    logger.info("Clinical trial analytics displayed successfully.")
                 else:
-                    st.warning("No clinical trials found for the provided query.")
+                    st.warning("No clinical trials found for the query.")
+                    logger.warning("No clinical trial data returned from API.")
 
-    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, CC(=O)OC1=CC=CC=C1C(=O)O)")
-        if st.button("Profile Compound"):
+    def _compound_profiler(self) -> None:
+        """
+        Render the multi-omics compound profiler module for in-depth chemical analysis.
+        """
+        st.header("Multi-Omics Compound Profiler")
+        compound = st.text_input("Analyze Compound:", placeholder="Enter drug name or SMILES")
+        
+        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")
-                        smiles = profile.get('canonical_smiles', '')
-                        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")
-                        else:
-                            st.error("Could not generate molecular structure image. Verify the SMILES string or compound name.")
-                    with col2:
-                        st.subheader("Physicochemical Profile")
-                        st.metric("Molecular Weight", profile.get('molecular_weight', "N/A"))
-                        st.metric("LogP", profile.get('logp', "N/A"))
-                        st.metric("IUPAC Name", profile.get('iupac_name', "N/A"))
-                        st.code(f"SMILES: {profile.get('canonical_smiles', 'N/A')}")
-                else:
-                    st.warning("Compound profiling failed. Please ensure you have entered a valid chemical compound.")
+                
+            if profile:
+                col1, col2 = st.columns(2)
+                with col1:
+                    st.subheader("Structural Insights")
+                    mol = Chem.MolFromSmiles(profile['canonical_smiles'])
+                    if mol:
+                        # Generate and display the 2D molecular structure image.
+                        img = Draw.MolToImage(mol, size=(400, 300))
+                        st.image(img, caption="2D Molecular Structure")
+                    else:
+                        st.warning("Unable to render molecular structure from SMILES.")
+                        logger.warning("RDKit failed to create molecule from SMILES.")
+                
+                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']}")
+                    logger.info("Compound profile details rendered.")
+            else:
+                st.warning("No compound data available. Please verify the input.")
+                logger.warning("Compound profiler did not return any data.")
 
-    def _regulatory_hub(self):
+    def _regulatory_hub(self) -> None:
+        """
+        Render the regulatory intelligence hub module for accessing FDA and regulatory data.
+        """
         st.header("Regulatory Intelligence Hub")
-        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")
+        st.write("Access detailed 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"):
             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)
+                    logger.info("FDA regulatory data displayed.")
                 else:
-                    st.warning("No FDA regulatory data found for the specified drug.")
+                    st.warning("No FDA data found for the specified drug.")
+                    logger.warning("FDA regulatory data retrieval returned no results.")
 
-    def _ai_strategist(self):
+    def _ai_strategist(self) -> None:
+        """
+        Render the AI strategist module for generating innovative drug development strategies.
+        """
         st.header("AI Drug Development Strategist")
-        st.write("Leverage GPT-4 to generate cutting-edge drug development strategies.")
+        st.write("Utilize GPT-4 to craft 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..."):
                 strategy = self.ai_innovator.generate_strategy(target, "First-in-class")
                 st.markdown(strategy, unsafe_allow_html=True)
+                logger.info("AI-driven strategy generated and displayed.")
 
 # -----------------------------
 # MAIN EXECUTION
 # -----------------------------
 if __name__ == "__main__":
-    interface = PharmaResearchInterface()
-    interface.render()
+    try:
+        interface = PharmaResearchInterface()
+        interface.render()
+        logger.info("PRIS application launched successfully.")
+    except Exception as e:
+        logger.critical(f"Unexpected error during application launch: {str(e)}")
+        st.error(f"Application failed to start due to an unexpected error: {str(e)}")