Upload 9 files

README.md

@@ -18,10 +18,12 @@ A powerful web application that analyzes athletic jump performance from videos u
 
 - **🎥 YouTube Integration**: Analyze videos directly from YouTube URLs
 - **📁 File Upload**: Support for MP4, AVI, MOV, and other video formats  
-- **📊 Detailed Analytics**: Get jump height, flight time, normalized rise, and performance insights
+- **📊 Comprehensive Biomechanical Analysis**: Jump height, flight time, peak power, force development, and more
+- **🤖 AI Sports Coach**: Get personalized sport recommendations and technique improvements
 - **🎯 Real-time Processing**: Fast analysis using Google's MediaPipe pose estimation
-- **📱 Modern Interface**: Beautiful, responsive Gradio interface
-- **🔬 Scientific Accuracy**: Precise biomechanical analysis
+- **📱 Modern Interface**: Beautiful, responsive Gradio interface with multiple analysis modes
+- **🔬 Scientific Accuracy**: Professional-grade biomechanical analysis
+- **⚡ Advanced Metrics**: Peak power output, rate of force development, impulse, and ground contact time
 
 ## 🚀 Live Demo
 
@@ -52,7 +54,12 @@ Try the live demo on Hugging Face Spaces: [Athletic Ability Analysis](https://hu
 2. **Create a new Space** on [Hugging Face Spaces](https://huggingface.co/spaces)
 3. **Connect your GitHub repo** to the Space
 4. **Set the Space type** to "Gradio"
-5. **Wait for automatic deployment**
+5. **⚠️ IMPORTANT: Set up API Key Environment Variable**:
+   - Go to your Space's "Settings" tab
+   - Add a new "Secret" with name: `GEMINI_API_KEY`
+   - Add your Gemini API key as the value
+   - This keeps your API key secure and private
+6. **Wait for automatic deployment**
 
 ### Manual Deployment
 
@@ -66,19 +73,37 @@ Try the live demo on Hugging Face Spaces: [Athletic Ability Analysis](https://hu
 
 3. **Upload files** to your Space:
    - `app.py` (main application)
+   - `athletic_performance.py` (analysis module)
    - `requirements.txt` (dependencies)
    - `README.md` (this file)
 
-4. **Space will automatically deploy** using Gradio
+4. **🔐 Set up Secure API Key**:
+   - In your Space settings, add environment variable: `GEMINI_API_KEY`
+   - Get your free API key from [Google AI Studio](https://aistudio.google.com/app/apikey)
+   - **NEVER commit API keys to your repository!**
+
+5. **Space will automatically deploy** using Gradio
+
+### 🔐 API Key Security
+
+For the AI Sports Coach feature, you need a Google Gemini API key:
+
+- **🆓 Free**: Get your key at [Google AI Studio](https://aistudio.google.com/app/apikey)
+- **🔒 Secure**: Set as environment variable `GEMINI_API_KEY` in HF Spaces
+- **🚫 Never**: Commit API keys to code repositories
+- **✅ Best Practice**: Use HF Spaces secrets for deployment
 
 ## 📁 Project Structure
 
 ```
 athletic-ability-analysis/
-├── app.py               # Main Gradio application
-├── requirements.txt     # Python dependencies
-├── README.md           # This file (with HF Spaces header)
-└── .gitignore         # Git ignore file
+├── app.py                    # Main Gradio application & UI
+├── athletic_performance.py   # Core analysis & AI integration
+├── requirements.txt          # Python dependencies
+├── README.md                # This file (with HF Spaces header)
+├── deploy_hf.py             # Deployment helper script
+├── test_deployment.py       # Dependency testing
+└── .gitignore              # Git ignore file
 ```
 
 ## 🎯 Usage
@@ -86,12 +111,21 @@ athletic-ability-analysis/
 ### Web Interface
 
 1. **Visit your Hugging Face Space URL**
-2. **Enter your height** in centimeters for accurate calculations
-3. **Choose input method**:
-   - **YouTube**: Paste a YouTube URL containing a jump video
-   - **File Upload**: Upload a video file from your device
-4. **Click "Analyze"** and wait for processing
-5. **View detailed results** including metrics and performance insights
+2. **Enter your height and weight** for accurate biomechanical calculations
+3. **Choose your analysis type**:
+   
+   **📊 Standard Analysis:**
+   - YouTube or File Upload tabs
+   - Get comprehensive biomechanical metrics
+   
+   **🤖 AI Sports Coach:**
+   - Select your gender
+   - Provide video (YouTube URL or upload)
+   - Get personalized sport recommendations
+   - Receive jump technique improvement suggestions
+
+4. **Click analyze** and wait for processing
+5. **View comprehensive results** with detailed insights
 
 ### Supported Video Formats
 

app.py

@@ -1,328 +1,281 @@
-import cv2
-import numpy as np
-import mediapipe as mp
-from collections import deque
-from pathlib import Path
-import json
-import tempfile
-import os
-import yt_dlp
 import gradio as gr
 import pandas as pd
+import os
+from athletic_performance import analyze_youtube_video, analyze_video_file, get_performance_insights, get_ai_sports_coaching_analysis
 
-LHIP, RHIP = 23, 24
-POSE_CONNECTIONS = mp.solutions.pose.POSE_CONNECTIONS
-
-def smooth_moving_avg(series, k=5):
-    """Simple causal moving average; ignores None values."""
-    out = []
-    q = deque()
-    s = 0.0
-    cnt = 0
-    for v in series:
-        if v is not None:
-            q.append(v); s += v; cnt += 1
-        else:
-            q.append(None)
-        if len(q) > k:
-            old = q.popleft()
-            if old is not None:
-                s -= old; cnt -= 1
-        out.append((s / max(cnt, 1)) if cnt > 0 else None)
-    return out
-
-def estimate_jump_metrics(hip_y_series, fps):
-    """Return jump_height_norm (0..1), flight_time_s using hip trajectory."""
-    # Remove None
-    hip = [h for h in hip_y_series if h is not None]
-    if len(hip) < 3:
-        return None, None
-
-    # Smooth
-    hip = smooth_moving_avg(hip, k=5)
-
-    # Jump height (normalized): deepest crouch (max y) to apex (min y)
-    min_y = min(hip)  # apex (body highest)
-    max_y = max(hip)  # deepest crouch (body lowest)
-    jump_height_norm = max(0.0, (max_y - min_y))
-
-    # Flight time heuristic using vertical velocity pattern
-    hip_arr = np.array(hip, dtype=float)
-    vel = np.diff(hip_arr)
-    if vel.size == 0:
-        flight_time_s = 0.0
-    else:
-        takeoff_idx = int(np.argmin(vel))   # most negative velocity
-        landing_idx = int(np.argmax(vel))   # most positive velocity
-        flight_frames = max(0, landing_idx - takeoff_idx)
-        flight_time_s = flight_frames / float(fps or 30.0)
-
-    return jump_height_norm, flight_time_s
-
-def download_youtube_video(youtube_url, output_path):
-    """Download YouTube video to specified path."""
-    ydl_opts = {
-        'format': 'best[height<=720]',  # Limit quality for faster processing
-        'outtmpl': output_path,
-        'quiet': True,
-        'no_warnings': True,
-    }
+def analyze_jump_from_youtube(youtube_url, user_height_cm, user_weight_kg, progress=gr.Progress()):
+    """Main analysis function for Gradio interface."""
     
-    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-        ydl.download([youtube_url])
-    return output_path
-
-def process_video_analysis(video_path, user_height_cm, progress_callback=None):
-    """Core video analysis function with progress tracking."""
-    cap = cv2.VideoCapture(video_path)
-    if not cap.isOpened():
-        raise Exception(f"Could not open video: {video_path}")
-
-    w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-    h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-    fps = cap.get(cv2.CAP_PROP_FPS) or 30.0
-    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-
-    mp_pose = mp.solutions.pose
-    pose = mp_pose.Pose(static_image_mode=False, model_complexity=1, enable_segmentation=False)
-
-    hip_y_series = []
-    frame_idx = 0
-
-    print(f"Processing video: {Path(video_path).name}")
-    print(f"Video dimensions: {w}x{h}, FPS: {fps}, Total frames: {total_frames}")
-
-    ok, frame = cap.read()
-    while ok:
-        rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-        res = pose.process(rgb)
-
-        if res.pose_landmarks:
-            lms = res.pose_landmarks.landmark
-            mid_hip_y = (lms[LHIP].y + lms[RHIP].y) / 2.0
-            hip_y_series.append(float(mid_hip_y))
-        else:
-            hip_y_series.append(None)
-
-        frame_idx += 1
-        
-        # Update progress
-        if progress_callback and total_frames > 0:
-            progress = min(frame_idx / total_frames, 1.0)
-            progress_callback(progress, f"Processing frame {frame_idx}/{total_frames}")
-        
-        ok, frame = cap.read()
-
-    cap.release()
-    print(f"Completed processing {frame_idx} frames")
+    # Create progress callback for the athletic_performance module
+    def progress_callback(prog, desc):
+        progress(prog, desc=desc)
+    
+    # Call the core analysis function
+    result = analyze_youtube_video(youtube_url, user_height_cm, user_weight_kg, progress_callback)
+    
+    # Handle errors
+    if "error" in result:
+        return f"❌ {result['error']}", None, None
+    
+    if result is None:
+        return "⚠️ Could not analyze jump. Make sure the video shows a person clearly performing a vertical jump.", None, None
+    
+    # Format results for display
+    results_text = f"""
+## 🎉 Comprehensive Jump Analysis Results
 
-    jump_norm, flight_time_s = estimate_jump_metrics(hip_y_series, fps)
+### 📊 Core Performance Metrics
+- **Jump Height**: {result['jump_height_cm']:.2f} cm
+- **Flight Time**: {result['flight_time_s']:.3f} seconds  
+- **Normalized Rise**: {result['normalized_rise']:.3f} ({result['normalized_rise']*100:.1f}%)
 
-    if jump_norm is None:
-        return None
+### ⚡ Power & Force Metrics
+- **Peak Power Output**: {result.get('peak_power_watts', 0):.0f} watts
+- **Peak Force**: {result.get('peak_force_n', 0):.0f} N
+- **Impulse**: {result.get('impulse_ns', 0):.2f} N⋅s
 
-    jump_height_cm = jump_norm * user_height_cm
+### 🚀 Explosiveness Metrics
+- **Rate of Force Development**: {result.get('rate_of_force_development', 0):.2f}
+- **Takeoff Phase Duration**: {result.get('takeoff_phase_duration_s', 0):.3f} seconds
+- **Ground Contact Time**: {result.get('ground_contact_time_s', 0):.3f} seconds
 
-    return {
-        "video": Path(video_path).name,
-        "frames": len(hip_y_series),
-        "fps": fps,
-        "jump_height_cm": jump_height_cm,
-        "normalized_rise": jump_norm,
-        "flight_time_s": flight_time_s
-    }
+### 📹 Video Information
+- **Total Frames**: {result['frames']}
+- **Frame Rate**: {result['fps']:.2f} FPS
+- **Video File**: {result['video']}
+- **Subject Weight**: {result.get('user_weight_kg', 'N/A')} kg
 
-def analyze_jump_from_youtube(youtube_url, user_height_cm, progress=gr.Progress()):
-    """Main analysis function for Gradio interface."""
+### 📈 Performance Insights
+"""
     
-    # Validate inputs
-    if not youtube_url or not youtube_url.strip():
-        return "❌ Please provide a YouTube URL", None, None
+    # Add performance insights using the new function
+    insights = get_performance_insights(result)
+    for insight in insights:
+        results_text += f"{insight}\n"
     
-    if not user_height_cm or user_height_cm <= 0:
-        return "❌ Please provide a valid height in centimeters", None, None
+    # Create a comprehensive results dataframe for the table
+    results_df = pd.DataFrame([
+        ["Jump Height", f"{result['jump_height_cm']:.2f} cm"],
+        ["Flight Time", f"{result['flight_time_s']:.3f} seconds"],
+        ["Peak Power", f"{result.get('peak_power_watts', 0):.0f} watts"],
+        ["Peak Force", f"{result.get('peak_force_n', 0):.0f} N"],
+        ["Rate of Force Development", f"{result.get('rate_of_force_development', 0):.2f}"],
+        ["Ground Contact Time", f"{result.get('ground_contact_time_s', 0):.3f} seconds"],
+        ["Impulse", f"{result.get('impulse_ns', 0):.2f} N⋅s"],
+        ["Takeoff Duration", f"{result.get('takeoff_phase_duration_s', 0):.3f} seconds"],
+        ["Normalized Rise", f"{result['normalized_rise']*100:.1f}%"],
+        ["Video Frames", f"{result['frames']}"],
+        ["Frame Rate", f"{result['fps']:.2f} FPS"],
+    ], columns=["Metric", "Value"])
     
-    try:
-        progress(0.1, desc="Validating YouTube URL...")
-        
-        # Validate YouTube URL
-        youtube_url = youtube_url.strip()
-        if not any(domain in youtube_url for domain in ['youtube.com', 'youtu.be']):
-            return "❌ Please provide a valid YouTube URL", None, None
-        
-        # Create temporary directory for processing
-        with tempfile.TemporaryDirectory() as temp_dir:
-            progress(0.2, desc="Downloading video from YouTube...")
-            
-            # Download video
-            video_filename = os.path.join(temp_dir, 'video.%(ext)s')
-            try:
-                download_youtube_video(youtube_url, video_filename)
-                # Find the actual downloaded file
-                video_files = [f for f in os.listdir(temp_dir) if f.startswith('video.')]
-                if not video_files:
-                    return "❌ Failed to download YouTube video. Please check the URL and try again.", None, None
-                video_path = os.path.join(temp_dir, video_files[0])
-            except Exception as e:
-                return f"❌ Failed to download YouTube video: {str(e)}", None, None
+    return results_text, results_df, "✅ Analysis completed successfully!"
 
-            progress(0.3, desc="Starting video analysis...")
-            
-            # Process the video with progress tracking
-            def update_progress(prog, desc):
-                progress(0.3 + (prog * 0.6), desc=desc)
-            
-            result = process_video_analysis(video_path, user_height_cm, update_progress)
-            
-            progress(0.9, desc="Generating results...")
-            
-            if result is None:
-                return "⚠️ Could not analyze jump. Make sure the video shows a person clearly performing a vertical jump.", None, None
-            
-            # Format results for display
-            results_text = f"""
-## 🎉 Jump Analysis Results
+def analyze_jump_from_file(video_file, user_height_cm, user_weight_kg, progress=gr.Progress()):
+    """Analysis function for uploaded video files."""
+    
+    # Create progress callback for the athletic_performance module
+    def progress_callback(prog, desc):
+        progress(prog, desc=desc)
+    
+    # Call the core analysis function
+    video_path = video_file.name if video_file else None
+    result = analyze_video_file(video_path, user_height_cm, user_weight_kg, progress_callback)
+    
+    # Handle errors
+    if "error" in result:
+        return f"❌ {result['error']}", None, None
+    
+    if result is None:
+        return "⚠️ Could not analyze jump. Make sure the video shows a person clearly performing a vertical jump.", None, None
+    
+    # Format results (same as YouTube function)
+    results_text = f"""
+## 🎉 Comprehensive Jump Analysis Results
 
-### 📊 Performance Metrics
+### 📊 Core Performance Metrics
 - **Jump Height**: {result['jump_height_cm']:.2f} cm
 - **Flight Time**: {result['flight_time_s']:.3f} seconds  
 - **Normalized Rise**: {result['normalized_rise']:.3f} ({result['normalized_rise']*100:.1f}%)
 
+### ⚡ Power & Force Metrics
+- **Peak Power Output**: {result.get('peak_power_watts', 0):.0f} watts
+- **Peak Force**: {result.get('peak_force_n', 0):.0f} N
+- **Impulse**: {result.get('impulse_ns', 0):.2f} N⋅s
+
+### 🚀 Explosiveness Metrics
+- **Rate of Force Development**: {result.get('rate_of_force_development', 0):.2f}
+- **Takeoff Phase Duration**: {result.get('takeoff_phase_duration_s', 0):.3f} seconds
+- **Ground Contact Time**: {result.get('ground_contact_time_s', 0):.3f} seconds
+
 ### 📹 Video Information
 - **Total Frames**: {result['frames']}
 - **Frame Rate**: {result['fps']:.2f} FPS
 - **Video File**: {result['video']}
+- **Subject Weight**: {result.get('user_weight_kg', 'N/A')} kg
 
 ### 📈 Performance Insights
 """
-            
-            # Add performance insights
-            if result['jump_height_cm'] > 60:
-                results_text += "🔥 **Excellent jump height!** This is above average performance.\n"
-            elif result['jump_height_cm'] > 40:
-                results_text += "👍 **Good jump height!** Solid athletic performance.\n"
-            elif result['jump_height_cm'] > 25:
-                results_text += "📈 **Moderate jump height.** Room for improvement with training.\n"
-            else:
-                results_text += "🎯 **Starting point identified.** Focus on technique and strength training.\n"
-            
-            if result['flight_time_s'] > 0.5:
-                results_text += "⏱️ **Great flight time!** Shows good explosive power.\n"
-            elif result['flight_time_s'] > 0.3:
-                results_text += "⏱️ **Decent flight time.** Good coordination.\n"
-            
-            # Create a results dataframe for the table
-            results_df = pd.DataFrame([
-                ["Jump Height", f"{result['jump_height_cm']:.2f} cm"],
-                ["Flight Time", f"{result['flight_time_s']:.3f} seconds"],
-                ["Normalized Rise", f"{result['normalized_rise']*100:.1f}%"],
-                ["Video Frames", f"{result['frames']}"],
-                ["Frame Rate", f"{result['fps']:.2f} FPS"],
-            ], columns=["Metric", "Value"])
-            
-            progress(1.0, desc="Analysis complete!")
-            
-            return results_text, results_df, "✅ Analysis completed successfully!"
-            
-    except Exception as e:
-        return f"❌ Error during analysis: {str(e)}", None, None
+    
+    # Add performance insights using the new function
+    insights = get_performance_insights(result)
+    for insight in insights:
+        results_text += f"{insight}\n"
+    
+    # Create a comprehensive results dataframe for the table
+    results_df = pd.DataFrame([
+        ["Jump Height", f"{result['jump_height_cm']:.2f} cm"],
+        ["Flight Time", f"{result['flight_time_s']:.3f} seconds"],
+        ["Peak Power", f"{result.get('peak_power_watts', 0):.0f} watts"],
+        ["Peak Force", f"{result.get('peak_force_n', 0):.0f} N"],
+        ["Rate of Force Development", f"{result.get('rate_of_force_development', 0):.2f}"],
+        ["Ground Contact Time", f"{result.get('ground_contact_time_s', 0):.3f} seconds"],
+        ["Impulse", f"{result.get('impulse_ns', 0):.2f} N⋅s"],
+        ["Takeoff Duration", f"{result.get('takeoff_phase_duration_s', 0):.3f} seconds"],
+        ["Normalized Rise", f"{result['normalized_rise']*100:.1f}%"],
+        ["Video Frames", f"{result['frames']}"],
+        ["Frame Rate", f"{result['fps']:.2f} FPS"],
+    ], columns=["Metric", "Value"])
+    
+    return results_text, results_df, "✅ Analysis completed successfully!"
 
-def analyze_jump_from_file(video_file, user_height_cm, progress=gr.Progress()):
-    """Analysis function for uploaded video files."""
+def get_ai_coaching_recommendations(youtube_url, video_file, user_height_cm, user_weight_kg, gender, gemini_api_key, progress=gr.Progress()):
+    """Get AI-powered sports coaching recommendations."""
     
     # Validate inputs
-    if video_file is None:
-        return "❌ Please upload a video file", None, None
+    if not gemini_api_key or not gemini_api_key.strip():
+        return "❌ Please provide your Gemini API key", None, None
+    
+    if not gender:
+        return "❌ Please select your gender", None, None
     
     if not user_height_cm or user_height_cm <= 0:
-        return "❌ Please provide a valid height in centimeters", None, None
+        return "❌ Please provide a valid height", None, None
+    
+    # Determine which video source to use
+    video_source = None
+    if youtube_url and youtube_url.strip():
+        video_source = "youtube"
+        progress(0.1, desc="Analyzing YouTube video...")
+    elif video_file:
+        video_source = "file"
+        progress(0.1, desc="Analyzing uploaded video...")
+    else:
+        return "❌ Please provide either a YouTube URL or upload a video file", None, None
     
     try:
-        progress(0.1, desc="Processing uploaded video...")
+        # First, get the jump analysis
+        progress(0.2, desc="Performing biomechanical analysis...")
         
-        # Process the video with progress tracking
-        def update_progress(prog, desc):
-            progress(0.1 + (prog * 0.8), desc=desc)
+        def progress_callback(prog, desc):
+            progress(0.2 + (prog * 0.5), desc=desc)
         
-        result = process_video_analysis(video_file.name, user_height_cm, update_progress)
+        if video_source == "youtube":
+            result = analyze_youtube_video(youtube_url, user_height_cm, user_weight_kg, progress_callback)
+        else:
+            video_path = video_file.name if video_file else None
+            result = analyze_video_file(video_path, user_height_cm, user_weight_kg, progress_callback)
         
-        progress(0.9, desc="Generating results...")
+        # Handle analysis errors
+        if "error" in result:
+            return f"❌ Video analysis failed: {result['error']}", None, None
         
         if result is None:
-            return "⚠️ Could not analyze jump. Make sure the video shows a person clearly performing a vertical jump.", None, None
+            return "❌ Could not analyze jump. Please ensure the video shows a clear vertical jump.", None, None
         
-        # Format results (same as YouTube function)
+        progress(0.7, desc="Getting AI coaching analysis...")
+        
+        # Get AI coaching analysis
+        ai_result = get_ai_sports_coaching_analysis(
+            jump_height_cm=result['jump_height_cm'],
+            user_height_cm=user_height_cm,
+            gender=gender,
+            peak_power_watts=result.get('peak_power_watts'),
+            flight_time_s=result.get('flight_time_s'),
+            rfd=result.get('rate_of_force_development'),
+            api_key=gemini_api_key.strip()
+        )
+        
+        progress(0.9, desc="Formatting results...")
+        
+        if "error" in ai_result:
+            return f"❌ AI analysis failed: {ai_result['error']}", None, None
+        
+        # Format the comprehensive results
         results_text = f"""
-## 🎉 Jump Analysis Results
+# 🤖 AI Sports Coaching Analysis
 
-### 📊 Performance Metrics
+## 📊 Performance Summary
 - **Jump Height**: {result['jump_height_cm']:.2f} cm
-- **Flight Time**: {result['flight_time_s']:.3f} seconds  
-- **Normalized Rise**: {result['normalized_rise']:.3f} ({result['normalized_rise']*100:.1f}%)
+- **Relative Jump**: {(result['jump_height_cm']/user_height_cm*100):.1f}% of body height
+- **Flight Time**: {result['flight_time_s']:.3f} seconds
+- **Peak Power**: {result.get('peak_power_watts', 0):.0f} watts
+- **Gender**: {gender}
+- **Height**: {user_height_cm} cm
 
-### 📹 Video Information
-- **Total Frames**: {result['frames']}
-- **Frame Rate**: {result['fps']:.2f} FPS
-- **Video File**: {result['video']}
+## 🏆 AI Expert Coaching Analysis
 
-### 📈 Performance Insights
+{ai_result['analysis']}
+
+---
+*Analysis powered by Google Gemini AI*
 """
         
-        # Add performance insights
-        if result['jump_height_cm'] > 60:
-            results_text += "🔥 **Excellent jump height!** This is above average performance.\n"
-        elif result['jump_height_cm'] > 40:
-            results_text += "👍 **Good jump height!** Solid athletic performance.\n"
-        elif result['jump_height_cm'] > 25:
-            results_text += "📈 **Moderate jump height.** Room for improvement with training.\n"
-        else:
-            results_text += "🎯 **Starting point identified.** Focus on technique and strength training.\n"
-        
-        if result['flight_time_s'] > 0.5:
-            results_text += "⏱️ **Great flight time!** Shows good explosive power.\n"
-        elif result['flight_time_s'] > 0.3:
-            results_text += "⏱️ **Decent flight time.** Good coordination.\n"
-        
-        # Create a results dataframe for the table
-        results_df = pd.DataFrame([
+        # Create summary dataframe
+        summary_df = pd.DataFrame([
             ["Jump Height", f"{result['jump_height_cm']:.2f} cm"],
+            ["Relative Jump Height", f"{(result['jump_height_cm']/user_height_cm*100):.1f}%"],
             ["Flight Time", f"{result['flight_time_s']:.3f} seconds"],
-            ["Normalized Rise", f"{result['normalized_rise']*100:.1f}%"],
-            ["Video Frames", f"{result['frames']}"],
-            ["Frame Rate", f"{result['fps']:.2f} FPS"],
+            ["Peak Power", f"{result.get('peak_power_watts', 0):.0f} watts"],
+            ["Rate of Force Development", f"{result.get('rate_of_force_development', 0):.2f}"],
+            ["Gender", gender],
+            ["Height", f"{user_height_cm} cm"],
+            ["Weight", f"{user_weight_kg} kg"],
         ], columns=["Metric", "Value"])
         
-        progress(1.0, desc="Analysis complete!")
+        progress(1.0, desc="AI coaching analysis complete!")
         
-        return results_text, results_df, "✅ Analysis completed successfully!"
+        return results_text, summary_df, "✅ AI coaching analysis completed!"
         
     except Exception as e:
-        return f"❌ Error during analysis: {str(e)}", None, None
+        return f"❌ Unexpected error: {str(e)}", None, None
 
 # Create Gradio interface
 def create_interface():
     with gr.Blocks(title="🏃‍♂️ Athletic Ability Analysis") as app:
         gr.Markdown("""
-        # 🏃‍♂️ Athletic Ability Analysis
+        # 🏃‍♂️ Athletic Ability Analysis & AI Sports Coach
+        
+        Analyze jumping performance from videos using computer vision and get AI-powered sports coaching recommendations.
+        Upload a video or provide a YouTube URL to get detailed metrics and personalized coaching insights.
         
-        Analyze jumping performance from videos using computer vision and pose estimation.
-        Upload a video or provide a YouTube URL to get detailed metrics about jump height, flight time, and athletic performance.
+        ## 🚀 Features
+        - **📊 Biomechanical Analysis**: Comprehensive jump metrics (height, power, force, RFD)
+        - **🤖 AI Sports Coach**: Personalized sport recommendations and technique improvements
+        - **🎯 Performance Insights**: Professional-grade analysis and training suggestions
         
         ## 📋 Instructions
-        1. Enter your height in centimeters
-        2. Choose either YouTube URL or file upload
-        3. Wait for the analysis to complete
-        4. View your detailed jump performance results
+        1. Enter your height in centimeters and weight in kilograms
+        2. Choose your analysis type: Basic metrics, or AI coaching with sports recommendations
+        3. Provide a video (YouTube URL or file upload)
+        4. Get comprehensive results and actionable insights
         """)
         
         with gr.Row():
-            user_height = gr.Number(
-                label="Your Height (cm)",
-                value=175,
-                minimum=100,
-                maximum=250
-            )
-        gr.Markdown("💡 *Enter your height in centimeters for accurate jump height calculation*")
+            with gr.Column():
+                user_height = gr.Number(
+                    label="Your Height (cm)",
+                    value=175,
+                    minimum=100,
+                    maximum=250
+                )
+            with gr.Column():
+                user_weight = gr.Number(
+                    label="Your Weight (kg)",
+                    value=75,
+                    minimum=30,
+                    maximum=200
+                )
+        gr.Markdown("💡 *Enter your height and weight for accurate biomechanical calculations*")
         
         with gr.Tabs():
             # YouTube URL Tab
@@ -342,6 +295,53 @@ def create_interface():
                     file_types=[".mp4", ".avi", ".mov", ".mkv", ".webm"]
                 )
                 file_btn = gr.Button("🚀 Analyze Uploaded Video", variant="primary")
+            
+            # AI Coaching Tab
+            with gr.TabItem("🤖 AI Sports Coach"):
+                gr.Markdown("""
+                ## 🤖 AI-Powered Sports Coaching Analysis
+                
+                Get personalized sports recommendations and jump technique improvement suggestions from our AI sports coach powered by Google Gemini.
+                
+                **What you'll get:**
+                - 🏆 **Recommended Sports** (top 3 that match your athletic profile)
+                - 🎯 **Jump Technique Analysis** with specific improvement suggestions
+                - 📊 **Personalized Training Recommendations**
+                """)
+                
+                with gr.Row():
+                    with gr.Column():
+                        ai_gender = gr.Radio(
+                            choices=["Male", "Female"],
+                            label="Gender",
+                            value="Male"
+                        )
+                        # Check if API key is available in environment
+                        default_api_key = os.getenv("GEMINI_API_KEY", "")
+                        ai_gemini_key = gr.Textbox(
+                            label="Gemini API Key",
+                            placeholder="Enter your Google Gemini API key" if not default_api_key else "API key loaded from environment",
+                            type="password",
+                            value=default_api_key
+                        )
+                        gr.Markdown("""
+                        💡 **Get your free API key**: [Google AI Studio](https://aistudio.google.com/app/apikey)
+                        
+                        📱 **Privacy**: Your API key is only used for this analysis and not stored.
+                        """)
+                    
+                    with gr.Column():
+                        ai_youtube_url = gr.Textbox(
+                            label="YouTube URL (Optional)",
+                            placeholder="https://youtube.com/watch?v=..."
+                        )
+                        ai_video_file = gr.File(
+                            label="Upload Video File (Optional)",
+                            file_types=[".mp4", ".avi", ".mov", ".mkv", ".webm"]
+                        )
+                        gr.Markdown("*Provide either a YouTube URL or upload a video file*")
+                
+                ai_coaching_btn = gr.Button("🤖 Get AI Coaching Analysis", variant="primary", size="lg")
         
         # Results section
         gr.Markdown("## 📊 Analysis Results")
@@ -375,31 +375,41 @@ def create_interface():
         
         1. **Pose Detection**: Uses Google's MediaPipe to detect human pose landmarks
         2. **Hip Tracking**: Tracks the midpoint between left and right hip joints
-        3. **Jump Analysis**: Calculates metrics based on hip trajectory:
-           - Jump height relative to your body size
-           - Flight time during the airborne phase
-           - Normalized rise showing jump efficiency
+        3. **Biomechanical Analysis**: Calculates comprehensive metrics based on hip trajectory:
+           - **Jump Height**: Relative to your body size
+           - **Flight Time**: Duration in the air
+           - **Peak Power Output**: Maximum power generated during takeoff
+           - **Rate of Force Development (RFD)**: Speed of force generation
+           - **Ground Contact Time**: Efficiency in stretch-shortening cycle
+           - **Impulse & Peak Force**: Force characteristics during takeoff
+           - **Takeoff Phase Duration**: Time from crouch to launch
         """)
         
         # Event handlers
         youtube_btn.click(
             fn=analyze_jump_from_youtube,
-            inputs=[youtube_url, user_height],
+            inputs=[youtube_url, user_height, user_weight],
             outputs=[results_text, results_table, status_message]
         )
         
         file_btn.click(
             fn=analyze_jump_from_file,
-            inputs=[video_file, user_height],
+            inputs=[video_file, user_height, user_weight],
+            outputs=[results_text, results_table, status_message]
+        )
+        
+        ai_coaching_btn.click(
+            fn=get_ai_coaching_recommendations,
+            inputs=[ai_youtube_url, ai_video_file, user_height, user_weight, ai_gender, ai_gemini_key],
             outputs=[results_text, results_table, status_message]
         )
         
         # Example section
         gr.Examples(
             examples=[
-                ["https://www.youtube.com/watch?v=dQw4w9WgXcQ", 175],  # This is just a placeholder
+                ["https://www.youtube.com/watch?v=dQw4w9WgXcQ", 175, 75],  # This is just a placeholder
             ],
-            inputs=[youtube_url, user_height],
+            inputs=[youtube_url, user_height, user_weight],
             label="📚 Example (Replace with actual jump video URLs)"
         )
     

athletic_performance.py

@@ -0,0 +1,573 @@
+import cv2
+import numpy as np
+import mediapipe as mp
+from collections import deque
+from pathlib import Path
+import tempfile
+import os
+import yt_dlp
+import json
+import requests
+
+# MediaPipe pose landmarks
+LHIP, RHIP = 23, 24
+POSE_CONNECTIONS = mp.solutions.pose.POSE_CONNECTIONS
+
+
+def smooth_moving_avg(series, k=5):
+    """Simple causal moving average; ignores None values."""
+    out = []
+    q = deque()
+    s = 0.0
+    cnt = 0
+    for v in series:
+        if v is not None:
+            q.append(v)
+            s += v
+            cnt += 1
+        else:
+            q.append(None)
+        if len(q) > k:
+            old = q.popleft()
+            if old is not None:
+                s -= old
+                cnt -= 1
+        out.append((s / max(cnt, 1)) if cnt > 0 else None)
+    return out
+
+
+def calculate_peak_power_output(jump_height_m, body_mass_kg, flight_time_s):
+    """Calculate peak power output using biomechanical models."""
+    if jump_height_m <= 0 or flight_time_s <= 0:
+        return None
+    
+    # Using the equation: Power = (body_mass * gravity * jump_height) / flight_time
+    # This is a simplified model - in reality, peak power occurs during takeoff phase
+    gravity = 9.81  # m/s²
+    
+    # Average power during flight
+    avg_power = (body_mass_kg * gravity * jump_height_m) / (flight_time_s / 2)
+    
+    # Peak power is typically 2-3x average power during explosive movements
+    peak_power = avg_power * 2.5
+    
+    return peak_power  # Watts
+
+
+def calculate_rate_of_force_development(hip_y_series, fps, takeoff_start_idx, takeoff_end_idx):
+    """Calculate Rate of Force Development from hip trajectory."""
+    if takeoff_end_idx <= takeoff_start_idx or len(hip_y_series) <= takeoff_end_idx:
+        return None
+    
+    # Extract takeoff phase
+    takeoff_phase = hip_y_series[takeoff_start_idx:takeoff_end_idx + 1]
+    
+    # Calculate velocity and acceleration
+    dt = 1.0 / fps
+    velocities = np.diff(takeoff_phase) / dt
+    accelerations = np.diff(velocities) / dt
+    
+    if len(accelerations) == 0:
+        return None
+    
+    # RFD is the maximum rate of change of force (approximated by acceleration)
+    # Convert to relative units (normalized by body position change)
+    max_acceleration = np.max(np.abs(accelerations))
+    
+    # Normalize to get RFD index (higher values indicate faster force development)
+    rfd_index = max_acceleration * fps  # per second
+    
+    return rfd_index
+
+
+def detect_ground_contact_phases(hip_y_series, fps, threshold_velocity=0.01):
+    """Detect ground contact and flight phases from hip trajectory."""
+    if len(hip_y_series) < 5:
+        return [], []
+    
+    # Calculate vertical velocity
+    velocities = np.diff(hip_y_series)
+    
+    # Smooth velocities
+    velocities = smooth_moving_avg(list(velocities), k=3)
+    
+    # Find phases where velocity is near zero (ground contact)
+    ground_contact_frames = []
+    flight_frames = []
+    
+    for i, vel in enumerate(velocities):
+        if vel is not None and abs(vel) < threshold_velocity:
+            ground_contact_frames.append(i)
+        elif vel is not None:
+            flight_frames.append(i)
+    
+    # Calculate ground contact time
+    if ground_contact_frames:
+        total_contact_frames = len(ground_contact_frames)
+        ground_contact_time = total_contact_frames / fps
+    else:
+        ground_contact_time = 0.0
+    
+    return ground_contact_frames, ground_contact_time
+
+
+def calculate_impulse_and_force(hip_y_series, fps, body_mass_kg, takeoff_start_idx, takeoff_end_idx):
+    """Calculate impulse and force characteristics during takeoff."""
+    if takeoff_end_idx <= takeoff_start_idx or len(hip_y_series) <= takeoff_end_idx:
+        return None, None
+    
+    # Extract takeoff phase
+    takeoff_phase = hip_y_series[takeoff_start_idx:takeoff_end_idx + 1]
+    dt = 1.0 / fps
+    
+    # Calculate velocity and acceleration
+    velocities = np.diff(takeoff_phase) / dt
+    accelerations = np.diff(velocities) / dt
+    
+    if len(accelerations) == 0:
+        return None, None
+    
+    # Estimate force (F = ma, where a includes gravity)
+    gravity = 9.81
+    forces = body_mass_kg * (np.array(accelerations) + gravity)
+    
+    # Calculate impulse (area under force-time curve)
+    impulse = np.trapz(forces, dx=dt)
+    
+    # Peak force
+    peak_force = np.max(forces) if len(forces) > 0 else None
+    
+    return impulse, peak_force
+
+
+def estimate_jump_metrics(hip_y_series, fps, body_mass_kg=75.0):
+    """Return comprehensive jump metrics including advanced biomechanical parameters."""
+    # Remove None values
+    hip_clean = [(i, h) for i, h in enumerate(hip_y_series) if h is not None]
+    if len(hip_clean) < 5:
+        return None
+    
+    indices, hip_values = zip(*hip_clean)
+    hip = list(hip_values)
+    
+    # Smooth the data
+    hip_smooth = smooth_moving_avg(hip, k=5)
+    
+    # Basic jump metrics
+    min_y = min(hip_smooth)  # apex (body highest)
+    max_y = max(hip_smooth)  # deepest crouch (body lowest)
+    jump_height_norm = max(0.0, (max_y - min_y))
+    
+    # Find key phase indices
+    hip_arr = np.array(hip_smooth, dtype=float)
+    vel = np.diff(hip_arr)
+    
+    if vel.size == 0:
+        return None
+    
+    # Identify takeoff and landing phases
+    takeoff_idx = int(np.argmin(vel))  # most negative velocity (takeoff)
+    landing_idx = int(np.argmax(vel))  # most positive velocity (landing)
+    
+    # Flight time
+    flight_frames = max(0, landing_idx - takeoff_idx)
+    flight_time_s = flight_frames / float(fps or 30.0)
+    
+    # Find takeoff phase (from crouch to takeoff)
+    crouch_idx = int(np.argmax(hip_smooth))  # deepest crouch
+    takeoff_start_idx = max(0, crouch_idx - 10)  # start of takeoff phase
+    takeoff_end_idx = takeoff_idx
+    
+    # Advanced metrics
+    jump_height_m = jump_height_norm * 2.0  # Rough conversion to meters
+    
+    # Peak Power Output
+    peak_power = calculate_peak_power_output(jump_height_m, body_mass_kg, flight_time_s)
+    
+    # Rate of Force Development
+    rfd = calculate_rate_of_force_development(hip_smooth, fps, takeoff_start_idx, takeoff_end_idx)
+    
+    # Ground Contact Time
+    ground_contact_frames, ground_contact_time = detect_ground_contact_phases(hip_smooth, fps)
+    
+    # Impulse and Force
+    impulse, peak_force = calculate_impulse_and_force(hip_smooth, fps, body_mass_kg, takeoff_start_idx, takeoff_end_idx)
+    
+    return {
+        'jump_height_norm': jump_height_norm,
+        'flight_time_s': flight_time_s,
+        'peak_power_watts': peak_power,
+        'rate_of_force_development': rfd,
+        'ground_contact_time_s': ground_contact_time,
+        'impulse_ns': impulse,
+        'peak_force_n': peak_force,
+        'takeoff_phase_duration_s': (takeoff_end_idx - takeoff_start_idx) / fps if takeoff_end_idx > takeoff_start_idx else 0
+    }
+
+
+def download_youtube_video(youtube_url, output_path):
+    """Download YouTube video to specified path."""
+    ydl_opts = {
+        'format': 'best[height<=720]',  # Limit quality for faster processing
+        'outtmpl': output_path,
+        'quiet': True,
+        'no_warnings': True,
+    }
+    
+    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+        ydl.download([youtube_url])
+    return output_path
+
+
+def process_video_analysis(video_path, user_height_cm, user_weight_kg=75.0, progress_callback=None):
+    """Core video analysis function with progress tracking.
+    
+    Args:
+        video_path (str): Path to the video file
+        user_height_cm (float): User's height in centimeters
+        user_weight_kg (float): User's weight in kilograms (default: 75kg)
+        progress_callback (callable, optional): Function to call with progress updates
+            Signature: progress_callback(progress_float, description_string)
+    
+    Returns:
+        dict: Analysis results containing jump metrics and video info
+        None: If analysis failed
+    """
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        raise Exception(f"Could not open video: {video_path}")
+
+    w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    fps = cap.get(cv2.CAP_PROP_FPS) or 30.0
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+
+    mp_pose = mp.solutions.pose
+    pose = mp_pose.Pose(static_image_mode=False, model_complexity=1, enable_segmentation=False)
+
+    hip_y_series = []
+    frame_idx = 0
+
+    print(f"Processing video: {Path(video_path).name}")
+    print(f"Video dimensions: {w}x{h}, FPS: {fps}, Total frames: {total_frames}")
+
+    ok, frame = cap.read()
+    while ok:
+        rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        res = pose.process(rgb)
+
+        if res.pose_landmarks:
+            lms = res.pose_landmarks.landmark
+            mid_hip_y = (lms[LHIP].y + lms[RHIP].y) / 2.0
+            hip_y_series.append(float(mid_hip_y))
+        else:
+            hip_y_series.append(None)
+
+        frame_idx += 1
+        
+        # Update progress
+        if progress_callback and total_frames > 0:
+            progress = min(frame_idx / total_frames, 1.0)
+            progress_callback(progress, f"Processing frame {frame_idx}/{total_frames}")
+        
+        ok, frame = cap.read()
+
+    cap.release()
+    print(f"Completed processing {frame_idx} frames")
+
+    # Calculate comprehensive jump metrics
+    metrics = estimate_jump_metrics(hip_y_series, fps, user_weight_kg)
+
+    if metrics is None:
+        return None
+
+    # Convert normalized jump height to actual height in cm
+    jump_height_cm = metrics['jump_height_norm'] * user_height_cm
+
+    return {
+        "video": Path(video_path).name,
+        "frames": len(hip_y_series),
+        "fps": fps,
+        "jump_height_cm": jump_height_cm,
+        "normalized_rise": metrics['jump_height_norm'],
+        "flight_time_s": metrics['flight_time_s'],
+        "peak_power_watts": metrics['peak_power_watts'],
+        "rate_of_force_development": metrics['rate_of_force_development'],
+        "ground_contact_time_s": metrics['ground_contact_time_s'],
+        "impulse_ns": metrics['impulse_ns'],
+        "peak_force_n": metrics['peak_force_n'],
+        "takeoff_phase_duration_s": metrics['takeoff_phase_duration_s'],
+        "user_weight_kg": user_weight_kg
+    }
+
+
+def analyze_youtube_video(youtube_url, user_height_cm, user_weight_kg=75.0, progress_callback=None):
+    """Analyze jump from YouTube video.
+    
+    Args:
+        youtube_url (str): YouTube video URL
+        user_height_cm (float): User's height in centimeters
+        user_weight_kg (float): User's weight in kilograms (default: 75kg)
+        progress_callback (callable, optional): Function to call with progress updates
+    
+    Returns:
+        dict: Analysis results or error information
+    """
+    # Validate inputs
+    if not youtube_url or not youtube_url.strip():
+        return {"error": "Please provide a YouTube URL"}
+    
+    if not user_height_cm or user_height_cm <= 0:
+        return {"error": "Please provide a valid height in centimeters"}
+    
+    try:
+        if progress_callback:
+            progress_callback(0.1, "Validating YouTube URL...")
+        
+        # Validate YouTube URL
+        youtube_url = youtube_url.strip()
+        if not any(domain in youtube_url for domain in ['youtube.com', 'youtu.be']):
+            return {"error": "Please provide a valid YouTube URL"}
+        
+        # Create temporary directory for processing
+        with tempfile.TemporaryDirectory() as temp_dir:
+            if progress_callback:
+                progress_callback(0.2, "Downloading video from YouTube...")
+            
+            # Download video
+            video_filename = os.path.join(temp_dir, 'video.%(ext)s')
+            try:
+                download_youtube_video(youtube_url, video_filename)
+                # Find the actual downloaded file
+                video_files = [f for f in os.listdir(temp_dir) if f.startswith('video.')]
+                if not video_files:
+                    return {"error": "Failed to download YouTube video. Please check the URL and try again."}
+                video_path = os.path.join(temp_dir, video_files[0])
+            except Exception as e:
+                return {"error": f"Failed to download YouTube video: {str(e)}"}
+
+            if progress_callback:
+                progress_callback(0.3, "Starting video analysis...")
+            
+            # Process the video with progress tracking
+            def update_progress(prog, desc):
+                if progress_callback:
+                    progress_callback(0.3 + (prog * 0.6), desc)
+            
+            result = process_video_analysis(video_path, user_height_cm, user_weight_kg, update_progress)
+            
+            if progress_callback:
+                progress_callback(0.9, "Analysis complete!")
+            
+            return result
+            
+    except Exception as e:
+        return {"error": f"Error during analysis: {str(e)}"}
+
+
+def analyze_video_file(video_path, user_height_cm, user_weight_kg=75.0, progress_callback=None):
+    """Analyze jump from video file.
+    
+    Args:
+        video_path (str): Path to video file
+        user_height_cm (float): User's height in centimeters
+        user_weight_kg (float): User's weight in kilograms (default: 75kg)
+        progress_callback (callable, optional): Function to call with progress updates
+    
+    Returns:
+        dict: Analysis results or error information
+    """
+    # Validate inputs
+    if not video_path:
+        return {"error": "Please provide a video file"}
+    
+    if not user_height_cm or user_height_cm <= 0:
+        return {"error": "Please provide a valid height in centimeters"}
+    
+    try:
+        if progress_callback:
+            progress_callback(0.1, "Processing video file...")
+        
+        # Process the video with progress tracking
+        def update_progress(prog, desc):
+            if progress_callback:
+                progress_callback(0.1 + (prog * 0.8), desc)
+        
+        result = process_video_analysis(video_path, user_height_cm, user_weight_kg, update_progress)
+        
+        if progress_callback:
+            progress_callback(1.0, "Analysis complete!")
+        
+        return result
+        
+    except Exception as e:
+        return {"error": f"Error during analysis: {str(e)}"}
+
+
+def get_performance_insights(result_dict):
+    """Generate performance insights based on comprehensive jump metrics.
+    
+    Args:
+        result_dict (dict): Dictionary containing all jump analysis results
+    
+    Returns:
+        list: List of insight strings
+    """
+    insights = []
+    
+    jump_height_cm = result_dict.get('jump_height_cm', 0)
+    flight_time_s = result_dict.get('flight_time_s', 0)
+    peak_power_watts = result_dict.get('peak_power_watts')
+    rfd = result_dict.get('rate_of_force_development')
+    ground_contact_time = result_dict.get('ground_contact_time_s')
+    peak_force = result_dict.get('peak_force_n')
+    
+    # Jump height insights
+    if jump_height_cm > 60:
+        insights.append("🔥 **Excellent jump height!** This is above average performance.")
+    elif jump_height_cm > 40:
+        insights.append("👍 **Good jump height!** Solid athletic performance.")
+    elif jump_height_cm > 25:
+        insights.append("📈 **Moderate jump height.** Room for improvement with training.")
+    else:
+        insights.append("🎯 **Starting point identified.** Focus on technique and strength training.")
+    
+    # Flight time insights
+    if flight_time_s > 0.5:
+        insights.append("⏱️ **Great flight time!** Shows good explosive power.")
+    elif flight_time_s > 0.3:
+        insights.append("⏱️ **Decent flight time.** Good coordination.")
+    
+    # Peak power insights
+    if peak_power_watts and peak_power_watts > 3000:
+        insights.append("⚡ **Outstanding power output!** Elite-level explosive strength.")
+    elif peak_power_watts and peak_power_watts > 2000:
+        insights.append("💪 **High power output!** Strong explosive capabilities.")
+    elif peak_power_watts and peak_power_watts > 1000:
+        insights.append("🏋️ **Moderate power output.** Good base strength to build on.")
+    
+    # Rate of Force Development insights
+    if rfd and rfd > 15:
+        insights.append("🚀 **Excellent RFD!** Very quick force generation - great for sprinting and jumping.")
+    elif rfd and rfd > 10:
+        insights.append("⚡ **Good RFD!** Solid ability to generate force quickly.")
+    elif rfd and rfd > 5:
+        insights.append("📊 **Moderate RFD.** Work on plyometric training to improve explosiveness.")
+    
+    # Ground contact time insights
+    if ground_contact_time and ground_contact_time < 0.2:
+        insights.append("🦘 **Excellent ground contact time!** Very efficient stretch-shortening cycle.")
+    elif ground_contact_time and ground_contact_time < 0.3:
+        insights.append("👟 **Good ground contact efficiency.** Solid reactive strength.")
+    
+    # Peak force insights
+    if peak_force and peak_force > 2000:
+        insights.append("🏋️‍♂️ **High peak force production!** Strong neuromuscular system.")
+    elif peak_force and peak_force > 1500:
+        insights.append("💪 **Good force production.** Solid strength foundation.")
+    
+    return insights
+
+
+def get_ai_sports_coaching_analysis(jump_height_cm, user_height_cm, gender, peak_power_watts=None, 
+                                   flight_time_s=None, rfd=None, api_key=None):
+    """Get AI-powered sports coaching analysis using Google Gemini API.
+    
+    Args:
+        jump_height_cm (float): Jump height in centimeters
+        user_height_cm (float): User's height in centimeters
+        gender (str): User's gender ('Male' or 'Female')
+        peak_power_watts (float, optional): Peak power output in watts
+        flight_time_s (float, optional): Flight time in seconds
+        rfd (float, optional): Rate of force development
+        api_key (str): Google Gemini API key
+    
+    Returns:
+        dict: AI analysis with sports recommendations and improvement suggestions
+    """
+    if not api_key:
+        return {"error": "Gemini API key is required"}
+    
+    # Calculate relative jump height
+    relative_jump_height = (jump_height_cm / user_height_cm) * 100 if user_height_cm > 0 else 0
+    
+    # Prepare the analysis prompt
+    prompt = f"""Consider yourself an expert sports coach and biomechanics analyst. Based on the following athletic performance data, provide your professional analysis:
+
+ATHLETE PROFILE:
+- Gender: {gender}
+- Height: {user_height_cm} cm
+- Jump Height: {jump_height_cm} cm
+- Relative Jump Height: {relative_jump_height:.1f}% of body height
+- Flight Time: {flight_time_s:.3f} seconds (if available: {flight_time_s is not None})
+- Peak Power Output: {peak_power_watts:.0f} watts (if available: {peak_power_watts is not None})
+- Rate of Force Development: {rfd:.2f} (if available: {rfd is not None})
+
+ANALYSIS REQUIRED:
+Please provide a comprehensive analysis with exactly these two sections:
+
+1. RECOMMENDED SPORTS (Maximum 3 sports):
+Based on the athletic profile, suggest the top 3 sports where this athlete would likely excel. Consider their explosive power, jump ability, and biomechanical characteristics. Be specific about why each sport matches their strengths.
+
+2. JUMP TECHNIQUE IMPROVEMENT:
+Analyze potential areas for improvement in their jumping technique. Consider possible errors in their jump execution, training recommendations, and specific drills that could enhance their performance. Focus on actionable advice.
+
+Please format your response clearly with these two distinct sections and provide practical, evidence-based recommendations."""
+
+    # Prepare the API request
+    url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent"
+    
+    headers = {
+        'Content-Type': 'application/json',
+        'X-goog-api-key': api_key
+    }
+    
+    data = {
+        "contents": [
+            {
+                "parts": [
+                    {
+                        "text": prompt
+                    }
+                ]
+            }
+        ],
+        "generationConfig": {
+            "temperature": 0.7,
+            "topK": 40,
+            "topP": 0.95,
+            "maxOutputTokens": 1024
+        }
+    }
+    
+    try:
+        response = requests.post(url, headers=headers, json=data, timeout=30)
+        response.raise_for_status()
+        
+        result = response.json()
+        
+        if 'candidates' in result and len(result['candidates']) > 0:
+            ai_analysis = result['candidates'][0]['content']['parts'][0]['text']
+            
+            return {
+                "success": True,
+                "analysis": ai_analysis,
+                "athlete_profile": {
+                    "gender": gender,
+                    "height_cm": user_height_cm,
+                    "jump_height_cm": jump_height_cm,
+                    "relative_jump_height": relative_jump_height,
+                    "flight_time_s": flight_time_s,
+                    "peak_power_watts": peak_power_watts,
+                    "rfd": rfd
+                }
+            }
+        else:
+            return {"error": "No response generated from AI"}
+            
+    except requests.exceptions.RequestException as e:
+        return {"error": f"API request failed: {str(e)}"}
+    except json.JSONDecodeError as e:
+        return {"error": f"Failed to parse API response: {str(e)}"}
+    except Exception as e:
+        return {"error": f"Unexpected error: {str(e)}"}

deploy_hf.py

@@ -29,6 +29,13 @@ def main():
     
     print("✅ Found app.py")
     
+    # Check if athletic_performance.py exists
+    if not os.path.exists("athletic_performance.py"):
+        print("❌ Error: athletic_performance.py not found.")
+        sys.exit(1)
+    
+    print("✅ Found athletic_performance.py")
+    
     # Check if requirements.txt exists
     if not os.path.exists("requirements.txt"):
         print("❌ Error: requirements.txt not found.")
@@ -66,9 +73,10 @@ def main():
     
     print("\n📋 Deployment Checklist:")
     print("1. ✅ app.py - Main Gradio application")
-    print("2. ✅ requirements.txt - Python dependencies")
-    print("3. ✅ README.md - With HF Spaces header")
-    print("4. ✅ Dependencies tested")
+    print("2. ✅ athletic_performance.py - Core analysis module")
+    print("3. ✅ requirements.txt - Python dependencies")
+    print("4. ✅ README.md - With HF Spaces header")
+    print("5. ✅ Dependencies tested")
     
     print("\n🚀 Ready for Hugging Face Spaces deployment!")
     print("\n📖 Deployment Instructions:")
@@ -77,9 +85,14 @@ def main():
     print("3. Choose 'Gradio' as the SDK")
     print("4. Upload these files:")
     print("   - app.py")
+    print("   - athletic_performance.py")
     print("   - requirements.txt") 
     print("   - README.md")
-    print("5. Wait for automatic deployment")
+    print("5. 🔐 IMPORTANT - Set up API Key Security:")
+    print("   - Go to Space Settings")
+    print("   - Add Secret: GEMINI_API_KEY = your_api_key")
+    print("   - NEVER commit API keys to your repository!")
+    print("6. Wait for automatic deployment")
     print("\n🔗 Your Space will be available at:")
     print("   https://huggingface.co/spaces/YOUR_USERNAME/athletic-ability-analysis")
     

requirements.txt

@@ -3,4 +3,5 @@ opencv-python-headless>=4.8.0
 numpy>=1.21.0
 mediapipe>=0.10.14
 yt-dlp>=2023.7.6
-pandas>=2.0.0
+pandas>=2.0.0
+requests>=2.28.0