Update app.py

app.py

@@ -4,8 +4,14 @@ import plotly.express as px
 import os
 from openai import OpenAI
 import bcrypt
+from supabase import create_client, Client
 
-# Set up OpenAI API key
+# Set up Supabase client
+supabase_url = st.secrets["SUPABASE_URL"]
+supabase_key = st.secrets["SUPABASE_KEY"]
+supabase: Client = create_client(supabase_url, supabase_key)
+
+# Set up OpenAI client
 client = OpenAI(api_key=st.secrets["OPENAI_API_KEY"])
 
 # Initialize session state
@@ -14,33 +20,31 @@ if 'user' not in st.session_state:
 if 'user_type' not in st.session_state:
     st.session_state.user_type = None
 
-# File path for CSV database
-CSV_FILE = "migraine_diary.csv"
-USER_FILE = "users.csv"
-
-# Function to load data from CSV
-# @st.cache_data
-def load_data():
-    if os.path.exists(CSV_FILE):
-        return pd.read_csv(CSV_FILE)
-    return pd.DataFrame(columns=['user', 'date', 'pain_level', 'duration', 'triggers', 'symptoms', 'medications', 'notes', 'doctor_analysis', 'patient_advice'])
+def load_data(username=None):
+    if username:
+        response = supabase.table('entries').select('*').eq('username', username).execute()
+    else:
+        response = supabase.table('entries').select('*').execute()
+    return pd.DataFrame(response.data)
 
-# Function to load user data
-# @st.cache_data
 def load_user_data():
-    if os.path.exists(USER_FILE):
-        return pd.read_csv(USER_FILE)
-    return pd.DataFrame(columns=['username', 'password', 'user_type'])
+    response = supabase.table('users').select('*').execute()
+    return pd.DataFrame(response.data)
 
-# Function to save data to CSV
-def save_data(df):
-    df.to_csv(CSV_FILE, index=False)
+def save_data(entry):
+    supabase.table('entries').insert(entry).execute()
 
-# Function to save user data
-def save_user_data(df):
-    df.to_csv(USER_FILE, index=False)
+def save_user_data(username, hashed_password, user_type):
+    supabase.table('users').insert({
+        'username': username,
+        'password': hashed_password,
+        'user_type': user_type
+    }).execute()
+
+def get_user(username):
+    response = supabase.table('users').select('*').eq('username', username).execute()
+    return pd.DataFrame(response.data)
 
-# Function to get GPT analysis
 def get_gpt_analysis(entry_text, system_prompt):
     try:
         response = client.chat.completions.create(
@@ -55,15 +59,12 @@ def get_gpt_analysis(entry_text, system_prompt):
         st.error(f"Error in GPT analysis: {str(e)}")
         return "Analysis unavailable at this time."
 
-# Password hashing function
 def hash_password(password):
     return bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
 
-# Password verification function
 def verify_password(stored_password, provided_password):
     return bcrypt.checkpw(provided_password.encode('utf-8'), stored_password.encode('utf-8'))
 
-# Login/Register function
 def auth():
     if st.session_state.user is None:
         st.subheader("User Authentication")
@@ -76,8 +77,7 @@ def auth():
             login_button = st.button("Login")
             
             if login_button:
-                user_df = load_user_data()
-                user_data = user_df[user_df['username'] == login_username]
+                user_data = get_user(login_username)
                 if not user_data.empty and verify_password(user_data.iloc[0]['password'], login_password):
                     st.session_state.user = login_username
                     st.session_state.user_type = user_data.iloc[0]['user_type']
@@ -95,18 +95,16 @@ def auth():
             register_button = st.button("Register")
             
             if register_button:
-                user_df = load_user_data()
-                if reg_username in user_df['username'].values:
+                existing_user = get_user(reg_username)
+                if not existing_user.empty:
                     st.error("Username already exists. Please choose a different one.")
                 elif reg_password != confirm_password:
                     st.error("Passwords do not match.")
-                elif len(reg_password) < 1:
+                elif len(reg_password) < 8:
                     st.error("Password must be at least 8 characters long.")
                 else:
                     hashed_password = hash_password(reg_password)
-                    new_user = pd.DataFrame({'username': [reg_username], 'password': [hashed_password], 'user_type': [user_type]})
-                    user_df = pd.concat([user_df, new_user], ignore_index=True)
-                    save_user_data(user_df)
+                    save_user_data(reg_username, hashed_password, user_type)
                     st.session_state.user = reg_username
                     st.session_state.user_type = user_type
                     st.success("Registered successfully!")
@@ -118,7 +116,6 @@ def auth():
             st.session_state.user_type = None
             st.rerun()
 
-# Main app
 def main():
     st.set_page_config(page_title="Migraine Diary App", page_icon="🧠", layout="wide")
     st.title("Migraine Diary App")
@@ -184,48 +181,43 @@ def add_entry():
         
         submitted = st.form_submit_button("Submit Entry")
         if submitted:
-            df = load_data()
             entry_text = f"Date: {date}\nPain Level: {pain_level}\nDuration: {duration}\nTriggers: {', '.join(triggers)}\nSymptoms: {', '.join(symptoms)}\nMedications: {medications}\nNotes: {notes}"
             
             with st.spinner("Analyzing your entry..."):
                 doctor_analysis = get_gpt_analysis(entry_text, "You are a neurologist specializing in migraine management. Provide a technical analysis of the patient's migraine diary entry, including potential correlations, patterns, and suggestions for the treating physician. Keep it short and to the point the doctor is busy.")
                 patient_advice = get_gpt_analysis(entry_text, "You are a supportive health coach specializing in migraine management. Provide friendly, easy-to-understand advice for the patient based on their migraine diary entry. Include actionable tips for managing their condition and potential lifestyle adjustments.")
 
-            new_entry = pd.DataFrame({
-                'user': [st.session_state.user],
-                'date': [date],
-                'pain_level': [pain_level],
-                'duration': [duration],
-                'triggers': [', '.join(triggers)],
-                'symptoms': [', '.join(symptoms)],
-                'medications': [medications],
-                'notes': [notes],
-                'doctor_analysis': [doctor_analysis],
-                'patient_advice': [patient_advice]
-            })
-            df = pd.concat([df, new_entry], ignore_index=True)
-            save_data(df)
+            new_entry = {
+                'username': st.session_state.user,
+                'entry_date': date.isoformat(),
+                'pain_level': pain_level,
+                'duration': duration,
+                'triggers': ', '.join(triggers),
+                'symptoms': ', '.join(symptoms),
+                'medications': medications,
+                'notes': notes,
+                'doctor_analysis': doctor_analysis,
+                'patient_advice': patient_advice
+            }
+            save_data(new_entry)
             st.success("Entry added successfully!")
             st.subheader("Advice for You:")
             st.write(patient_advice)
 
 def view_entries(is_doctor):
     st.header("Migraine Entries")
-    df = load_data()
     if is_doctor:
-        user_entries = df
+        user_entries = load_data()
         st.subheader("All Patient Entries")
     else:
-        user_entries = df[df['user'] == st.session_state.user]
-        print(st.session_state.user)
-        print(user_entries)
+        user_entries = load_data(st.session_state.user)
         st.subheader("Your Entries")
     
-    user_entries = user_entries.sort_values(by='date', ascending=False)
+    user_entries = user_entries.sort_values(by='entry_date', ascending=False)
     
     if not user_entries.empty:
         for _, entry in user_entries.iterrows():
-            with st.expander(f"Entry for {entry['user']} on {entry['date']} - Pain Level: {entry['pain_level']}"):
+            with st.expander(f"Entry for {entry['username']} on {entry['entry_date']} - Pain Level: {entry['pain_level']}"):
                 st.write(f"Duration: {entry['duration']}")
                 st.write(f"Triggers: {entry['triggers']}")
                 st.write(f"Symptoms: {entry['symptoms']}")
@@ -240,21 +232,21 @@ def view_entries(is_doctor):
 
 def display_dashboard(is_doctor):
     st.header("Migraine Dashboard")
-    df = load_data()
     
     if is_doctor:
         st.subheader("Select Patient")
-        selected_user = st.selectbox("Choose a patient", df['user'].unique())
-        user_entries = df[df['user'] == selected_user]
+        all_users = load_data()['username'].unique()
+        selected_user = st.selectbox("Choose a patient", all_users)
+        user_entries = load_data(selected_user)
     else:
-        user_entries = df[df['user'] == st.session_state.user]
+        user_entries = load_data(st.session_state.user)
 
     if not user_entries.empty:
         col1, col2 = st.columns(2)
         
         with col1:
             st.subheader("Pain Level Over Time")
-            fig = px.line(user_entries, x='date', y='pain_level', title='Pain Level Over Time')
+            fig = px.line(user_entries, x='entry_date', y='pain_level', title='Pain Level Over Time')
             st.plotly_chart(fig, use_container_width=True)
 
         with col2:
@@ -264,14 +256,24 @@ def display_dashboard(is_doctor):
             fig = px.bar(x=trigger_counts.index, y=trigger_counts.values, labels={'x': 'Trigger', 'y': 'Count'})
             st.plotly_chart(fig, use_container_width=True)
 
+        col1, col2 = st.columns(2)
+
+        with col1:
+            st.subheader("Common Symptoms")
+            all_symptoms = ', '.join(user_entries['symptoms'].dropna()).split(', ')
+            symptom_counts = pd.Series(all_symptoms).value_counts().head(5)
+            fig = px.bar(x=symptom_counts.index, y=symptom_counts.values, labels={'x': 'Symptom', 'y': 'Count'})
+            st.plotly_chart(fig, use_container_width=True)
+
         st.subheader("Migraine Statistics")
-        col1, col2, col3 = st.columns(3)
+        col1, col2, col3, col4 = st.columns(4)
         col1.metric("Total Entries", len(user_entries))
         col2.metric("Average Pain Level", f"{user_entries['pain_level'].mean():.2f}")
         col3.metric("Most Common Trigger", trigger_counts.index[0] if not trigger_counts.empty else "N/A")
+        col4.metric("Most Common Symptom", symptom_counts.index[0] if not symptom_counts.empty else "N/A")
 
         st.subheader("Recent Entries")
-        st.dataframe(user_entries[['date', 'pain_level', 'duration', 'triggers']].sort_values(by='date', ascending=False).head())
+        st.dataframe(user_entries[['entry_date', 'pain_level', 'duration', 'triggers', 'symptoms']].sort_values(by='entry_date', ascending=False).head())
     else:
         st.info("No entries found.")