Update app.py

app.py

@@ -39,43 +39,61 @@ class VideoProcessor:
             return f"Error generating response: {str(e)}"
 
 # Initialize session state properly
-if "messages" not in st.session_state:
-    st.session_state.messages = []
-if "video_processor" not in st.session_state:
-    st.session_state.video_processor = None
-if "video_file" not in st.session_state:
-    st.session_state.video_file = None
-if "video_name" not in st.session_state:
-    st.session_state.video_name = None
-if "api_key_validated" not in st.session_state:
-    st.session_state.api_key_validated = False
+def init_session_state():
+    if "messages" not in st.session_state:
+        st.session_state.messages = []
+    if "video_processor" not in st.session_state:
+        st.session_state.video_processor = None
+    if "video_file" not in st.session_state:
+        st.session_state.video_file = None
+    if "video_name" not in st.session_state:
+        st.session_state.video_name = None
+    if "api_key_validated" not in st.session_state:
+        st.session_state.api_key_validated = False
+    if "debug_mode" not in st.session_state:
+        st.session_state.debug_mode = False
 
 # Main app function
 def main():
-    st.set_page_config(page_title="Video Retrieval-Augmented Generation", page_icon="", layout="wide")
-    st.header("Video Retrieval-Augmented Generation - Gemini 2.0")
+    st.set_page_config(page_title="Video Retrieval-Augmented Generation", page_icon="🎥", layout="wide")
+    st.header("🎥 Video Retrieval-Augmented Generation - Gemini 2.0")
+    
+    # Initialize session state
+    init_session_state()
+    
+    # Debug mode toggle in sidebar
+    with st.sidebar:
+        st.session_state.debug_mode = st.checkbox("Debug Mode", value=st.session_state.debug_mode)
+        if st.session_state.debug_mode:
+            st.write("### Session State:")
+            st.write(f"API Key Validated: {st.session_state.api_key_validated}")
+            st.write(f"Video File: {'Yes' if st.session_state.video_file else 'No'}")
+            st.write(f"Video Name: {st.session_state.video_name}")
+            st.write(f"Messages Count: {len(st.session_state.messages)}")
+    
     st.markdown("---")
 
     # Step 1: API Key input
-    st.subheader("Step 1: Enter Your API Key")
+    st.subheader("📌 Step 1: Enter Your API Key")
     
     # Check for environment variable first
     env_api_key = os.environ.get("GOOGLE_API_KEY", "")
+    api_key = None
     
     if env_api_key:
-        st.info("Using API key from environment variable")
+        st.info("✅ Using API key from environment variable")
         api_key = env_api_key
         # Auto-validate environment API key
         if not st.session_state.api_key_validated:
             try:
                 st.session_state.video_processor = VideoProcessor(api_key)
                 st.session_state.api_key_validated = True
-                st.success("API key validated successfully")
+                st.success("✅ API key validated successfully")
             except Exception as e:
-                st.error(f"Invalid API key from environment: {str(e)}")
+                st.error(f"❌ Invalid API key from environment: {str(e)}")
                 api_key = None
     else:
-        # Direct API key input - users enter their key here
+        # Direct API key input
         api_key = st.text_input(
             "Enter your Gemini API key below:",
             type="password",
@@ -84,10 +102,29 @@ def main():
             key="api_key_input"
         )
         
-        # Show instructions if no API key entered
-        if not api_key:
-            st.info("Please enter your Gemini API key above to proceed")
-            with st.expander("How to obtain your API key"):
+        if api_key:
+            # Add a button to validate the API key
+            col1, col2 = st.columns([1, 4])
+            with col1:
+                validate_button = st.button("Validate Key", type="primary")
+            
+            if validate_button or (api_key and not st.session_state.api_key_validated):
+                try:
+                    with st.spinner("Validating API key..."):
+                        test_processor = VideoProcessor(api_key)
+                        st.session_state.video_processor = test_processor
+                        st.session_state.api_key_validated = True
+                    st.success("✅ API key validated successfully!")
+                    st.balloons()
+                    time.sleep(1)
+                    st.rerun()
+                except Exception as e:
+                    st.error(f"❌ Invalid API key: {str(e)}")
+                    st.session_state.api_key_validated = False
+                    st.session_state.video_processor = None
+        else:
+            st.info("ℹ️ Please enter your Gemini API key above to proceed")
+            with st.expander("📖 How to obtain your API key"):
                 st.markdown("""
                 1. Navigate to [Google AI Studio](https://makersuite.google.com/app/apikey)
                 2. Sign in with your Google account
@@ -97,126 +134,173 @@ def main():
                 
                 **Important:** Keep your API key secure and do not share it publicly.
                 """)
-        else:
-            # Validate the API key when entered
-            if not st.session_state.api_key_validated or (st.session_state.video_processor is None):
-                try:
-                    with st.spinner("Validating API key..."):
-                        st.session_state.video_processor = VideoProcessor(api_key)
-                        st.session_state.api_key_validated = True
-                    st.success("API key validated successfully - You can proceed to Step 2")
-                except Exception as e:
-                    st.error(f"Invalid API key. Please check your key and try again: {str(e)}")
-                    st.session_state.api_key_validated = False
-                    st.session_state.video_processor = None
-                    api_key = None
 
-    # Stop here if no valid API key
-    if not api_key or not st.session_state.api_key_validated:
-        st.warning("A valid API key is required to proceed to Steps 2 and 3")
-        st.stop()
+    # Check if we can proceed to next steps
+    if not st.session_state.api_key_validated:
+        st.warning("⚠️ Please enter a valid API key to proceed to Steps 2 and 3")
+        return  # Changed from st.stop() to return
 
     st.markdown("---")
 
     # Step 2: Upload Video
-    st.subheader("Step 2: Video Upload")
-    uploaded_file = st.file_uploader("Select a video file", type=['mp4', 'mov', 'avi', 'mkv', 'webm'])
+    st.subheader("📹 Step 2: Video Upload")
+    
+    # Show current status
+    if st.session_state.video_name:
+        st.success(f"✅ Current video: {st.session_state.video_name}")
+    
+    uploaded_file = st.file_uploader(
+        "Select a video file", 
+        type=['mp4', 'mov', 'avi', 'mkv', 'webm'],
+        help="Maximum file size: 200MB"
+    )
 
     if uploaded_file:
         # Validate video file
         mime_type = mimetypes.guess_type(uploaded_file.name)[0]
+        
+        if st.session_state.debug_mode:
+            st.info(f"Debug: MIME type detected: {mime_type}")
+        
         if mime_type and mime_type.startswith("video"):
-            file_size = len(uploaded_file.getvalue()) / (1024**2)
+            file_size_mb = len(uploaded_file.getvalue()) / (1024**2)
             
             # Display file info
-            col1, col2 = st.columns(2)
+            col1, col2, col3 = st.columns(3)
             with col1:
-                st.info(f"File: {uploaded_file.name}")
+                st.metric("File", uploaded_file.name)
             with col2:
-                st.info(f"Size: {file_size:.2f} MB")
+                st.metric("Size", f"{file_size_mb:.2f} MB")
+            with col3:
+                st.metric("Type", mime_type.split('/')[-1].upper())
             
-            # Check file size limit (200MB for Gemini)
-            if file_size > 200:
-                st.error("File size exceeds limit. Maximum file size is 200MB.")
-                st.stop()
-
-            # Process new video if different from current
+            # Check file size limit
+            if file_size_mb > 200:
+                st.error("❌ File size exceeds 200MB limit")
+                return
+            
+            # Process button
+            process_video = False
             if st.session_state.video_name != uploaded_file.name:
+                if st.button("🚀 Process Video", type="primary", use_container_width=True):
+                    process_video = True
+            else:
+                st.info("ℹ️ This video has already been processed")
+
+            # Process new video
+            if process_video:
                 tmp_path = None
+                progress_container = st.container()
+                
                 try:
-                    # Create temporary file
-                    with tempfile.NamedTemporaryFile(delete=False, suffix=Path(uploaded_file.name).suffix) as tmp:
-                        tmp.write(uploaded_file.getvalue())
-                        tmp_path = tmp.name
-
-                    # Upload and process with progress indication
-                    with st.spinner("Uploading and processing video..."):
+                    with progress_container:
+                        # Create temporary file
+                        with tempfile.NamedTemporaryFile(delete=False, suffix=Path(uploaded_file.name).suffix) as tmp:
+                            tmp.write(uploaded_file.getvalue())
+                            tmp_path = tmp.name
+                        
+                        if st.session_state.debug_mode:
+                            st.info(f"Debug: Temp file created at {tmp_path}")
+                        
+                        # Upload and process with detailed progress
                         progress_bar = st.progress(0)
-                        progress_bar.progress(25, text="Uploading video...")
+                        status_text = st.empty()
                         
+                        # Step 1: Upload
+                        status_text.text("📤 Uploading video to Gemini...")
+                        progress_bar.progress(25)
                         video_file = st.session_state.video_processor.upload_video(tmp_path, uploaded_file.name)
-                        progress_bar.progress(50, text="Processing video...")
                         
+                        if st.session_state.debug_mode:
+                            st.info(f"Debug: Video uploaded, state: {video_file.state.name}")
+                        
+                        # Step 2: Process
+                        status_text.text("⏳ Processing video (this may take a minute)...")
+                        progress_bar.progress(50)
                         processed_file = st.session_state.video_processor.wait_for_processing(video_file)
-                        progress_bar.progress(100, text="Processing complete")
+                        
+                        if st.session_state.debug_mode:
+                            st.info(f"Debug: Video processed, final state: {processed_file.state.name}")
+                        
+                        # Step 3: Complete
+                        progress_bar.progress(100)
+                        status_text.text("✅ Video ready for analysis!")
                         
                         # Update session state
                         st.session_state.video_file = processed_file
                         st.session_state.video_name = uploaded_file.name
                         st.session_state.messages = []  # Clear previous conversation
                         
-                        st.success("Video processed successfully")
-                        time.sleep(1)  # Show success message briefly
-                        progress_bar.empty()  # Clear progress bar
-
+                        st.success("🎉 Video processed successfully! You can now ask questions below.")
+                        time.sleep(2)
+                        st.rerun()  # Refresh to show chat interface
+                        
                 except Exception as e:
-                    st.error(f"Error processing video: {str(e)}")
+                    st.error(f"❌ Error processing video: {str(e)}")
+                    if st.session_state.debug_mode:
+                        st.exception(e)
                     st.session_state.video_file = None
                     st.session_state.video_name = None
                     
                 finally:
                     # Clean up temporary file
                     if tmp_path and os.path.exists(tmp_path):
-                        os.unlink(tmp_path)
+                        try:
+                            os.unlink(tmp_path)
+                            if st.session_state.debug_mode:
+                                st.info("Debug: Temp file cleaned up")
+                        except:
+                            pass
 
             # Display video player
-            st.video(uploaded_file.getvalue())
+            if uploaded_file:
+                st.video(uploaded_file.getvalue())
         else:
-            st.error("Please upload a valid video file")
+            st.error("❌ Please upload a valid video file")
 
     # Control buttons
+    st.markdown("---")
     col1, col2, col3 = st.columns(3)
     with col1:
-        if st.button("Reset Chat", disabled=not st.session_state.messages):
+        if st.button("🔄 Reset Chat", disabled=not st.session_state.messages, use_container_width=True):
             st.session_state.messages = []
+            st.success("Chat history cleared!")
+            time.sleep(1)
             st.rerun()
     
     with col2:
-        if st.button("Reset Video", disabled=not st.session_state.video_file):
+        if st.button("📹 Reset Video", disabled=not st.session_state.video_file, use_container_width=True):
             st.session_state.video_file = None
             st.session_state.video_name = None
             st.session_state.messages = []
+            st.success("Video reset!")
+            time.sleep(1)
             st.rerun()
     
     with col3:
-        if st.button("Clear All & Start Over"):
+        if st.button("🗑️ Clear All", type="secondary", use_container_width=True):
             for key in list(st.session_state.keys()):
                 del st.session_state[key]
+            st.success("All data cleared!")
+            time.sleep(1)
             st.rerun()
 
     st.markdown("---")
 
     # Step 3: Chat about Video
-    st.subheader("Step 3: Video Analysis Chat")
+    st.subheader("💬 Step 3: Video Analysis Chat")
 
     if st.session_state.video_file:
+        st.success(f"✅ Ready to analyze: {st.session_state.video_name}")
+        
         # Display chat history
         for msg in st.session_state.messages:
             with st.chat_message(msg["role"]):
                 st.markdown(msg["content"])
 
         # Chat input
-        user_question = st.chat_input("Ask a question about the video...")
+        user_question = st.chat_input("Ask a question about the video...", key="chat_input")
+        
         if user_question:
             # Add user message
             st.session_state.messages.append({"role": "user", "content": user_question})
@@ -225,20 +309,38 @@ def main():
 
             # Generate and display assistant response
             with st.chat_message("assistant"):
-                placeholder = st.empty()
-                with st.spinner("Processing..."):
+                with st.spinner("🤔 Analyzing video..."):
                     try:
                         response = st.session_state.video_processor.chat_with_video(
                             st.session_state.video_file, 
                             user_question
                         )
+                        
+                        if st.session_state.debug_mode:
+                            st.info(f"Debug: Response length: {len(response)} characters")
+                            
                     except Exception as e:
-                        response = f"Error: {str(e)}"
+                        response = f"❌ Error: {str(e)}"
+                        if st.session_state.debug_mode:
+                            st.exception(e)
 
-                placeholder.markdown(response)
+                st.markdown(response)
                 st.session_state.messages.append({"role": "assistant", "content": response})
+        
+        # Sample questions
+        with st.expander("💡 Sample Questions"):
+            st.markdown("""
+            - What is happening in this video?
+            - Can you describe the main events?
+            - What objects or people can you see?
+            - What is the mood or atmosphere?
+            - Can you provide a summary of the video?
+            - What are the key moments in the video?
+            """)
     else:
-        st.info("Please upload a video in Step 2 to begin analysis.")
+        st.info("📤 Please upload and process a video in Step 2 to begin analysis.")
+        if st.session_state.debug_mode:
+            st.warning("Debug: No video file in session state")
 
 if __name__ == "__main__":
-    main() 
+    main()