Update app.py

app.py

@@ -10,14 +10,10 @@ def get_api_key():
     # First try to get from Hugging Face Spaces secrets
     GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY", "")
     
-    # Fallback to Streamlit secrets if available
-    if not GOOGLE_API_KEY and hasattr(st, "secrets"):
-        GOOGLE_API_KEY = st.secrets.get("GOOGLE_API_KEY", "")
-    
-    # Last resort: manual input (remove in production)
+    # Fallback to manual input for testing
     if not GOOGLE_API_KEY:
         GOOGLE_API_KEY = st.sidebar.text_input(
-            "Enter Gemini API key (for testing only)", 
+            "Enter Gemini API key", 
             type="password",
             help="In production, this should be set as a Hugging Face Space secret"
         )
@@ -44,11 +40,19 @@ class VideoProcessor:
             raise e
 
     def wait_for_processing(self, video_file):
-        while video_file.state.name == "PROCESSING":
+        max_attempts = 30  # Maximum 60 seconds wait
+        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")
+        elif video_file.state.name == "PROCESSING":
+            raise RuntimeError("Video processing timeout")
+            
         return video_file
 
     def generate_summary(self, video_file):
@@ -63,12 +67,11 @@ class VideoProcessor:
 
         Please format the summary in a clear, structured way."""
         
-        response = self.model.generate_content([video_file, prompt])
-        return response.text
-    
-    def chat_with_video(self, video_file, prompt):
-        response = self.model.generate_content([video_file, prompt])
-        return response.text
+        try:
+            response = self.model.generate_content([video_file, prompt])
+            return response.text
+        except Exception as e:
+            return f"Error generating summary: {str(e)}"
 
 # Initialize session state
 if "video_processor" not in st.session_state:
@@ -77,10 +80,10 @@ if "video_file" not in st.session_state:
     st.session_state.video_file = None
 if "summary" not in st.session_state:
     st.session_state.summary = None
-if "messages" not in st.session_state:
-    st.session_state.messages = []
 if "video_name" not in st.session_state:
     st.session_state.video_name = None
+if "processing" not in st.session_state:
+    st.session_state.processing = False
 
 # Main app function
 def main():
@@ -90,41 +93,82 @@ def main():
         layout="wide"
     )
     
-    st.title("🎥 Video Upload & AI Analysis")
-    st.markdown("Upload a video or record one to get AI-powered insights")
+    # Header
+    st.title("🎥 Video Recording & AI Analysis")
+    st.markdown("Upload or record a video to get instant AI-powered insights")
     st.markdown("---")
 
-    # Get API key
-    api_key = get_api_key()
+    # Sidebar for API key and info
+    with st.sidebar:
+        st.markdown("### 🔑 Configuration")
+        
+        # Get API key
+        api_key = get_api_key()
+        
+        if api_key:
+            st.success("✅ API Key configured")
+        else:
+            st.error("❌ API Key missing")
+            
+        st.markdown("---")
+        st.markdown("### 📖 How to Use")
+        st.markdown("""
+        1. Add API key (in HF secrets)
+        2. Upload or record a video
+        3. Click 'Analyze Video'
+        4. View AI-generated summary
+        """)
+        
+        st.markdown("### 🎯 Tips")
+        st.markdown("""
+        - Keep videos under 50MB
+        - Clear content works best
+        - Good lighting helps
+        """)
+        
+        if st.button("🔄 Reset Everything"):
+            for key in list(st.session_state.keys()):
+                del st.session_state[key]
+            st.rerun()
     
+    # Check API key
     if not api_key:
-        st.error("⚠️ Please set your GOOGLE_API_KEY in Hugging Face Spaces secrets or environment variables")
+        st.error("⚠️ Please enter your GOOGLE_API_KEY in the sidebar")
         st.info("""
-        To set up the API key in Hugging Face Spaces:
-        1. Go to your Space Settings
-        2. Navigate to 'Repository secrets'
-        3. Add a new secret named 'GOOGLE_API_KEY'
-        4. Paste your Gemini API key as the value
+        **For Hugging Face Spaces deployment:**
+        1. Go to Settings → Repository secrets
+        2. Add secret named 'GOOGLE_API_KEY'
+        3. Paste your Gemini API key value
+        
+        **Get API key from:** https://makersuite.google.com/app/apikey
         """)
         st.stop()
     
     # Initialize video processor
     if st.session_state.video_processor is None:
-        st.session_state.video_processor = VideoProcessor(api_key)
+        try:
+            st.session_state.video_processor = VideoProcessor(api_key)
+        except Exception as e:
+            st.error(f"Error initializing processor: {str(e)}")
+            st.stop()
     
-    # Create tabs for different input methods
-    tab1, tab2, tab3 = st.tabs(["📤 Upload Video", "🎬 Record Video (Mobile)", "💬 Chat with Video"])
+    # Create tabs
+    tab1, tab2 = st.tabs(["📤 Upload Video", "📹 Record Video"])
     
     with tab1:
         st.subheader("Upload a video file")
         
         uploaded_file = st.file_uploader(
             "Choose a video file", 
-            type=['mp4', 'mov', 'avi', 'mkv', 'webm', 'm4v'],
-            help="Maximum recommended size: 100MB"
+            type=['mp4', 'mov', 'avi', 'mkv', 'webm'],
+            help="Maximum recommended size: 50MB"
         )
         
         if uploaded_file is not None:
+            # Display video info
+            file_size = len(uploaded_file.getvalue()) / (1024 * 1024)
+            st.info(f"📁 File: {uploaded_file.name} | Size: {file_size:.2f} MB")
+            
             # Display video
             st.video(uploaded_file)
             
@@ -133,70 +177,71 @@ def main():
                 st.session_state.video_name = uploaded_file.name
                 st.session_state.video_file = None
                 st.session_state.summary = None
-                st.session_state.messages = []
-            
-            col1, col2 = st.columns(2)
             
-            with col1:
-                if st.button("🔍 Analyze Video", type="primary", use_container_width=True):
-                    with st.spinner("Processing video... This may take a minute."):
-                        try:
-                            # Upload and process video
+            # Analyze button
+            if st.button("🔍 Analyze Video", type="primary", disabled=st.session_state.processing):
+                st.session_state.processing = True
+                
+                try:
+                    # Create progress container
+                    progress_container = st.container()
+                    
+                    with progress_container:
+                        with st.spinner("📤 Uploading video..."):
                             video_bytes = uploaded_file.read()
                             video_file, tmp_path = st.session_state.video_processor.upload_video(
                                 video_bytes, 
                                 uploaded_file.name
                             )
-                            
-                            # Wait for processing
+                        
+                        with st.spinner("⏳ Processing video... (this may take 30-60 seconds)"):
                             processed_file = st.session_state.video_processor.wait_for_processing(
                                 video_file
                             )
                             st.session_state.video_file = processed_file
-                            
-                            # Generate summary
+                        
+                        with st.spinner("🤖 Generating AI summary..."):
                             st.session_state.summary = st.session_state.video_processor.generate_summary(
                                 processed_file
                             )
-                            
-                            # Clean up
+                        
+                        # Clean up
+                        if os.path.exists(tmp_path):
                             os.unlink(tmp_path)
-                            
-                            st.success("✅ Analysis complete!")
-                            
-                        except Exception as e:
-                            st.error(f"Error processing video: {str(e)}")
-            
-            with col2:
-                if st.button("🔄 Reset", use_container_width=True):
-                    st.session_state.video_file = None
-                    st.session_state.summary = None
-                    st.session_state.messages = []
-                    st.session_state.video_name = None
+                        
+                        st.success("✅ Analysis complete!")
+                        
+                except Exception as e:
+                    st.error(f"❌ Error: {str(e)}")
+                finally:
+                    st.session_state.processing = False
                     st.rerun()
     
     with tab2:
-        st.subheader("Record a video (works best on mobile)")
+        st.subheader("Record a video")
         
         st.info("""
-        📱 **For Mobile Users:**
-        Use the camera input below to record a video directly from your device.
+        📱 **Mobile Users:** Use the camera button below to record
         
-        💻 **For Desktop Users:**
-        You may need to use the Upload tab instead, or record a video separately and upload it.
+        💻 **Desktop Users:** This feature works best on mobile devices
         """)
         
-        # Use Streamlit's camera input for simple video recording
-        video_file = st.camera_input("Record a video")
+        # Camera input for recording
+        video_file = st.camera_input("Click to record video")
         
         if video_file is not None:
             st.video(video_file)
             
-            if st.button("🔍 Analyze Recorded Video", type="primary"):
-                with st.spinner("Processing your recording..."):
-                    try:
-                        # Process the recorded video
+            if st.button("🔍 Analyze Recording", type="primary", disabled=st.session_state.processing):
+                st.session_state.processing = True
+                
+                try:
+                    with st.spinner("Processing your recording..."):
+                        # Reset video file pointer
+                        video_file.seek(0)
                         video_bytes = video_file.read()
+                        
+                        # Upload and process
                         uploaded_video, tmp_path = st.session_state.video_processor.upload_video(
                             video_bytes, 
                             f"recording_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
@@ -214,99 +259,48 @@ def main():
                         )
                         
                         # Clean up
-                        os.unlink(tmp_path)
+                        if os.path.exists(tmp_path):
+                            os.unlink(tmp_path)
                         
                         st.success("✅ Recording analyzed!")
                         
-                    except Exception as e:
-                        st.error(f"Error processing recording: {str(e)}")
-    
-    with tab3:
-        st.subheader("Chat about your video")
-        
-        if st.session_state.video_file:
-            # Display chat messages
-            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...")
-            
-            if user_question:
-                # Add user message
-                st.session_state.messages.append({"role": "user", "content": user_question})
-                with st.chat_message("user"):
-                    st.markdown(user_question)
-                
-                # Generate response
-                with st.chat_message("assistant"):
-                    with st.spinner("Thinking..."):
-                        try:
-                            response = st.session_state.video_processor.chat_with_video(
-                                st.session_state.video_file, 
-                                user_question
-                            )
-                            st.markdown(response)
-                            st.session_state.messages.append({"role": "assistant", "content": response})
-                        except Exception as e:
-                            st.error(f"Error generating response: {str(e)}")
-        else:
-            st.info("Please upload or record a video first, then analyze it to start chatting.")
+                except Exception as e:
+                    st.error(f"❌ Error: {str(e)}")
+                finally:
+                    st.session_state.processing = False
+                    st.rerun()
     
-    # Display summary if available
+    # Display summary
     if st.session_state.summary:
         st.markdown("---")
-        st.subheader("📝 Video Summary")
+        st.subheader("📝 AI-Generated Video Summary")
         
-        # Create columns for better layout
-        col1, col2 = st.columns([3, 1])
+        # Create columns for layout
+        col1, col2 = st.columns([4, 1])
         
         with col1:
-            st.markdown(st.session_state.summary)
+            # Display summary in a nice container
+            with st.container():
+                st.markdown(st.session_state.summary)
         
         with col2:
+            # Download button
             st.download_button(
-                label="📥 Download Summary",
+                label="📥 Download",
                 data=st.session_state.summary,
-                file_name=f"video_summary_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt",
+                file_name=f"summary_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt",
                 mime="text/plain",
                 use_container_width=True
             )
     
-    # Sidebar with instructions and info
-    with st.sidebar:
-        st.markdown("### 📖 How to Use")
-        st.markdown("""
-        1. **Set API Key**: Add your Gemini API key to HF Spaces secrets
-        2. **Upload/Record**: Choose a video file or record one
-        3. **Analyze**: Click the analyze button
-        4. **Review**: Read the AI-generated summary
-        5. **Chat**: Ask questions about the video content
-        """)
-        
-        st.markdown("### 🎯 Best Practices")
-        st.markdown("""
-        - Keep videos under 100MB for faster processing
-        - Ensure good lighting for recordings
-        - Speak clearly if recording audio
-        - Videos with clear content work best
-        """)
-        
-        st.markdown("### ⚙️ System Status")
-        if api_key:
-            st.success("✅ API Key configured")
-        else:
-            st.error("❌ API Key missing")
-        
-        if st.session_state.video_file:
-            st.success("✅ Video loaded")
-        else:
-            st.info("⏳ No video loaded")
-        
-        if st.button("🔄 Reset Everything"):
-            st.session_state.clear()
-            st.rerun()
+    # Footer
+    st.markdown("---")
+    st.markdown(
+        "<div style='text-align: center; color: gray; font-size: 0.8em;'>"
+        "Powered by Google Gemini 2.0 Flash | Made with Streamlit"
+        "</div>", 
+        unsafe_allow_html=True
+    )
 
 if __name__ == "__main__":
     main()