Upload 10 files

app.py

@@ -4,8 +4,7 @@ import os
 from athletic_performance import (
     analyze_youtube_video, analyze_video_file, get_performance_insights, 
     get_ai_sports_coaching_analysis, test_gemini_api_connection,
-    generate_annotated_video_from_youtube, generate_annotated_video_from_file,
-    generate_complete_analysis_with_video
+    generate_annotated_video_from_youtube, generate_annotated_video_from_file
 )
 
 def analyze_jump_from_youtube(youtube_url, user_height_cm, user_weight_kg, progress=gr.Progress()):
@@ -63,7 +62,7 @@ def analyze_jump_from_youtube(youtube_url, user_height_cm, user_weight_kg, progr
 
 ### 📈 Performance Insights
 """
-            
+    
     # Add performance insights using the new function
     insights = get_performance_insights(result)
     for insight in insights:
@@ -100,11 +99,11 @@ def analyze_jump_from_file(video_file, user_height_cm, user_weight_kg, progress=
     # 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)
+    
+    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)
     # Handle potential None values safely
     jump_height = result.get('jump_height_cm', 0) or 0
     flight_time = result.get('flight_time_s', 0) or 0
@@ -142,7 +141,7 @@ def analyze_jump_from_file(video_file, user_height_cm, user_weight_kg, progress=
 
 ### 📈 Performance Insights
 """
-        
+    
     # Add performance insights using the new function
     insights = get_performance_insights(result)
     for insight in insights:
@@ -397,139 +396,6 @@ Your annotated video is ready for download!
     return results_text, summary_df, video_path
 
 
-def complete_analysis_with_video_stream(youtube_url, video_file, user_height_cm, user_weight_kg, gender, gemini_api_key, progress=gr.Progress()):
-    """Complete analysis with AI coaching and video streaming."""
-    
-    # Validate inputs
-    if not user_height_cm or user_height_cm <= 0:
-        return "❌ Please provide a valid height", None, None, None
-    
-    if not user_weight_kg or user_weight_kg <= 0:
-        return "❌ Please provide a valid weight", None, None, None
-    
-    if not gender:
-        return "❌ Please select your gender", None, None, None
-    
-    # Determine video source and path
-    video_source = None
-    video_path_or_url = None
-    
-    if youtube_url and youtube_url.strip():
-        video_source = "youtube"
-        video_path_or_url = youtube_url.strip()
-        progress(0.05, desc="Processing YouTube video...")
-    elif video_file:
-        video_source = "file"
-        video_path_or_url = video_file.name
-        progress(0.05, desc="Processing uploaded video...")
-    else:
-        return "❌ Please provide either a YouTube URL or upload a video file", None, None, None
-    
-    try:
-        # Create progress callback
-        def progress_callback(prog, desc):
-            progress(prog, desc=desc)
-        
-        # Run complete analysis
-        result = generate_complete_analysis_with_video(
-            video_source=video_source,
-            video_path_or_url=video_path_or_url,
-            user_height_cm=user_height_cm,
-            user_weight_kg=user_weight_kg,
-            gender=gender,
-            api_key=gemini_api_key.strip() if gemini_api_key else None,
-            progress_callback=progress_callback
-        )
-        
-        # Handle errors
-        if "error" in result:
-            return f"❌ Analysis failed: {result['error']}", None, None, None
-        
-        if not result.get("success"):
-            return "❌ Analysis failed. Please ensure the video shows a clear vertical jump.", None, None, None
-        
-        # Extract results
-        video_path = result.get("video_path")
-        jump_metrics = result.get("jump_metrics", {})
-        jump_references = result.get("jump_references", {})
-        ai_coaching = result.get("ai_coaching")
-        
-        # Handle potential None values safely
-        jump_height = jump_metrics.get('jump_height_cm', 0) or 0
-        flight_time = jump_metrics.get('flight_time_s', 0) or 0
-        peak_power = jump_metrics.get('peak_power_watts', 0) or 0
-        rfd = jump_metrics.get('rate_of_force_development', 0) or 0
-        
-        # Format comprehensive results
-        results_text = f"""
-# 🎬 Complete Athletic Performance Analysis
-
-## 📊 Performance Metrics
-- **Jump Height**: {jump_height:.2f} cm
-- **Relative Jump**: {(jump_height/user_height_cm*100):.1f}% of body height
-- **Flight Time**: {flight_time:.3f} seconds
-- **Peak Power**: {peak_power:.0f} watts
-- **Rate of Force Development**: {rfd:.2f}
-
-## 📏 Performance Comparison
-- **Your Performance**: {jump_height:.1f} cm
-- **Average for {gender}**: {jump_references.get('average', 0):.1f} cm
-- **Professional Level**: {jump_references.get('professional', 0):.1f} cm
-
-## 🎥 Video Analysis Features
-- ✅ **Real-time Pose Tracking**: Skeleton overlay throughout jump
-- ✅ **Performance Reference Lines**: Average vs Professional benchmarks  
-- ✅ **Knee Strain Detection**: Automatic form analysis with warnings
-- ✅ **Live Metrics Display**: Frame-by-frame jump height tracking
-
-"""
-        
-        # Add AI coaching analysis if available
-        if ai_coaching and ai_coaching.get("success"):
-            results_text += f"""
-## 🤖 AI Sports Coach Analysis
-
-{ai_coaching.get('analysis', 'AI analysis not available')}
-
----
-*Analysis powered by Google Gemini AI*
-"""
-        elif gemini_api_key:
-            results_text += """
-## 🤖 AI Sports Coach Analysis
-
-❌ AI coaching analysis failed. Please check your API key and try again.
-"""
-        else:
-            results_text += """
-## 🤖 AI Sports Coach Analysis
-
-💡 **Provide a Gemini API key to get personalized sports recommendations and technique improvements!**
-
-Get your free API key at: [Google AI Studio](https://aistudio.google.com/app/apikey)
-"""
-        
-        # Create comprehensive summary dataframe
-        summary_data = [
-            ["Jump Height", f"{jump_height:.2f} cm"],
-            ["Flight Time", f"{flight_time:.3f} seconds"],
-            ["Peak Power", f"{peak_power:.0f} watts"],
-            ["Rate of Force Development", f"{rfd:.2f}"],
-            ["Performance vs Average", f"{((jump_height/jump_references.get('average', 1))*100):.0f}%"],
-            ["Performance vs Pro", f"{((jump_height/jump_references.get('professional', 1))*100):.0f}%"],
-            ["Video Features", "Pose + References + Strain Detection"],
-            ["AI Coaching", "✅ Included" if ai_coaching and ai_coaching.get("success") else "❌ Not Available"],
-        ]
-        
-        summary_df = pd.DataFrame(summary_data, columns=["Metric", "Value"])
-        
-        # Return results with video for streaming
-        return results_text, summary_df, video_path, "✅ Complete analysis ready!"
-        
-    except Exception as e:
-        return f"❌ Unexpected error: {str(e)}", None, None, None
-
-
 # Create Gradio interface
 def create_interface():
     with gr.Blocks(title="🏃‍♂️ Athletic Ability Analysis") as app:
@@ -545,25 +411,25 @@ def create_interface():
         - **🎬 Annotated Videos**: Generate training videos with pose tracking and performance overlays
         - **⚠️ Technique Analysis**: Real-time knee strain detection and form corrections
         - **🎯 Performance Insights**: Professional-grade analysis and training suggestions
-        - **📺 Video Streaming**: Watch your annotated analysis video directly in the browser
         
         ## 📋 Instructions
         1. Enter your height in centimeters and weight in kilograms
         2. Choose your analysis type: 
-           - **📊 Standard Analysis**: Get detailed biomechanical metrics only
-           - **🎬 Complete Analysis**: Get annotated video + AI coaching + streaming (Recommended!)
+           - **📊 Standard Analysis**: Get detailed biomechanical metrics
+           - **🤖 AI Sports Coach**: Personalized recommendations and sport suggestions  
+           - **🎬 Video Generation**: Create annotated training videos with visual overlays
         3. Provide a video (YouTube URL or file upload)
-        4. Get comprehensive results with video streaming and AI coaching insights
+        4. Get comprehensive results, actionable insights, or downloadable training videos
         """)
         
         with gr.Row():
             with gr.Column():
                 user_height = gr.Number(
-                label="Your Height (cm)",
-                value=175,
-                minimum=100,
-                maximum=250
-            )
+                    label="Your Height (cm)",
+                    value=175,
+                    minimum=100,
+                    maximum=250
+                )
             with gr.Column():
                 user_weight = gr.Number(
                     label="Your Weight (kg)",
@@ -592,48 +458,34 @@ def create_interface():
                 )
                 file_btn = gr.Button("🚀 Analyze Uploaded Video", variant="primary")
             
-            # Complete Analysis Tab  
-            with gr.TabItem("🎬 Complete Analysis + AI Coach"):
+            # AI Coaching Tab
+            with gr.TabItem("🤖 AI Sports Coach"):
                 gr.Markdown("""
-                ## 🎬 Complete Athletic Performance Analysis
-                
-                Get the ultimate training analysis combining:
-                
-                ### 🎥 Annotated Training Video
-                - **🦴 Real-time Pose Tracking**: Skeleton overlay throughout jump
-                - **📏 Performance Reference Lines**: Average vs Professional benchmarks
-                - **⚠️ Knee Strain Detection**: Automatic form analysis with red warnings
-                - **📊 Live Metrics Display**: Frame-by-frame jump height tracking
+                ## 🤖 AI-Powered Sports Coaching Analysis
                 
-                ### 🤖 AI Sports Coach Analysis  
-                - **🏆 Sport Recommendations**: Top 3 sports matching your athletic profile
-                - **🎯 Technique Improvements**: Specific jump form corrections
-                - **📈 Training Insights**: Personalized performance enhancement tips
+                Get personalized sports recommendations and jump technique improvement suggestions from our AI sports coach powered by Google Gemini.
                 
-                ### 📺 Video Streaming
-                - **Watch directly in browser**: No downloads required
-                - **Professional annotations**: Training-ready video output
-                - **Shareable results**: Perfect for coaches and athletes
+                **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():
-                        complete_gender = gr.Radio(
+                        ai_gender = gr.Radio(
                             choices=["Male", "Female"],
                             label="Gender",
                             value="Male"
                         )
-                        gr.Markdown("*Used for performance references and AI analysis*")
-                        
                         # Check if API key is available in environment
                         default_api_key = os.getenv("GEMINI_API_KEY", "")
-                        complete_gemini_key = gr.Textbox(
-                            label="Gemini API Key (Optional for AI Coaching)",
-                            placeholder="Enter your Google Gemini API key for AI coaching" if not default_api_key else "API key loaded from environment",
+                        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
                         )
-                        
                         with gr.Row():
                             test_api_btn = gr.Button("🧪 Test API Key", size="sm")
                         
@@ -647,21 +499,60 @@ def create_interface():
                         gr.Markdown("""
                         💡 **Get your free API key**: [Google AI Studio](https://aistudio.google.com/app/apikey)
                         
-                        ⚠️ **Note**: Video generation works without API key, but AI coaching requires one
+                        📱 **Privacy**: Your API key is only used for this analysis and not stored.
                         """)
                     
                     with gr.Column():
-                        complete_youtube_url = gr.Textbox(
+                        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")
+            
+            # Video Generation Tab
+            with gr.TabItem("🎬 Annotated Video"):
+                gr.Markdown("""
+                ## 🎬 Generate Annotated Training Video
+                
+                Create a professional training video with visual overlays including:
+                - **🦴 Pose Tracking**: Real-time skeleton visualization
+                - **📏 Performance Lines**: Average vs Professional jump heights
+                - **⚠️ Knee Strain Detection**: Red warnings for poor form
+                - **📊 Live Metrics**: Frame-by-frame jump analysis
+                
+                Perfect for coaches, athletes, and performance analysis!
+                """)
+                
+                with gr.Row():
+                    with gr.Column():
+                        video_gender = gr.Radio(
+                            choices=["Male", "Female"],
+                            label="Gender (for performance references)",
+                            value="Male"
+                        )
+                        gr.Markdown("*Used to set appropriate average/pro jump height lines*")
+                    
+                    with gr.Column():
+                        gr.Markdown("### Video Input Options")
+                        video_youtube_url = gr.Textbox(
                             label="YouTube URL (Option 1)",
                             placeholder="https://youtube.com/watch?v=..."
                         )
-                        complete_video_file = gr.File(
+                        video_file_upload = gr.File(
                             label="Upload Video File (Option 2)",
                             file_types=[".mp4", ".avi", ".mov", ".mkv", ".webm"]
                         )
                         gr.Markdown("*Provide either a YouTube URL or upload a video file*")
                 
-                complete_analysis_btn = gr.Button("🚀 Get Complete Analysis + Video", variant="primary", size="lg")
+                with gr.Row():
+                    video_youtube_btn = gr.Button("🎬 Generate from YouTube", variant="primary", size="lg")
+                    video_file_btn = gr.Button("🎬 Generate from Upload", variant="primary", size="lg")
         
         # Results section
         gr.Markdown("## 📊 Analysis Results")
@@ -676,14 +567,6 @@ def create_interface():
                     datatype=["str", "str"]
                 )
         
-        # Video streaming section
-        with gr.Row():
-            with gr.Column():
-                analysis_video = gr.Video(
-                    label="📺 Annotated Training Video",
-                    visible=False
-                )
-        
         status_message = gr.Textbox(label="Status", interactive=False)
         
         # Video requirements
@@ -726,25 +609,10 @@ def create_interface():
             outputs=[results_text, results_table, status_message]
         )
         
-        # Complete analysis with video streaming
-        def complete_analysis_with_video_display(youtube_url, video_file, user_height_cm, user_weight_kg, gender, gemini_api_key, progress=gr.Progress()):
-            # Get the complete analysis
-            results_text_output, summary_df, video_path, status = complete_analysis_with_video_stream(
-                youtube_url, video_file, user_height_cm, user_weight_kg, gender, gemini_api_key, progress
-            )
-            
-            # Update video component visibility and content
-            if video_path and os.path.exists(video_path):
-                video_update = gr.update(value=video_path, visible=True)
-            else:
-                video_update = gr.update(visible=False)
-            
-            return results_text_output, summary_df, video_update, status
-        
-        complete_analysis_btn.click(
-            fn=complete_analysis_with_video_display,
-            inputs=[complete_youtube_url, complete_video_file, user_height, user_weight, complete_gender, complete_gemini_key],
-            outputs=[results_text, results_table, analysis_video, 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]
         )
         
         # API key test handler
@@ -754,10 +622,23 @@ def create_interface():
         
         test_api_btn.click(
             fn=test_and_show_result,
-            inputs=[complete_gemini_key],
+            inputs=[ai_gemini_key],
             outputs=[api_test_result]
         )
         
+        # Video generation event handlers
+        video_youtube_btn.click(
+            fn=generate_video_from_youtube,
+            inputs=[video_youtube_url, user_height, user_weight, video_gender],
+            outputs=[results_text, results_table, gr.File(label="Download Video")]
+        )
+        
+        video_file_btn.click(
+            fn=generate_video_from_file,
+            inputs=[video_file_upload, user_height, user_weight, video_gender],
+            outputs=[results_text, results_table, gr.File(label="Download Video")]
+        )
+        
         # Example section
         gr.Examples(
             examples=[

athletic_performance.py

@@ -826,102 +826,6 @@ def generate_annotated_video_from_file(video_file_path, user_height_cm, user_wei
         return {"error": f"Error during video generation: {str(e)}"}
 
 
-def generate_complete_analysis_with_video(video_source, video_path_or_url, user_height_cm, user_weight_kg, gender, api_key=None, progress_callback=None):
-    """
-    Complete analysis combining annotated video generation + AI sports coaching.
-    
-    Args:
-        video_source (str): "youtube" or "file"
-        video_path_or_url (str): YouTube URL or file path
-        user_height_cm (float): User's height in centimeters
-        user_weight_kg (float): User's weight in kilograms
-        gender (str): "Male" or "Female"
-        api_key (str, optional): Gemini API key for AI coaching
-        progress_callback (callable, optional): Progress tracking function
-    
-    Returns:
-        dict: Complete analysis with video path, AI coaching, and metrics
-    """
-    
-    try:
-        # Phase 1: Generate annotated video (50% of progress)
-        if progress_callback:
-            progress_callback(0.1, "Starting comprehensive analysis...")
-        
-        def video_progress(prog, desc):
-            if progress_callback:
-                progress_callback(0.1 + (prog * 0.4), f"Video: {desc}")
-        
-        # Generate annotated video
-        if video_source == "youtube":
-            video_result = generate_annotated_video_from_youtube(
-                video_path_or_url, user_height_cm, user_weight_kg, gender, video_progress
-            )
-        else:
-            video_result = generate_annotated_video_from_file(
-                video_path_or_url, user_height_cm, user_weight_kg, gender, video_progress
-            )
-        
-        if "error" in video_result:
-            return video_result
-        
-        # Phase 2: AI Sports Coaching Analysis (30% of progress)
-        if progress_callback:
-            progress_callback(0.5, "Generating AI sports coaching analysis...")
-        
-        ai_result = None
-        if api_key:
-            jump_metrics = video_result.get("jump_metrics", {})
-            
-            def ai_progress(prog, desc):
-                if progress_callback:
-                    progress_callback(0.5 + (prog * 0.3), f"AI: {desc}")
-            
-            ai_result = get_ai_sports_coaching_analysis(
-                jump_height_cm=jump_metrics.get('jump_height_cm', 0),
-                user_height_cm=user_height_cm,
-                gender=gender,
-                peak_power_watts=jump_metrics.get('peak_power_watts'),
-                flight_time_s=jump_metrics.get('flight_time_s'),
-                rfd=jump_metrics.get('rate_of_force_development'),
-                api_key=api_key
-            )
-            
-            if progress_callback:
-                progress_callback(0.8, "AI analysis complete!")
-        
-        # Phase 3: Combine results (20% of progress)
-        if progress_callback:
-            progress_callback(0.9, "Finalizing comprehensive analysis...")
-        
-        jump_metrics = video_result.get("jump_metrics", {})
-        jump_references = video_result.get("jump_references", {})
-        
-        # Create comprehensive result
-        result = {
-            "success": True,
-            "video_path": video_result.get("output_video_path"),
-            "jump_metrics": jump_metrics,
-            "jump_references": jump_references,
-            "ai_coaching": ai_result if ai_result and "error" not in ai_result else None,
-            "video_features": {
-                "pose_tracking": True,
-                "reference_lines": True,
-                "knee_strain_detection": True,
-                "live_metrics": True
-            },
-            "analysis_type": "complete_with_video"
-        }
-        
-        if progress_callback:
-            progress_callback(1.0, "Complete analysis ready!")
-        
-        return result
-        
-    except Exception as e:
-        return {"error": f"Error during complete analysis: {str(e)}"}
-
-
 def get_performance_insights(result_dict):
     """Generate performance insights based on comprehensive jump metrics.