Update app.py

app.py

@@ -11,38 +11,54 @@ def get_api_key():
     GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY", "")
     if not GOOGLE_API_KEY:
         GOOGLE_API_KEY = st.text_input("Enter your Gemini API key", type="password")
-    return GOOGLE_API_KEY or "AIzaSyA8TTu9s6fJDG9RlMwOyHFxg270xLgpiyE"
+    return GOOGLE_API_KEY or "AIzaSyA8TTu9s6fJDG9RlMwOyHFxg270xLgpiyE"  # Warning: Hardcoded key
 
 # VideoProcessor class
 class VideoProcessor:
     def __init__(self, api_key):
         genai.configure(api_key=api_key)
-        self.model = genai.GenerativeModel("gemini-2.0-flash")
+        self.model = genai.GenerativeModel("gemini-2.0-flash-exp")
 
     def upload_video(self, video_path, display_name="uploaded_video"):
-        return genai.upload_file(path=video_path, display_name=display_name)
+        try:
+            return genai.upload_file(path=video_path, display_name=display_name)
+        except Exception as e:
+            raise RuntimeError(f"Failed to upload video: {str(e)}")
 
     def wait_for_processing(self, video_file):
-        while video_file.state.name == "PROCESSING":
+        max_attempts = 60  # Maximum wait time: 2 minutes
+        attempts = 0
+        while video_file.state.name == "PROCESSING" and attempts < max_attempts:
             time.sleep(2)
             video_file = genai.get_file(video_file.name)
+            attempts += 1
         if video_file.state.name == "FAILED":
             raise RuntimeError("Video processing failed")
+        if attempts >= max_attempts:
+            raise RuntimeError("Video processing timeout")
         return video_file
 
     def chat_with_video(self, video_file, prompt):
-        response = self.model.generate_content([video_file, prompt])
-        return response.text
-
-# Initialize session state
-for key in ["video_processor", "video_file", "video_name", "messages"]:
-    if key not in st.session_state:
-        st.session_state[key] = None if key != "messages" else []
+        try:
+            response = self.model.generate_content([video_file, prompt])
+            return response.text
+        except Exception as e:
+            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
 
 # 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.header("🎬 Video Retrieval-Augmented Generation - Gemini 2.0")
     st.markdown("---")
 
     # Step 1: API Key input
@@ -58,59 +74,92 @@ def main():
     uploaded_file = st.file_uploader("Upload a video", type=['mp4', 'mov', 'avi', 'mkv', 'webm'])
 
     if uploaded_file:
-        if mimetypes.guess_type(uploaded_file.name)[0].startswith("video"):
+        # Validate video file
+        mime_type = mimetypes.guess_type(uploaded_file.name)[0]
+        if mime_type and mime_type.startswith("video"):
             file_size = len(uploaded_file.getvalue()) / (1024**2)
-            st.info(f"Size: {file_size:.2f} MB")
-
+            
+            # Display file info
+            col1, col2 = st.columns(2)
+            with col1:
+                st.info(f"📁 File: {uploaded_file.name}")
+            with col2:
+                st.info(f"💾 Size: {file_size:.2f} MB")
+            
+            # Check file size limit (200MB for Gemini)
+            if file_size > 200:
+                st.error("❌ File too large! Maximum size is 200MB")
+                st.stop()
+
+            # Process new video if different from current
             if st.session_state.video_name != uploaded_file.name:
-                st.session_state.video_processor = VideoProcessor(api_key)
-                with tempfile.NamedTemporaryFile(delete=False, suffix=Path(uploaded_file.name).suffix) as tmp:
-                    tmp.write(uploaded_file.getvalue())
-                    tmp_path = tmp.name
-
-                with st.spinner("Uploading and processing..."):
-                    video_file = st.session_state.video_processor.upload_video(tmp_path, uploaded_file.name)
-                    processed_file = st.session_state.video_processor.wait_for_processing(video_file)
-                    st.session_state.video_file = processed_file
-                    st.session_state.video_name = uploaded_file.name
-                    st.session_state.messages.clear()
-                    st.success("✅ Video processed")
-
-                os.unlink(tmp_path)
-
+                tmp_path = None
+                try:
+                    # Initialize processor if needed
+                    if not st.session_state.video_processor:
+                        st.session_state.video_processor = VideoProcessor(api_key)
+                    
+                    # 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..."):
+                        progress_bar = st.progress(0)
+                        progress_bar.progress(25, text="Uploading video...")
+                        
+                        video_file = st.session_state.video_processor.upload_video(tmp_path, uploaded_file.name)
+                        progress_bar.progress(50, text="Processing video...")
+                        
+                        processed_file = st.session_state.video_processor.wait_for_processing(video_file)
+                        progress_bar.progress(100, text="Complete!")
+                        
+                        # 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
+
+                except Exception as e:
+                    st.error(f"❌ Error processing video: {str(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)
+
+            # Display video player
             st.video(uploaded_file.getvalue())
         else:
-            st.error("Not a valid video file")
-
-    if st.button("Reset Chat"):
-        st.session_state.messages.clear()
-
-    if st.button("Reset All"):
-        st.session_state.clear()
+            st.error("❌ Please upload a valid video file")
+
+    # Control buttons
+    col1, col2 = st.columns(2)
+    with col1:
+        if st.button("🔄 Reset Chat", disabled=not st.session_state.messages):
+            st.session_state.messages = []
+            st.rerun()
+    
+    with col2:
+        if st.button("🗑️ Reset All", disabled=not st.session_state.video_file):
+            for key in list(st.session_state.keys()):
+                del st.session_state[key]
+            st.rerun()
 
     # Step 3: Chat about Video
     st.subheader("Step 3: Chat with your video")
 
     if st.session_state.video_file:
+        # Display chat history
         for msg in st.session_state.messages:
             with st.chat_message(msg["role"]):
                 st.markdown(msg["content"])
 
-        user_question = st.chat_input("Ask a question about the video...")
-        if user_question:
-            st.session_state.messages.append({"role": "user", "content": user_question})
-            with st.chat_message("user"):
-                st.markdown(user_question)
-
-            with st.chat_message("assistant"):
-                placeholder = st.empty()
-                with st.spinner("Generating response..."):
-                    response = st.session_state.video_processor.chat_with_video(st.session_state.video_file, user_question)
-
-                placeholder.markdown(response)
-                st.session_state.messages.append({"role": "assistant", "content": response})
-    else:
-        st.info("Please upload a video in step 2 to start chatting.")
-
-if __name__ == "__main__":
-    main() 
+        # Chat input
+        user_question = st.chat_input("Ask a question ab