Update app.py

app.py

@@ -2,9 +2,11 @@ import os
 import streamlit as st
 import pandas as pd
 import plotly.express as px
+import plotly.graph_objects as go
 from stravalib.client import Client
 import google.generativeai as genai
 from dotenv import load_dotenv
+from datetime import datetime, timedelta
 
 # Load environment variables
 load_dotenv()
@@ -22,7 +24,7 @@ genai.configure(api_key=GEMINI_API_KEY)
 model = genai.GenerativeModel('gemini-pro')
 
 # Streamlit app
-st.set_page_config(page_title="Strava Analysis App", layout="wide")
+st.set_page_config(page_title="Strava Run Analysis", layout="wide")
 
 # Custom CSS for better UI
 st.markdown("""
@@ -31,44 +33,64 @@ st.markdown("""
         background-color: #f0f2f6;
     }
     .stButton>button {
-        background-color: #fc5200;
+        background-color: #fc4c02;
         color: white;
+        font-weight: bold;
+        border-radius: 5px;
+        border: none;
+        padding: 0.5rem 1rem;
+    }
+    .stButton>button:hover {
+        background-color: #e34402;
     }
     .stSelectbox {
         color: #333333;
     }
     .stPlotlyChart {
         background-color: white;
-        border-radius: 5px;
-        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        border-radius: 10px;
+        box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+        padding: 1rem;
+        margin-bottom: 2rem;
     }
-    .success-message {
-        padding: 10px;
-        background-color: #d4edda;
-        color: #155724;
-        border-radius: 5px;
-        margin-bottom: 10px;
+    .stat-card {
+        background-color: white;
+        border-radius: 10px;
+        box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+        padding: 1.5rem;
+        text-align: center;
     }
-    .error-message {
-        padding: 10px;
-        background-color: #f8d7da;
-        color: #721c24;
-        border-radius: 5px;
-        margin-bottom: 10px;
+    .stat-card h3 {
+        color: #fc4c02;
+        font-size: 2.5rem;
+        margin-bottom: 0.5rem;
+    }
+    .stat-card p {
+        color: #666;
+        font-size: 1rem;
+        margin: 0;
+    }
+    .section-header {
+        color: #333;
+        font-size: 1.8rem;
+        font-weight: bold;
+        margin-top: 2rem;
+        margin-bottom: 1rem;
     }
 </style>
 """, unsafe_allow_html=True)
 
-st.title("🏃‍♂️ Strava Analysis App")
+st.title("🏃‍♂️ Strava Run Analysis")
 
 # Strava manual authentication
 if 'access_token' not in st.session_state:
     st.write("To use this app, you need to authorize it with Strava. Follow these steps:")
-    st.write("1. Click this link to go to Strava's authorization page:")
-    st.write(f"[Strava Authorization](https://www.strava.com/oauth/authorize?client_id={STRAVA_CLIENT_ID}&response_type=code&redirect_uri=http://localhost&approval_prompt=force&scope=read_all,profile:read_all,activity:read_all)")
+    st.write("1. Click the button below to go to Strava's authorization page:")
+    auth_url = f"https://www.strava.com/oauth/authorize?client_id={STRAVA_CLIENT_ID}&response_type=code&redirect_uri=http://localhost&approval_prompt=force&scope=read_all,profile:read_all,activity:read_all"
+    st.markdown(f"<a href='{auth_url}' target='_blank'><button style='background-color: #fc4c02; color: white; padding: 0.5rem 1rem; border: none; border-radius: 5px; cursor: pointer;'>Authorize Strava</button></a>", unsafe_allow_html=True)
     st.write("2. Log in to Strava if needed and click 'Authorize'")
-    st.write("3. After authorizing, you'll see a page that says 'Authorization Error' or 'localhost refused to connect'. This is expected!")
-    st.write("4. In the URL of that page, you'll see a code parameter. Copy the value of that code (it's a long string of letters and numbers).")
+    st.write("3. After authorizing, you'll be redirected to a page that may show an error. This is expected!")
+    st.write("4. Copy the 'code' parameter from the URL of that page.")
     st.write("5. Paste that code below:")
     
     auth_code = st.text_input("Paste the authorization code here:")
@@ -80,10 +102,10 @@ if 'access_token' not in st.session_state:
                 code=auth_code
             )
             st.session_state.access_token = token_response['access_token']
-            st.markdown('<div class="success-message">Authorization successful! Refreshing the app...</div>', unsafe_allow_html=True)
+            st.success("Authorization successful! Refreshing the app...")
             st.rerun()
         except Exception as e:
-            st.markdown(f'<div class="error-message">An error occurred: {str(e)}. Please try authorizing again.</div>', unsafe_allow_html=True)
+            st.error(f"An error occurred: {str(e)}. Please try authorizing again.")
 
 if 'access_token' in st.session_state:
     client.access_token = st.session_state.access_token
@@ -91,61 +113,91 @@ if 'access_token' in st.session_state:
         athlete = client.get_athlete()
         st.write(f"Welcome, {athlete.firstname} {athlete.lastname}! 👋")
     except Exception as e:
-        st.markdown(f'<div class="error-message">Error fetching athlete data: {str(e)}. Please try reauthorizing.</div>', unsafe_allow_html=True)
+        st.error(f"Error fetching athlete data: {str(e)}. Please try reauthorizing.")
         if st.button("Reauthorize"):
             del st.session_state.access_token
             st.rerun()
 
-    # Fetch activities
+    # Fetch running activities
     @st.cache_data(ttl=3600)
-    def fetch_activities():
-        activities = list(client.get_activities(limit=100))
+    def fetch_run_activities():
+        activities = list(client.get_activities(limit=200))
+        runs = [activity for activity in activities if activity.type == 'Run']
         df = pd.DataFrame([{
-            'name': activity.name,
-            'distance': float(activity.distance) if activity.distance is not None else 0,
-            'moving_time': float(activity.moving_time) if activity.moving_time is not None else 0,
-            'elevation_gain': float(activity.total_elevation_gain) if activity.total_elevation_gain is not None else 0,
-            'type': str(activity.type),
-        } for activity in activities])
+            'name': run.name,
+            'distance': float(run.distance) / 1000,  # Convert to km
+            'moving_time': run.moving_time.total_seconds() / 60,  # Convert to minutes
+            'total_elevation_gain': float(run.total_elevation_gain),
+            'average_speed': float(run.average_speed) * 3.6,  # Convert to km/h
+            'average_heartrate': float(run.average_heartrate) if run.average_heartrate else None,
+            'start_date': run.start_date.replace(tzinfo=None)
+        } for run in runs])
+        df['pace'] = df['moving_time'] / df['distance']  # Calculate pace (min/km)
         return df
 
     try:
-        df = fetch_activities()
+        df = fetch_run_activities()
     except Exception as e:
-        st.markdown(f'<div class="error-message">Error fetching activities: {str(e)}. Please try again later.</div>', unsafe_allow_html=True)
+        st.error(f"Error fetching activities: {str(e)}. Please try again later.")
         st.stop()
 
-    # Display recent activities
-    st.subheader("📊 Recent Activities")
-    st.dataframe(df.style.format({
-        'distance': '{:.2f} km',
-        'moving_time': '{:.2f} hours',
-        'elevation_gain': '{:.0f} m'
-    }))
-
     # Basic stats
-    st.subheader("🏅 Activity Stats")
-    total_distance = df['distance'].sum() / 1000  # Convert to km
-    total_time = df['moving_time'].sum() / 3600  # Convert to hours
-    total_elevation = df['elevation_gain'].sum()
+    st.markdown("<h2 class='section-header'>📊 Run Statistics</h2>", unsafe_allow_html=True)
     
-    col1, col2, col3 = st.columns(3)
-    col1.metric("Total Distance", f"{total_distance:.2f} km")
-    col2.metric("Total Time", f"{total_time:.2f} hours")
-    col3.metric("Total Elevation Gain", f"{total_elevation:.0f} m")
+    col1, col2, col3, col4 = st.columns(4)
+    with col1:
+        st.markdown("<div class='stat-card'><h3>{:.0f}</h3><p>Total Runs</p></div>".format(len(df)), unsafe_allow_html=True)
+    with col2:
+        st.markdown("<div class='stat-card'><h3>{:.0f} km</h3><p>Total Distance</p></div>".format(df['distance'].sum()), unsafe_allow_html=True)
+    with col3:
+        total_time = df['moving_time'].sum()
+        st.markdown("<div class='stat-card'><h3>{:.0f}h {:.0f}m</h3><p>Total Time</p></div>".format(total_time // 60, total_time % 60), unsafe_allow_html=True)
+    with col4:
+        st.markdown("<div class='stat-card'><h3>{:.0f} m</h3><p>Total Elevation Gain</p></div>".format(df['total_elevation_gain'].sum()), unsafe_allow_html=True)
 
     # Visualizations
-    st.subheader("📈 Activity Visualizations")
+    st.markdown("<h2 class='section-header'>📈 Run Analysis</h2>", unsafe_allow_html=True)
     
-    # Distance by activity type
-    fig_distance = px.bar(df.groupby('type').sum().reset_index(), 
-                          x='type', y='distance', 
-                          title="Total Distance by Activity Type")
-    fig_distance.update_layout(xaxis_title="Activity Type", yaxis_title="Distance (m)")
-    st.plotly_chart(fig_distance, use_container_width=True)
+    # Weekly distance
+    weekly_distance = df.resample('W', on='start_date')['distance'].sum().reset_index()
+    fig_weekly = px.bar(weekly_distance, x='start_date', y='distance', 
+                        title="Weekly Running Distance",
+                        labels={'distance': 'Distance (km)', 'start_date': 'Week'})
+    fig_weekly.update_layout(xaxis_title="Week", yaxis_title="Distance (km)")
+    st.plotly_chart(fig_weekly, use_container_width=True)
+
+    # Pace improvement
+    df_sorted = df.sort_values('start_date')
+    fig_pace = px.scatter(df_sorted, x='start_date', y='pace', 
+                          title="Running Pace Over Time",
+                          labels={'pace': 'Pace (min/km)', 'start_date': 'Date'})
+    fig_pace.add_trace(go.Scatter(x=df_sorted['start_date'], y=df_sorted['pace'].rolling(window=10).mean(),
+                                  mode='lines', name='10-run moving average'))
+    fig_pace.update_layout(yaxis_title="Pace (min/km)")
+    st.plotly_chart(fig_pace, use_container_width=True)
+
+    # Heart rate improvement (if data available)
+    if df['average_heartrate'].notna().any():
+        df_hr = df_sorted[df_sorted['average_heartrate'].notna()]
+        fig_hr = px.scatter(df_hr, x='start_date', y='average_heartrate', 
+                            title="Average Heart Rate Over Time",
+                            labels={'average_heartrate': 'Average Heart Rate (bpm)', 'start_date': 'Date'})
+        fig_hr.add_trace(go.Scatter(x=df_hr['start_date'], y=df_hr['average_heartrate'].rolling(window=10).mean(),
+                                    mode='lines', name='10-run moving average'))
+        fig_hr.update_layout(yaxis_title="Average Heart Rate (bpm)")
+        st.plotly_chart(fig_hr, use_container_width=True)
+    else:
+        st.info("No heart rate data available for analysis.")
+
+    # Distance vs. Elevation gain
+    fig_elev = px.scatter(df, x='distance', y='total_elevation_gain',
+                          title="Distance vs. Elevation Gain",
+                          labels={'distance': 'Distance (km)', 'total_elevation_gain': 'Elevation Gain (m)'})
+    fig_elev.update_layout(xaxis_title="Distance (km)", yaxis_title="Elevation Gain (m)")
+    st.plotly_chart(fig_elev, use_container_width=True)
 
     # Training Plan Generation
-    st.subheader("🏋️‍♀️ Generate Training Plan")
+    st.markdown("<h2 class='section-header'>🏋️‍♀️ Generate Training Plan</h2>", unsafe_allow_html=True)
     
     col1, col2, col3 = st.columns(3)
     with col1:
@@ -159,18 +211,12 @@ if 'access_token' in st.session_state:
         with st.spinner("Generating your personalized training plan..."):
             try:
                 prompt = f"""Create a {plan_duration} training plan for a {level} runner preparing for a {race_distance} race. 
-                Include weekly mileage and key workouts. Format the plan week by week, with each week on a new line."""
+                Include weekly mileage and key workouts. Format the plan week by week, with each week on a new line. 
+                Consider the runner's current weekly mileage of {weekly_distance['distance'].iloc[-1]:.1f} km."""
                 response = model.generate_content(prompt)
                 st.markdown(response.text)
             except Exception as e:
-                st.markdown(f'<div class="error-message">Error generating training plan: {str(e)}. Please try again later.</div>', unsafe_allow_html=True)
-
-    # Simple Insights
-    st.subheader("💡 Activity Insights")
-    activity_types = df['type'].value_counts()
-    st.write(f"You have {len(df)} recorded activities.")
-    st.write(f"Your most common activity type is {activity_types.index[0]} with {activity_types.iloc[0]} activities.")
-    st.write(f"Your average activity distance is {df['distance'].mean() / 1000:.2f} km.")
+                st.error(f"Error generating training plan: {str(e)}. Please try again later.")
 
 else:
-    st.info("Please complete the authorization process to view your Strava data and analytics.")
+    st.info("Please complete the authorization process to view your Strava running data and analytics.")