Update app.py

app.py

@@ -3,12 +3,7 @@ import google.generativeai as genai
 import os
 import tempfile
 import time
-import cv2
-import numpy as np
-from streamlit_webrtc import webrtc_streamer, VideoProcessorBase, WebRtcMode
-import av
-import threading
-from pathlib import Path
+from datetime import datetime
 
 # --- Get API key from Hugging Face secret or environment ---
 def get_api_key():
@@ -29,44 +24,24 @@ def get_api_key():
     
     return GOOGLE_API_KEY
 
-# Video Recorder class to handle WebRTC recording
-class VideoRecorder(VideoProcessorBase):
-    def __init__(self):
-        self.frames = []
-        self.recording = False
-        self.lock = threading.Lock()
-
-    def recv(self, frame):
-        img = frame.to_ndarray(format="bgr24")
-        
-        with self.lock:
-            if self.recording:
-                self.frames.append(img.copy())
-        
-        return av.VideoFrame.from_ndarray(img, format="bgr24")
-    
-    def start_recording(self):
-        with self.lock:
-            self.recording = True
-            self.frames = []
-    
-    def stop_recording(self):
-        with self.lock:
-            self.recording = False
-            return self.frames.copy()
-    
-    def is_recording(self):
-        with self.lock:
-            return self.recording
-
 # VideoProcessor class for Gemini API
 class VideoProcessor:
     def __init__(self, api_key):
         genai.configure(api_key=api_key)
         self.model = genai.GenerativeModel("gemini-2.0-flash-exp")
 
-    def upload_video(self, video_path, display_name="recorded_video"):
-        return genai.upload_file(path=video_path, display_name=display_name)
+    def upload_video(self, video_bytes, display_name="uploaded_video"):
+        # Save bytes to temporary file
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as tmp:
+            tmp.write(video_bytes)
+            tmp_path = tmp.name
+        
+        try:
+            video_file = genai.upload_file(path=tmp_path, display_name=display_name)
+            return video_file, tmp_path
+        except Exception as e:
+            os.unlink(tmp_path)
+            raise e
 
     def wait_for_processing(self, video_file):
         while video_file.state.name == "PROCESSING":
@@ -90,21 +65,10 @@ class VideoProcessor:
         
         response = self.model.generate_content([video_file, prompt])
         return response.text
-
-def save_frames_as_video(frames, output_path, fps=30):
-    """Save recorded frames as a video file"""
-    if not frames:
-        return False
-    
-    height, width, _ = frames[0].shape
-    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
     
-    for frame in frames:
-        out.write(frame)
-    
-    out.release()
-    return True
+    def chat_with_video(self, video_file, prompt):
+        response = self.model.generate_content([video_file, prompt])
+        return response.text
 
 # Initialize session state
 if "video_processor" not in st.session_state:
@@ -113,21 +77,21 @@ 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 "recording_complete" not in st.session_state:
-    st.session_state.recording_complete = False
-if "recorded_frames" not in st.session_state:
-    st.session_state.recorded_frames = 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
 
 # Main app function
 def main():
     st.set_page_config(
-        page_title="Video Recording & Analysis", 
+        page_title="Video Analysis with Gemini", 
         page_icon="🎥", 
         layout="wide"
     )
     
-    st.title("🎥 Video Recording & Automatic Analysis")
-    st.markdown("Record a video directly from your camera and get an AI-generated summary")
+    st.title("🎥 Video Upload & AI Analysis")
+    st.markdown("Upload a video or record one to get AI-powered insights")
     st.markdown("---")
 
     # Get API key
@@ -135,137 +99,214 @@ def main():
     
     if not api_key:
         st.error("⚠️ Please set your GOOGLE_API_KEY in Hugging Face Spaces secrets or environment variables")
+        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
+        """)
         st.stop()
     
     # Initialize video processor
     if st.session_state.video_processor is None:
         st.session_state.video_processor = VideoProcessor(api_key)
     
-    # Create two columns for layout
-    col1, col2 = st.columns([1, 1])
+    # Create tabs for different input methods
+    tab1, tab2, tab3 = st.tabs(["📤 Upload Video", "🎬 Record Video (Mobile)", "💬 Chat with Video"])
     
-    with col1:
-        st.subheader("📹 Video Recording")
+    with tab1:
+        st.subheader("Upload a video file")
         
-        # WebRTC streamer for video recording
-        ctx = webrtc_streamer(
-            key="video-recorder",
-            mode=WebRtcMode.SENDRECV,
-            video_processor_factory=VideoRecorder,
-            media_stream_constraints={"video": True, "audio": False},
-            async_processing=True,
+        uploaded_file = st.file_uploader(
+            "Choose a video file", 
+            type=['mp4', 'mov', 'avi', 'mkv', 'webm', 'm4v'],
+            help="Maximum recommended size: 100MB"
         )
         
-        # Recording controls
-        col_start, col_stop = st.columns(2)
-        
-        with col_start:
-            if st.button("🔴 Start Recording", use_container_width=True):
-                if ctx.video_processor:
-                    ctx.video_processor.start_recording()
-                    st.session_state.recording_complete = False
+        if uploaded_file is not None:
+            # Display video
+            st.video(uploaded_file)
+            
+            # Check if this is a new video
+            if st.session_state.video_name != uploaded_file.name:
+                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
+                            video_bytes = uploaded_file.read()
+                            video_file, tmp_path = st.session_state.video_processor.upload_video(
+                                video_bytes, 
+                                uploaded_file.name
+                            )
+                            
+                            # Wait for processing
+                            processed_file = st.session_state.video_processor.wait_for_processing(
+                                video_file
+                            )
+                            st.session_state.video_file = processed_file
+                            
+                            # Generate summary
+                            st.session_state.summary = st.session_state.video_processor.generate_summary(
+                                processed_file
+                            )
+                            
+                            # Clean up
+                            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.success("Recording started...")
+                    st.session_state.messages = []
+                    st.session_state.video_name = None
+                    st.rerun()
+    
+    with tab2:
+        st.subheader("Record a video (works best on mobile)")
+        
+        st.info("""
+        📱 **For Mobile Users:**
+        Use the camera input below to record a video directly from your device.
         
-        with col_stop:
-            if st.button("⏹️ Stop Recording", use_container_width=True):
-                if ctx.video_processor and ctx.video_processor.is_recording():
-                    frames = ctx.video_processor.stop_recording()
-                    
-                    if frames:
-                        st.session_state.recorded_frames = frames
-                        st.session_state.recording_complete = True
-                        st.success(f"Recording stopped! Captured {len(frames)} frames")
-                    else:
-                        st.warning("No frames were recorded")
+        💻 **For Desktop Users:**
+        You may need to use the Upload tab instead, or record a video separately and upload it.
+        """)
         
-        # Display recording status
-        if ctx.video_processor and ctx.video_processor.is_recording():
-            st.info("🔴 Recording in progress...")
+        # Use Streamlit's camera input for simple video recording
+        video_file = st.camera_input("Record a video")
         
-        # Process the recorded video
-        if st.session_state.recording_complete and st.session_state.recorded_frames:
-            with st.spinner("Processing video..."):
-                # Save frames as video
-                with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as tmp:
-                    tmp_path = tmp.name
-                
-                if save_frames_as_video(st.session_state.recorded_frames, tmp_path):
+        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:
-                        # Upload to Gemini
-                        video_file = st.session_state.video_processor.upload_video(
-                            tmp_path, 
-                            "recorded_video"
+                        # Process the recorded video
+                        video_bytes = video_file.read()
+                        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"
                         )
                         
                         # Wait for processing
                         processed_file = st.session_state.video_processor.wait_for_processing(
-                            video_file
+                            uploaded_video
                         )
+                        st.session_state.video_file = processed_file
                         
                         # Generate summary
                         st.session_state.summary = st.session_state.video_processor.generate_summary(
                             processed_file
                         )
                         
-                        st.success("✅ Video analyzed successfully!")
+                        # Clean up
+                        os.unlink(tmp_path)
+                        
+                        st.success("✅ Recording analyzed!")
                         
                     except Exception as e:
-                        st.error(f"Error processing video: {str(e)}")
-                    finally:
-                        # Clean up temp file
-                        if os.path.exists(tmp_path):
-                            os.unlink(tmp_path)
-                        st.session_state.recording_complete = False
-                else:
-                    st.error("Failed to save video")
+                        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.")
     
-    with col2:
+    # Display summary if available
+    if st.session_state.summary:
+        st.markdown("---")
         st.subheader("📝 Video Summary")
         
-        if st.session_state.summary:
+        # Create columns for better layout
+        col1, col2 = st.columns([3, 1])
+        
+        with col1:
             st.markdown(st.session_state.summary)
-            
-            # Option to download summary
+        
+        with col2:
             st.download_button(
                 label="📥 Download Summary",
                 data=st.session_state.summary,
-                file_name="video_summary.txt",
-                mime="text/plain"
+                file_name=f"video_summary_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt",
+                mime="text/plain",
+                use_container_width=True
             )
-        else:
-            st.info("Record a video and it will be automatically analyzed. The summary will appear here.")
     
-    # Sidebar with instructions
+    # Sidebar with instructions and info
     with st.sidebar:
         st.markdown("### 📖 How to Use")
         st.markdown("""
-        1. **Allow camera access** when prompted
-        2. Click **Start Recording** to begin
-        3. Perform your action or speak
-        4. Click **Stop Recording** to end
-        5. Wait for automatic analysis
-        6. View your video summary
+        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("### ⚙️ Settings")
-        if st.button("🔄 Reset Application"):
-            st.session_state.clear()
-            st.rerun()
-        
-        st.markdown("### 📌 Notes")
+        st.markdown("### 🎯 Best Practices")
         st.markdown("""
-        - Video is processed using Gemini 2.0
-        - Recording is temporary and not stored
-        - API key should be set in HF Spaces secrets
+        - 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()
 
 if __name__ == "__main__":
-    # Install required packages if not present
-    try:
-        import streamlit_webrtc
-    except ImportError:
-        st.error("Please install streamlit-webrtc: `pip install streamlit-webrtc`")
-        st.stop()
-    
     main()