Create app.py

app.py

@@ -0,0 +1,160 @@
+import os
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+from stravalib.client import Client
+import google.generativeai as genai
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# API Keys and Secrets
+STRAVA_CLIENT_ID = os.getenv('STRAVA_CLIENT_ID')
+STRAVA_CLIENT_SECRET = os.getenv('STRAVA_CLIENT_SECRET')
+STRAVA_REDIRECT_URI = os.getenv('STRAVA_REDIRECT_URI')
+GEMINI_API_KEY = os.getenv('GEMINI_API_KEY')
+
+# Strava API setup
+client = Client()
+
+# Gemini API setup
+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.title("Strava Analysis App")
+
+# Strava authentication
+if 'access_token' not in st.session_state:
+    auth_url = client.authorization_url(
+        client_id=STRAVA_CLIENT_ID,
+        redirect_uri=STRAVA_REDIRECT_URI,
+        scope=['read_all', 'profile:read_all', 'activity:read_all']
+    )
+    st.write(f"[Authorize with Strava]({auth_url})")
+    
+    code = st.text_input("Enter the code from the redirect URL:")
+    if code:
+        token_response = client.exchange_code_for_token(
+            client_id=STRAVA_CLIENT_ID,
+            client_secret=STRAVA_CLIENT_SECRET,
+            code=code
+        )
+        st.session_state.access_token = token_response['access_token']
+        st.experimental_rerun()
+
+if 'access_token' in st.session_state:
+    client.access_token = st.session_state.access_token
+    athlete = client.get_athlete()
+    st.write(f"Welcome, {athlete.firstname} {athlete.lastname}!")
+
+    # Fetch activities
+    @st.cache_data(ttl=3600)
+    def fetch_activities():
+        activities = list(client.get_activities(limit=100))
+        df = pd.DataFrame([{
+            'name': activity.name,
+            'distance': activity.distance.num,
+            'moving_time': activity.moving_time.total_seconds() / 3600,
+            'elevation_gain': activity.total_elevation_gain.num,
+            'type': activity.type,
+            'start_date': activity.start_date.date()
+        } for activity in activities])
+        return df
+
+    df = fetch_activities()
+
+    # Display recent activities
+    st.subheader("Recent Activities")
+    st.dataframe(df)
+
+    # Basic stats
+    st.subheader("Activity Stats")
+    total_distance = df['distance'].sum() / 1000  # Convert to km
+    total_time = df['moving_time'].sum()
+    total_elevation = df['elevation_gain'].sum()
+    
+    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")
+
+    # Visualizations
+    st.subheader("Activity Visualizations")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        # Distance by activity type
+        fig_distance = px.bar(df.groupby('type').sum().reset_index(), 
+                              x='type', y='distance', 
+                              title="Total Distance by Activity Type")
+        st.plotly_chart(fig_distance, use_container_width=True)
+
+    with col2:
+        # Activity count over time
+        df['start_date'] = pd.to_datetime(df['start_date'])
+        fig_timeline = px.bar(df.groupby('start_date').size().reset_index(name='count'), 
+                              x='start_date', y='count', 
+                              title="Activity Count Over Time")
+        st.plotly_chart(fig_timeline, use_container_width=True)
+
+    # Training Plan Generation
+    st.subheader("Generate Training Plan")
+    
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        level = st.selectbox("Select your level:", ["Beginner", "Intermediate", "Advanced"])
+    with col2:
+        race_distance = st.selectbox("Select race distance:", ["5K", "10K", "Half Marathon", "Marathon"])
+    with col3:
+        plan_duration = st.selectbox("Select plan duration:", ["8 weeks", "10 weeks", "12 weeks"])
+
+    if st.button("Generate Training Plan"):
+        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."""
+        response = model.generate_content(prompt)
+        st.markdown(response.text)
+
+    # Natural Language Insights
+    st.subheader("Get Insights")
+    user_question = st.text_input("Ask a question about your running data:")
+    if user_question:
+        context = f"""Based on the runner's data: 
+        Total distance: {total_distance:.2f} km
+        Total time: {total_time:.2f} hours
+        Total elevation gain: {total_elevation:.0f} m
+        Number of activities: {len(df)}
+        Date range: {df['start_date'].min()} to {df['start_date'].max()}
+        """
+        prompt = f"{context}\n\nUser question: {user_question}\n\nProvide a concise, insightful answer:"
+        response = model.generate_content(prompt)
+        st.write(response.text)
+
+    # Performance Analysis
+    st.subheader("Performance Analysis")
+    
+    # Calculate pace
+    df['pace'] = df['moving_time'] / (df['distance'] / 1000)  # min/km
+    
+    # Filter for runs only
+    runs_df = df[df['type'] == 'Run']
+    
+    if not runs_df.empty:
+        fig_pace = px.scatter(runs_df, x='start_date', y='pace', 
+                              title="Running Pace Over Time",
+                              labels={'pace': 'Pace (min/km)', 'start_date': 'Date'})
+        st.plotly_chart(fig_pace, use_container_width=True)
+        
+        # Weekly mileage
+        weekly_mileage = runs_df.resample('W', on='start_date')['distance'].sum() / 1000
+        fig_weekly = px.bar(weekly_mileage, title="Weekly Running Mileage",
+                            labels={'value': 'Distance (km)', 'start_date': 'Week'})
+        st.plotly_chart(fig_weekly, use_container_width=True)
+    else:
+        st.write("No running data available for performance analysis.")
+
+else:
+    st.write("Please authorize with Strava to view your data and analytics.")