Implement 5-step flow with floating sidebar in Streamlit

- Convert Gradio step-based design to Streamlit implementation
- Add custom CSS with Par-ity branding and zigzag effects
- Implement 5 steps: Upload → Analysis → Results → Improvements/Chatbot
- Add floating sidebar navigation after Step 3
- Include start over functionality and step navigation
- Switch back to Streamlit SDK in Hugging Face configuration
- Remove Gradio dependency and restore Streamlit in requirements

README.md

@@ -3,8 +3,8 @@ title: Par-ity Project
 emoji: ⛳
 colorFrom: blue
 colorTo: green
-sdk: gradio
-app_file: app.py
+sdk: streamlit
+app_file: app/streamlit_app.py
 pinned: false
 ---
 

app/streamlit_app.py

@@ -587,37 +587,106 @@ def display_video(video_path, width=300):
 
 # Main app
 def main():
-    """Main Streamlit application"""
-    st.title("Par-ity Project: Golf Swing Analysis 🏌️‍♀️")
-    st.write("Founded to address the gender gap in golf participation and access to quality coaching resources, Par-ity Project is a technology-driven initiative empowering girls in golf through innovative AI based swing analysis. This technology uses computer vision and machine learning algorithms to analyze golf swings and provide personalized feedback to improve technique and performance.")
+    """Main Streamlit application with 5-step flow"""
+    
+    # Custom CSS for Par-ity branding
+    st.markdown("""
+    <style>
+    /* Par-ity Project Styling */
+    .main-header {
+        text-align: center;
+        color: #0B3B0B;
+        font-family: 'Georgia', serif;
+        font-weight: bold;
+        margin-bottom: 10px;
+    }
     
-    # Check and display OpenAI client status immediately
-    st.markdown("---")
-    st.subheader("🔧 System Status")
+    .step-header {
+        color: #0B3B0B;
+        font-family: 'Georgia', serif;
+        font-weight: bold;
+        margin: 20px 0;
+        position: relative;
+    }
     
-    if RAG_AVAILABLE:
-        try:
-            # Create a temporary RAG instance to check OpenAI client status
-            with st.spinner("Checking OpenAI API connection..."):
-                temp_rag = GolfSwingRAG()
-                
-            if temp_rag.openai_client:
-                st.success("✅ **OpenAI API Client**: Successfully initialized and tested")
-                st.info("💡 **ChatBot & AI Analysis**: Available - You can use the Golf Swing Chatbot and AI-powered improvement recommendations")
-            else:
-                st.error("❌ **OpenAI API Client**: Not available")
-                st.warning("⚠️ **Impact**: ChatBot will use fallback responses, AI analysis may be limited")
-                st.info("🔑 **Fix**: Check that your OPENAI_API_KEY is set correctly in Hugging Face Space secrets")
-        except Exception as e:
-            st.error(f"❌ **OpenAI API Client**: Error during initialization - {str(e)}")
-            st.warning("⚠️ **Impact**: ChatBot and AI features will use fallback mode")
-    else:
-        st.error("❌ **RAG System**: Not available due to missing dependencies")
-        st.warning("⚠️ **Impact**: ChatBot feature will be disabled")
+    .step-header::after {
+        content: "";
+        display: block;
+        height: 10px;
+        background: repeating-linear-gradient(
+            135deg,
+            #1D6F42 0px,
+            #1D6F42 5px,
+            #A9DFBF 5px,
+            #A9DFBF 10px
+        );
+        margin: 8px auto 0;
+        width: 200px;
+        border-radius: 5px;
+    }
+    
+    .sidebar-nav {
+        position: fixed;
+        top: 100px;
+        right: 20px;
+        background: rgba(76, 175, 80, 0.05);
+        border: 2px solid rgba(76, 175, 80, 0.2);
+        border-radius: 15px;
+        padding: 15px;
+        z-index: 1000;
+        min-width: 150px;
+    }
+    
+    .nav-button {
+        display: block;
+        width: 100%;
+        margin: 5px 0;
+        padding: 8px 12px;
+        background: #0B3B0B;
+        color: white;
+        border: none;
+        border-radius: 20px;
+        text-align: center;
+        text-decoration: none;
+        font-size: 12px;
+        cursor: pointer;
+    }
     
-    st.markdown("---")
+    .nav-button:hover {
+        background: #4CAF50;
+    }
+    
+    .stButton > button {
+        background-color: #0B3B0B;
+        color: white;
+        border-radius: 25px;
+        border: none;
+        padding: 12px 28px;
+        font-weight: bold;
+        font-size: 16px;
+        transition: all 0.3s ease;
+    }
     
-    # Initialize session state for storing analysis results
+    .stButton > button:hover {
+        background-color: #4CAF50;
+        transform: translateY(-1px);
+    }
+    </style>
+    """, unsafe_allow_html=True)
+    
+    # Main title with logo placeholder
+    st.markdown("""
+    <div class="main-header">
+        <h1>⛳ Par-ity Project: Golf Swing Analysis</h1>
+        <p style="color: #4CAF50; font-size: 18px; margin-top: -10px;">
+            Founded to address the gender gap in golf participation and access to quality coaching resources
+        </p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Initialize session state for step-based flow
+    if 'current_step' not in st.session_state:
+        st.session_state.current_step = 1
     if 'video_analyzed' not in st.session_state:
         st.session_state.video_analyzed = False
     if 'analysis_data' not in st.session_state:
@@ -630,251 +699,282 @@ def main():
             'trajectory_data': None,
             'sample_rate': None
         }
-    if 'show_chatbot' not in st.session_state:
-        st.session_state.show_chatbot = False
+    if 'show_sidebar' not in st.session_state:
+        st.session_state.show_sidebar = False
 
-    # Add session cleanup - clean up old files when starting a new session
+    # Add session cleanup
     if 'session_initialized' not in st.session_state:
         cleanup_result = cleanup_downloads_directory(keep_annotated=True)
         if cleanup_result.get('files_removed', 0) > 0:
-            st.info(f"🗑️ Cleaned up {cleanup_result['files_removed']} old files ({cleanup_result['space_freed_mb']} MB freed)")
+            st.success(f"🗑️ Cleaned up {cleanup_result['files_removed']} old files ({cleanup_result['space_freed_mb']} MB freed)")
         st.session_state.session_initialized = True
 
-    # Automatic cleanup function
-    def perform_cleanup():
-        """Perform automatic cleanup of temporary files"""
-        cleanup_result = cleanup_downloads_directory(keep_annotated=False)
-        return cleanup_result
-
-    # Set automatic defaults (no user configuration needed)
-    # Check available LLM services and enable automatically if available
+    # Set automatic defaults
     llm_services = check_llm_services()
     any_service_available = llm_services['ollama']['available'] or llm_services['openai']['available']
-    
-    # Automatically enable LLM analysis if services are available
     enable_gpt = any_service_available
-    
-    # Set default frame processing rate (1 = all frames for best accuracy)
     sample_rate = 1
-    
-    # Disable pro comparison feature entirely
-    enable_pro_comparison = False
-    pro_url = None
-
-    # Video input options
-    st.header("Video Input")
-    input_option = st.radio("Choose input method:",
-                            ["YouTube URL", "Upload Video"])
 
-    video_path = None
-    analyze_clicked = False
-
-    if input_option == "YouTube URL":
-        youtube_url = st.text_input("Enter YouTube URL of golf swing:")
-
-        analyze_clicked = st.button("Analyze Swing", key="analyze_youtube")
-        if youtube_url and analyze_clicked:
+    # Floating sidebar navigation (appears after Step 3)
+    if st.session_state.current_step >= 3:
+        st.session_state.show_sidebar = True
+        
+    if st.session_state.show_sidebar:
+        st.markdown("""
+        <div class="sidebar-nav">
+            <h4 style="color: #0B3B0B; margin: 0 0 10px 0; font-size: 14px;">Navigation</h4>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        # Navigation buttons in sidebar
+        sidebar_col = st.sidebar
+        with sidebar_col:
+            st.markdown("### 🧭 Quick Navigation")
+            
+            if st.button("📊 Results", key="nav_results", use_container_width=True):
+                st.session_state.current_step = 3
+                st.rerun()
+                
+            if st.button("🎯 Improvements", key="nav_improvements", use_container_width=True):
+                st.session_state.current_step = 4
+                st.rerun()
+                
+            if st.button("💬 Chatbot", key="nav_chatbot", use_container_width=True):
+                st.session_state.current_step = 5
+                st.rerun()
+                
+            st.markdown("---")
+            if st.button("🔄 Start Over", key="nav_start_over", use_container_width=True):
+                # Reset all session state
+                for key in list(st.session_state.keys()):
+                    if key != 'session_initialized':
+                        del st.session_state[key]
+                st.session_state.current_step = 1
+                st.rerun()
+
+    # Step-based content rendering
+    if st.session_state.current_step == 1:
+        render_step_1()
+    elif st.session_state.current_step == 2:
+        render_step_2()
+    elif st.session_state.current_step == 3:
+        render_step_3()
+    elif st.session_state.current_step == 4:
+        render_step_4()
+    elif st.session_state.current_step == 5:
+        render_step_5()
+
+def render_step_1():
+    """Step 1: Upload Video"""
+    st.markdown('<div class="step-header"><h2>Step 1: Upload Your Video</h2></div>', unsafe_allow_html=True)
+    
+    st.markdown("**Choose your input method:**")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.markdown("#### YouTube URL")
+        youtube_url = st.text_input("Enter YouTube URL of golf swing:", key="youtube_input")
+    
+    with col2:
+        st.markdown("#### Upload Video File")
+        uploaded_file = st.file_uploader("Upload a golf swing video", type=["mp4", "mov", "avi"], key="video_upload")
+    
+    # Analyze button
+    if st.button("🏌️ Start Analysis", key="start_analysis", use_container_width=True):
+        video_path = None
+        
+        if uploaded_file is not None:
+            with st.spinner("Processing uploaded video..."):
+                try:
+                    video_path = process_uploaded_video(uploaded_file)
+                    st.success("Video uploaded successfully!")
+                except Exception as e:
+                    st.error(f"Error processing video: {str(e)}")
+                    return
+                    
+        elif youtube_url:
             if validate_youtube_url(youtube_url):
                 with st.spinner("Downloading video..."):
                     try:
                         video_path = download_youtube_video(youtube_url)
                         st.success("Video downloaded successfully!")
-                        display_video(video_path, width=400)
                     except Exception as e:
                         st.error(f"Error downloading video: {str(e)}")
-                        st.session_state.video_analyzed = False
                         return
             else:
                 st.error("Please enter a valid YouTube URL")
-                st.session_state.video_analyzed = False
                 return
+        else:
+            st.error("Please provide either a YouTube URL or upload a video file.")
+            return
+            
+        if video_path:
+            st.session_state.analysis_data['video_path'] = video_path
+            st.session_state.current_step = 2
+            st.rerun()
 
-    else:  # Upload Video
-        uploaded_file = st.file_uploader("Upload a golf swing video",
-                                         type=["mp4", "mov", "avi"])
-
-        analyze_clicked = st.button("Analyze Swing", key="analyze_upload")
-        if uploaded_file and analyze_clicked:
-            with st.spinner("Processing uploaded video..."):
-                try:
-                    video_path = process_uploaded_video(uploaded_file)
-                    st.success("Video uploaded successfully!")
-                    display_video(video_path, width=400)
-                except Exception as e:
-                    st.error(f"Error processing video: {str(e)}")
-                    st.session_state.video_analyzed = False
-                    return
+def render_step_2():
+    """Step 2: Analyzing Video and Pose"""
+    st.markdown('<div class="step-header"><h2>Step 2: Analyzing Video and Pose</h2></div>', unsafe_allow_html=True)
     
-    # Download pro reference if enabled
-    if enable_pro_comparison and (video_path or st.session_state.video_analyzed):
-        if not st.session_state.pro_reference_path:
-            with st.spinner("Downloading professional golfer reference..."):
-                try:
-                    pro_path = download_pro_reference(pro_url)
-                    st.session_state.pro_reference_path = pro_path
-                    st.success("Professional reference downloaded successfully!")
-                except Exception as e:
-                    st.error(f"Error downloading pro reference: {str(e)}")
-                    st.session_state.pro_reference_path = None
-
-    # Process video if available and analyze button was clicked
-    if video_path and analyze_clicked:
+    st.markdown("🔄 **Processing your swing video...**")
+    st.markdown("Please wait while we analyze your golf swing.")
+    
+    video_path = st.session_state.analysis_data.get('video_path')
+    
+    if video_path and not st.session_state.video_analyzed:
         try:
-            # Step 1: Process video and detect objects
+            # Process the video
             with st.spinner("Processing video and detecting objects..."):
-                frames, detections = process_video(video_path,
-                                                   sample_rate=sample_rate)
-                st.success("Video processing complete!")
+                frames, detections = process_video(video_path, sample_rate=1)
+                st.success("✅ Video processing complete!")
 
-            # Step 2: Analyze pose
             with st.spinner("Analyzing golfer's pose..."):
                 pose_data = analyze_pose(frames)
-                st.success("Pose analysis complete")
+                st.success("✅ Pose analysis complete!")
 
-            # Step 3: Segment swing into phases
             with st.spinner("Segmenting swing phases..."):
-                swing_phases = segment_swing(pose_data,
-                                             detections,
-                                             sample_rate=sample_rate)
+                swing_phases = segment_swing(pose_data, detections, sample_rate=1)
+                st.success("✅ Swing segmentation complete!")
 
-            # Step 4: Analyze trajectory and speed
             with st.spinner("Analyzing trajectory and speed..."):
-                trajectory_data = analyze_trajectory(frames,
-                                                     detections,
-                                                     swing_phases,
-                                                     sample_rate=sample_rate)
-
-            # Prepare data for LLM regardless of whether GPT is enabled
-            analysis_data = prepare_data_for_llm(pose_data, swing_phases,
-                                                 trajectory_data)
+                trajectory_data = analyze_trajectory(frames, detections, swing_phases, sample_rate=1)
+                st.success("✅ Trajectory analysis complete!")
+
+            # Prepare data for LLM
+            analysis_data = prepare_data_for_llm(pose_data, swing_phases, trajectory_data)
             prompt = create_llm_prompt(analysis_data)
 
-            # Store analysis data in session state
-            st.session_state.video_analyzed = True
-            st.session_state.analysis_data = {
-                'video_path': video_path,
+            # Store analysis data
+            st.session_state.analysis_data.update({
                 'frames': frames,
                 'detections': detections,
                 'pose_data': pose_data,
                 'swing_phases': swing_phases,
                 'trajectory_data': trajectory_data,
-                'sample_rate': sample_rate,
+                'sample_rate': 1,
                 'analysis_data': analysis_data,
                 'prompt': prompt
-            }
+            })
+            
+            st.session_state.video_analyzed = True
+            st.session_state.current_step = 3
+            st.rerun()
+            
+        except Exception as e:
+            st.error(f"❌ **Analysis Failed**\n\n{str(e)}\n\nPlease try again.")
+            
+            # Back button
+            if st.button("← Back to Upload", key="back_to_upload"):
+                st.session_state.current_step = 1
+                st.rerun()
+    else:
+        # Analysis already completed, move to results
+        st.session_state.current_step = 3
+        st.rerun()
 
-            # Trackio logging moved out of try block to avoid impacting UI
+def render_step_3():
+    """Step 3: See Results"""
+    st.markdown('<div class="step-header"><h2>Step 3: See Your Results</h2></div>', unsafe_allow_html=True)
+    
+    if st.session_state.video_analyzed:
+        data = st.session_state.analysis_data
+        video_path = data.get('video_path', '')
+        swing_phases = data.get('swing_phases', [])
+        pose_data = data.get('pose_data', [])
+        trajectory_data = data.get('trajectory_data')
+        
+        st.markdown(f"""
+        ## 🏌️ Swing Analysis Results
 
-            # Keep the original video file for potential annotation
-            # Video will be cleaned up when user uploads a new video or session ends
+        **Video:** {os.path.basename(video_path) if video_path else 'Unknown'}
 
-            # Present the options after analysis
-            st.subheader("What would you like to do next?")
-            options_col1, options_col2 = st.columns(2)
+        ### 📊 **Analysis Summary**
+        - **Swing Phases Detected:** {len(swing_phases) if swing_phases else 0}
+        - **Pose Data Points:** {len(pose_data) if pose_data else 0}
+        - **Trajectory Analysis:** {'✅ Complete' if trajectory_data else '❌ Failed'}
 
-            with options_col1:
-                st.info(
-                    "**Option 1: Generate Recommendations**\n\nGet AI-powered analysis of your swing with specific tips for improvement."
-                )
-                
-            with options_col2:
-                st.info(
-                    "**Option 2: Golf Swing Chatbot**\n\nAsk specific questions about golf swing technique and get expert advice from our knowledge base."
-                )
+        ### 🎯 **Key Findings**
+        - Swing timing and rhythm patterns identified
+        - Pose alignment and form analyzed
+        - Ball trajectory and impact mechanics evaluated
 
-        except Exception as e:
-            st.error(f"Error during analysis: {str(e)}")
-            st.session_state.video_analyzed = False
-            # Clean up on error as well
-            if video_path and os.path.exists(video_path):
-                cleanup_video_file(video_path)
+        **Ready to dive deeper?** Choose how you'd like to explore your swing analysis:
+        """)
+        
+        # Display video if available
+        if video_path and os.path.exists(video_path):
+            st.markdown("### 📹 Your Swing Video")
+            display_video(video_path, width=400)
+        
+        # Action buttons
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            if st.button("🎯 Get Improvements", key="get_improvements", use_container_width=True):
+                st.session_state.current_step = 4
+                st.rerun()
+        
+        with col2:
+            if st.button("💬 Ask Questions", key="ask_questions", use_container_width=True):
+                st.session_state.current_step = 5
+                st.rerun()
+    else:
+        st.error("No analysis data available. Please start over.")
+        if st.button("🔄 Start Over", key="restart_analysis"):
+            st.session_state.current_step = 1
+            st.rerun()
 
-    # Show action buttons and their results (only if analysis is complete)
+def render_step_4():
+    """Step 4: AI-Powered Improvements"""
+    st.markdown('<div class="step-header"><h2>Step 4: AI-Powered Improvements</h2></div>', unsafe_allow_html=True)
+    
     if st.session_state.video_analyzed:
-        # Trackio/telemetry removed per request
-
-        # Display the GPT prompt in an expander
-        if 'prompt' in st.session_state.analysis_data:
-            with st.expander("View LLM Prompt", expanded=False):
-                st.code(st.session_state.analysis_data['prompt'],
-                        language="text")
-
-        # Create columns for the action buttons
-        button_col1, button_col2 = st.columns(2)
-
-        with button_col1:
-            improvements_clicked = st.button("Generate Improvements",
-                                             key="gpt_recommendations",
-                                             use_container_width=True)
+        data = st.session_state.analysis_data
+        pose_data = data['pose_data']
+        swing_phases = data['swing_phases']
+        trajectory_data = data['trajectory_data']
         
-        with button_col2:
-            chatbot_clicked = st.button("Golf Swing Chatbot",
-                                       key="rag_chatbot",
-                                       use_container_width=True)
-
-        # Handle improvement recommendations generation
-        if improvements_clicked:
-            # Reset chatbot state when other buttons are clicked
-            st.session_state.show_chatbot = False
-            with st.spinner(
-                    "Analyzing your swing and generating recommendations..."):
-                # Get data from session state
-                data = st.session_state.analysis_data
-                pose_data = data['pose_data']
-                swing_phases = data['swing_phases']
-                trajectory_data = data['trajectory_data']
-
-                # Generate detailed analysis with recommendations
-                analysis = generate_swing_analysis(pose_data, swing_phases,
-                                                   trajectory_data)
-
-                # Display the analysis
-                st.subheader("Swing Analysis and Recommendations")
-
-                # Check available services to show appropriate message
-                llm_services = check_llm_services()
-                any_service_available = llm_services['ollama'][
-                    'available'] or llm_services['openai']['available']
-
-                if not any_service_available or not enable_gpt:
-                    st.info(
-                        "ℹ️ **Using sample analysis mode**. The recommendations below are general examples and not personalized to your specific swing."
-                    )
-                else:
-                    if llm_services['ollama']['available'] and llm_services[
-                            'openai']['available']:
-                        st.info(
-                            "🔄 **Analysis generated using available LLM services** (tried Ollama first, OpenAI as fallback)"
-                        )
-                    elif llm_services['ollama']['available']:
-                        st.info("🦙 **Analysis generated using Ollama**")
-                    elif llm_services['openai']['available']:
-                        st.info("🤖 **Analysis generated using OpenAI**")
-
-                # Parse and display the formatted analysis instead of raw markdown
-                if "Error:" not in analysis:
+        with st.spinner("🎯 **Generating personalized swing improvements...**"):
+            # Generate detailed analysis with recommendations
+            analysis = generate_swing_analysis(pose_data, swing_phases, trajectory_data)
+            
+            st.markdown("## 🎯 Personalized Swing Improvements")
+            
+            # Check available services
+            llm_services = check_llm_services()
+            any_service_available = llm_services['ollama']['available'] or llm_services['openai']['available']
+            
+            if not any_service_available:
+                st.info("ℹ️ **Using sample analysis mode**. The recommendations below are general examples.")
+            else:
+                st.info("🤖 **Analysis generated using AI-powered swing analysis technology**")
+            
+            # Display the analysis
+            if "Error:" not in analysis:
+                try:
                     formatted_analysis = parse_and_format_analysis(analysis)
                     display_formatted_analysis(formatted_analysis)
-                else:
-                    # Show error message if analysis failed
-                    st.error(analysis)
-        
-        # Handle RAG chatbot
-        if chatbot_clicked:
-            st.session_state.show_chatbot = True
+                except:
+                    st.markdown(analysis)
+            else:
+                st.error(analysis)
         
-        # Always show chatbot interface if it's active
-        if st.session_state.show_chatbot:
-            # Create header with close button
-            header_col1, header_col2 = st.columns([3, 1])
-            with header_col1:
-                st.subheader("Golf Swing Technique Chatbot")
-            with header_col2:
-                if st.button("✕ Close Chatbot", use_container_width=True):
-                    st.session_state.show_chatbot = False
-                    st.rerun()
-            
-            render_rag_interface()
+    else:
+        st.error("No analysis data available. Please analyze a video first.")
+
+def render_step_5():
+    """Step 5: Ask the Golf Expert"""
+    st.markdown('<div class="step-header"><h2>Step 5: Ask the Golf Expert</h2></div>', unsafe_allow_html=True)
+    
+    st.markdown("💬 **Ready to answer your swing questions!**")
+    
+    if RAG_AVAILABLE:
+        render_rag_interface()
+    else:
+        st.error("❌ **RAG System**: Not available due to missing dependencies")
+        st.info("The Golf Expert chatbot requires additional dependencies that are not currently available.")
 
 
 if __name__ == "__main__":

requirements.txt

@@ -9,7 +9,7 @@ torchvision==0.17.0
 openai>=1.0.0
 python-dotenv==1.0.0
 tqdm==4.66.1
-gradio>=4.0.0
+streamlit>=1.32.0
 pandas==2.1.4
 sentence-transformers>=2.2.0
 faiss-cpu>=1.7.0