Update app.py

app.py

@@ -1,193 +1,152 @@
 import streamlit as st
 import py3Dmol
 from rdkit import Chem
-from rdkit.Chem import AllChem, Draw, Descriptors, PandasTools
-from rdkit.Chem.Draw import rdMolDraw2D
+from rdkit.Chem import Draw, Descriptors, AllChem
 import pandas as pd
-import numpy as np
 import requests
-import matplotlib.pyplot as plt
-import plotly.express as px
 from PIL import Image
+import json
 from io import BytesIO
-from fpdf import FPDF
 from streamlit.components.v1 import html
-from mordred import Calculator, descriptors
 import pubchempy as pcp
-from typing import Optional, Dict, List, Any
 
-# --- Configuration ---
-st.set_page_config(page_title="PharmaAI Suite", layout="wide", page_icon="🧬")
+# --- Hugging Face Optimized Configuration ---
+st.set_page_config(page_title="PharmaAI HF", layout="wide", page_icon="🧪")
 st.markdown("""
     <style>
-        .stApp { background-color: #f0f2f6 }
-        .css-1d391kg { padding: 20px; border-radius: 10px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
-        h2 { color: #2c3e50; }
+        .stApp { background-color: #f8f9fa }
+        .block-container { padding-top: 2rem }
+        h1 { color: #1e3d59 }
+        .stButton>button { background-color: #4CAF50; color: white }
     </style>
 """, unsafe_allow_html=True)
 
-# --- API Endpoints ---
+# --- Lightweight API Config ---
 API_CONFIG = {
     "pubchem": "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{}/JSON",
-    "clinicaltrials": {
-        "url": "https://clinicaltrials.gov/api/v2/studies",
-        "params": {"format": "json"}
-    },
-    "chembl": "https://www.ebi.ac.uk/chembl/api/data/molecule?pref_name__iexact={}&format=json",
-    "uniprot": "https://rest.uniprot.org/uniprotkb/search?query={}&format=json"
+    "clinicaltrials": "https://clinicaltrials.gov/api/query/full_studies?expr={}&fmt=json",
+    "chembl": "https://www.ebi.ac.uk/chembl/api/data/molecule?pref_name__iexact={}"
 }
 
-# --- Advanced Calculators ---
-mordred_calculator = Calculator(descriptors, ignore_3D=True)
-
-# --- Core Functions ---
-def render_3d_molecule(smiles: str):
-    """Interactive 3D molecular visualization using py3Dmol"""
+# --- Core Functions with Caching ---
+@st.cache_data(ttl=3600)
+def get_pubchem_data(name):
+    try:
+        return pcp.get_compounds(name, 'name')[0]
+    except Exception as e:
+        st.error(f"PubChem error: {str(e)}")
+        return None
+
+@st.cache_data(ttl=3600)
+def get_clinical_trials(query):
+    try:
+        response = requests.get(API_CONFIG["clinicaltrials"].format(query))
+        return json.loads(response.text)["FullStudiesResponse"]["FullStudies"][:5]
+    except Exception as e:
+        st.error(f"Clinical Trials API error: {str(e)}")
+        return []
+
+def render_3d(smiles):
     viewer = py3Dmol.view(width=400, height=300)
     viewer.addModel(Chem.MolToMolBlock(Chem.MolFromSmiles(smiles)), 'smiles')
     viewer.setStyle({'stick': {}, 'sphere': {'radius': 0.3}})
     viewer.zoomTo()
     html(viewer._make_html())
 
-def calculate_molecular_properties(smiles: str):
-    """Calculate advanced molecular descriptors"""
-    mol = Chem.MolFromSmiles(smiles)
-    if mol:
-        try:
-            df = mordred_calculator.pandas([mol])
-            return df.iloc[0].to_dict()
-        except:
-            return {k: v(mol) for k, v in Descriptors.descList}
-
-def predict_admet(smiles: str):
-    """Placeholder for actual ADMET prediction model"""
-    return {
-        'BBB_Permeant': np.random.choice([True, False]),
-        'CYP2D6_Inhibitor': np.random.choice([True, False]),
-        'AMES_Toxicity': np.random.choice([True, False])
-    }
-
-def quantum_simulation(smiles: str):
-    """Placeholder for quantum chemistry calculations"""
-    return {
-        'HOMO_Energy': np.random.uniform(-15, -5),
-        'LUMO_Energy': np.random.uniform(-3, 3),
-        'Dipole_Moment': np.random.uniform(0, 5)
-    }
-
-# --- Streamlit UI Components ---
+# --- Streamlit App ---
 def main():
-    st.title("🧪 Next-Gen Pharma Research Platform")
-    st.markdown("Integrated Drug Discovery & Development Analytics")
-
-    tabs = st.tabs([
-        "🚀 Molecular Explorer", 
-        "📊 Clinical Analytics", 
-        "⚗️ ADMET Predictor", 
-        "🔬 Quantum Chemistry"
-    ])
-
-    with tabs[0]:
-        st.header("Molecular Discovery Studio")
-        compound_input = st.text_input("Enter compound identifier:", "Aspirin")
+    st.title("🧬 Pharma Research Hub")
+    st.markdown("Drug Discovery Platform Optimized for Hugging Face Spaces")
+    
+    tab1, tab2, tab3, tab4 = st.tabs(["Molecule Analysis", "Clinical Trials", "ADMET Prediction", "About"])
+    
+    with tab1:
+        col1, col2 = st.columns([1, 2])
+        with col1:
+            compound = st.text_input("Enter compound name:", "Aspirin")
+            if st.button("Analyze"):
+                with st.spinner("Fetching data..."):
+                    mol_data = get_pubchem_data(compound)
+                    
+                    if mol_data:
+                        st.session_state.mol = mol_data
+                        with col2:
+                            st.subheader("3D Visualization")
+                            render_3d(mol_data.canonical_smiles)
         
-        if st.button("Analyze Compound"):
-            col1, col2 = st.columns([2, 3])
+        if 'mol' in st.session_state:
+            mol = st.session_state.mol
+            st.subheader(f"Properties for {mol.iupac_name}")
+            
+            col1, col2, col3 = st.columns(3)
             with col1:
-                try:
-                    compound = pcp.get_compounds(compound_input, 'name')[0]
-                    st.subheader("2D Structure")
-                    img = Draw.MolToImage(Chem.MolFromSmiles(compound.canonical_smiles))
-                    st.image(img, caption=f"{compound.iupac_name}")
-                    
-                    st.subheader("3D Visualization")
-                    render_3d_molecule(compound.canonical_smiles)
-                except Exception as e:
-                    st.error(f"Error rendering molecule: {str(e)}")
-
+                st.image(Draw.MolToImage(Chem.MolFromSmiles(mol.canonical_smiles)), 
+                        caption="2D Structure", width=200)
+                
             with col2:
-                st.subheader("Molecular Properties")
-                props = calculate_molecular_properties(compound.canonical_smiles)
-                prop_df = pd.DataFrame(list(props.items()), columns=['Property', 'Value'])
-                st.dataframe(prop_df.style.format({"Value": "{:.4f}"}), height=400)
-
-                st.subheader("Structural Similarity")
-                fig = px.scatter(x=[0.2, 0.7, 0.5], y=[0.8, 0.3, 0.6], 
-                               size=[10, 20, 15], color=['A', 'B', 'C'],
-                               labels={'x': 'Feature 1', 'y': 'Feature 2'})
-                st.plotly_chart(fig)
-
-    with tabs[1]:
-        st.header("Clinical Trial Intelligence")
-        trial_query = st.text_input("Search clinical trials:", "COVID-19")
-        
-        if st.button("Analyze Trials"):
-            try:
-                response = requests.get(API_CONFIG['clinicaltrials']['url'], 
-                                      params={**API_CONFIG['clinicaltrials']['params'], 
-                                              "query": trial_query})
-                trials = response.json()['studies'][:5]
+                st.markdown("**Basic Properties**")
+                st.write(f"Molecular Formula: {mol.molecular_formula}")
+                st.write(f"Weight: {mol.molecular_weight:.2f} g/mol")
+                st.write(f"LogP: {mol.xlogp}")
                 
-                st.subheader("Top Clinical Trials")
-                trial_data = []
+            with col3:
+                st.markdown("**Advanced Features**")
+                rdkit_mol = Chem.MolFromSmiles(mol.canonical_smiles)
+                st.write(f"H-Bond Donors: {Descriptors.NumHDonors(rdkit_mol)}")
+                st.write(f"Rotatable Bonds: {Descriptors.NumRotatableBonds(rdkit_mol)}")
+                st.write(f"TPSA: {Descriptors.TPSA(rdkit_mol):.2f}")
+
+    with tab2:
+        trial_query = st.text_input("Search clinical trials:", "Cancer")
+        if st.button("Find Trials"):
+            trials = get_clinical_trials(trial_query)
+            
+            if trials:
+                st.subheader("Recent Clinical Trials")
                 for study in trials:
-                    trial_data.append({
-                        'NCT ID': study.get('protocolSection', {}).get('identificationModule', {}).get('nctId'),
-                        'Title': study.get('protocolSection', {}).get('identificationModule', {}).get('briefTitle'),
-                        'Phase': study.get('protocolSection', {}).get('designModule', {}).get('phase'),
-                        'Status': study.get('protocolSection', {}).get('statusModule', {}).get('overallStatus')
-                    })
-                st.dataframe(pd.DataFrame(trial_data), use_container_width=True)
-                
-                st.subheader("Trial Phase Distribution")
-                phase_counts = pd.DataFrame(trial_data)['Phase'].value_counts()
-                fig = px.pie(phase_counts, values=phase_counts.values, names=phase_counts.index)
-                st.plotly_chart(fig)
-                
-            except Exception as e:
-                st.error(f"Clinical trial search failed: {str(e)}")
-
-    with tabs[2]:
-        st.header("ADMET Prediction Engine")
-        smiles_input = st.text_input("Enter SMILES string:", "CC(=O)OC1=CC=CC=C1C(=O)O")
-        
-        if st.button("Predict ADMET"):
-            with st.spinner("Running predictive models..."):
-                admet_props = predict_admet(smiles_input)
+                    info = study["Study"]["ProtocolSection"]
+                    st.markdown(f"""
+                    **{info["IdentificationModule"]["OfficialTitle"]}**
+                    - Status: {info["StatusModule"]["OverallStatus"]}
+                    - Phase: {info["DesignModule"].get("Phase", "N/A")}
+                    - Interventions: {", ".join([i["InterventionName"] for i in info["ArmsInterventionsModule"]["Interventions"]])}
+                    """)
+            else:
+                st.warning("No trials found for this search term")
+
+    with tab3:
+        st.subheader("ADMET Prediction (Demo)")
+        if 'mol' in st.session_state:
+            col1, col2 = st.columns(2)
+            with col1:
+                st.markdown("**Absorption**")
+                st.progress(0.75)
+                st.caption("Predicted Bioavailability: 75%")
                 
-                st.subheader("Prediction Results")
-                col1, col2, col3 = st.columns(3)
-                col1.metric("Blood-Brain Barrier", 
-                           "Permeant" if admet_props['BBB_Permeant'] else "Non-Permeant")
-                col2.metric("CYP2D6 Inhibition", 
-                           "Yes" if admet_props['CYP2D6_Inhibitor'] else "No")
-                col3.metric("AMES Toxicity", 
-                           "Toxic" if admet_props['AMES_Toxicity'] else "Safe")
+                st.markdown("**Distribution**")
+                st.progress(0.82)
+                st.caption("Plasma Protein Binding: 82%")
                 
-                st.subheader("Toxicity Risk Profile")
-                fig = px.bar(x=list(admet_props.keys()), y=[1, 0.5, 0.8],
-                            labels={'x': 'Property', 'y': 'Risk Score'},
-                            color_discrete_sequence=['#ff5252'])
-                st.plotly_chart(fig)
-
-    with tabs[3]:
-        st.header("Quantum Chemistry Simulations")
-        qc_smiles = st.text_input("Enter SMILES for simulation:", "C1CCCCC1")
-        
-        if st.button("Run Quantum Analysis"):
-            with st.spinner("Performing quantum calculations..."):
-                qc_results = quantum_simulation(qc_smiles)
-                
-                st.subheader("Quantum Properties")
-                col1, col2, col3 = st.columns(3)
-                col1.metric("HOMO Energy", f"{qc_results['HOMO_Energy']:.2f} eV")
-                col2.metric("LUMO Energy", f"{qc_results['LUMO_Energy']:.2f} eV")
-                col3.metric("Dipole Moment", f"{qc_results['Dipole_Moment']:.2f} D")
+            with col2:
+                st.markdown("**Metabolism**")
+                st.progress(0.68)
+                st.caption("CYP3A4 Substrate Probability: 68%")
                 
-                st.subheader("Molecular Orbitals")
-                fig = px.line(x=[-5, 0, 5], y=[qc_results['HOMO_Energy'], 0, qc_results['LUMO_Energy']],
-                            labels={'x': 'Energy Level', 'y': 'Energy (eV)'})
-                st.plotly_chart(fig)
+                st.markdown("**Toxicity**")
+                st.progress(0.15)
+                st.caption("AMES Mutagenicity Risk: 15%")
+        else:
+            st.info("Analyze a compound first in the 'Molecule Analysis' tab")
+
+    with tab4:
+        st.markdown("""
+        ## About This Platform
+        **Pharma Research Hub** - Optimized for Hugging Face Spaces
+        - Built with Streamlit
+        - Integrates PubChem, ClinicalTrials.gov
+        - Molecular visualization with RDKit and py3Dmol
+        - Lightweight architecture for HF Spaces
+        """)
 
 if __name__ == "__main__":
     main()