Update app.py

app.py

@@ -11,8 +11,6 @@ from datetime import datetime
 import edge_tts
 import asyncio
 import base64
-from openai import OpenAI
-import anthropic
 import streamlit.components.v1 as components
 
 # Page configuration
@@ -23,17 +21,11 @@ st.set_page_config(
 )
 
 # Initialize session state
-if 'messages' not in st.session_state:
-    st.session_state['messages'] = []
 if 'search_history' not in st.session_state:
     st.session_state['search_history'] = []
 if 'last_voice_input' not in st.session_state:
     st.session_state['last_voice_input'] = ""
 
-# Load environment variables
-openai_client = OpenAI()
-claude_client = anthropic.Anthropic()
-
 # Initialize the speech component
 speech_component = components.declare_component("speech_recognition", path="mycomponent")
 
@@ -42,12 +34,53 @@ class VideoSearch:
         self.text_model = SentenceTransformer('all-MiniLM-L6-v2')
         self.load_dataset()
         
+    def fetch_dataset_rows(self):
+        """Fetch dataset from Hugging Face API"""
+        import requests
+        
+        # Fetch first rows from the dataset
+        url = "https://datasets-server.huggingface.co/first-rows?dataset=omegalabsinc%2Fomega-multimodal&config=default&split=train"
+        response = requests.get(url)
+        
+        if response.status_code == 200:
+            data = response.json()
+            # Extract the rows from the response
+            rows = data.get('rows', [])
+            return pd.DataFrame(rows)
+        else:
+            st.error(f"Error fetching dataset: {response.status_code}")
+            return None
+            
+    def get_dataset_splits(self):
+        """Get available dataset splits"""
+        import requests
+        
+        url = "https://datasets-server.huggingface.co/splits?dataset=omegalabsinc%2Fomega-multimodal"
+        response = requests.get(url)
+        
+        if response.status_code == 200:
+            splits_data = response.json()
+            return splits_data
+        else:
+            st.error(f"Error fetching splits: {response.status_code}")
+            return None
+        
     def load_dataset(self):
         """Load the Omega Multimodal dataset"""
         try:
-            # Load dataset from Hugging Face
-            self.dataset = pd.read_csv("paste.txt")
-            self.prepare_features()
+            # Fetch dataset from Hugging Face API
+            self.dataset = self.fetch_dataset_rows()
+            
+            if self.dataset is not None:
+                # Get dataset splits info
+                splits_info = self.get_dataset_splits()
+                if splits_info:
+                    st.sidebar.write("Available splits:", splits_info)
+                
+                self.prepare_features()
+            else:
+                self.create_dummy_data()
+                
         except Exception as e:
             st.error(f"Error loading dataset: {e}")
             self.create_dummy_data()
@@ -55,16 +88,23 @@ class VideoSearch:
     def prepare_features(self):
         """Prepare and cache embeddings"""
         # Convert string representations of embeddings back to numpy arrays
-        self.video_embeds = np.array([json.loads(e) if isinstance(e, str) else e 
-                                    for e in self.dataset.video_embed])
-        self.text_embeds = np.array([json.loads(e) if isinstance(e, str) else e 
-                                   for e in self.dataset.description_embed])
+        try:
+            self.video_embeds = np.array([json.loads(e) if isinstance(e, str) else e 
+                                        for e in self.dataset.video_embed])
+            self.text_embeds = np.array([json.loads(e) if isinstance(e, str) else e 
+                                       for e in self.dataset.description_embed])
+        except Exception as e:
+            st.error(f"Error preparing features: {e}")
+            # Create random embeddings as fallback
+            num_rows = len(self.dataset)
+            self.video_embeds = np.random.randn(num_rows, 384)
+            self.text_embeds = np.random.randn(num_rows, 384)
     
     def create_dummy_data(self):
         """Create dummy data for testing"""
         self.dataset = pd.DataFrame({
             'video_id': [f'video_{i}' for i in range(10)],
-            'youtube_id': ['dQw4w9WgXcQ'] * 10,  # Example YouTube ID
+            'youtube_id': ['dQw4w9WgXcQ'] * 10,
             'description': ['Sample video description'] * 10,
             'views': [1000] * 10,
             'start_time': [0] * 10,
@@ -74,6 +114,7 @@ class VideoSearch:
         self.video_embeds = np.random.randn(10, 384)  # Match model dimensions
         self.text_embeds = np.random.randn(10, 384)
 
+
     def search(self, query, top_k=5):
         """Search videos using query"""
         query_embedding = self.text_model.encode([query])[0]
@@ -112,31 +153,6 @@ async def generate_speech(text, voice="en-US-AriaNeural"):
     await communicate.save(audio_file)
     return audio_file
 
-def process_with_gpt4(prompt):
-    """Process text with GPT-4"""
-    try:
-        response = openai_client.chat.completions.create(
-            model="gpt-4",
-            messages=[{"role": "user", "content": prompt}]
-        )
-        return response.choices[0].message.content
-    except Exception as e:
-        st.error(f"Error with GPT-4: {e}")
-        return None
-
-def process_with_claude(prompt):
-    """Process text with Claude"""
-    try:
-        response = claude_client.messages.create(
-            model="claude-3-sonnet-20240229",
-            max_tokens=1000,
-            messages=[{"role": "user", "content": prompt}]
-        )
-        return response.content[0].text
-    except Exception as e:
-        st.error(f"Error with Claude: {e}")
-        return None
-
 def main():
     st.title("🎥 Video Search with Speech Recognition")
     
@@ -202,34 +218,18 @@ def main():
             st.markdown("**Transcribed Text:**")
             st.write(voice_input)
             
-            cols = st.columns(3)
-            with cols[0]:
-                if st.button("🔍 Search Videos"):
-                    results = search.search(voice_input, num_results)
-                    st.session_state['search_history'].append({
-                        'query': voice_input,
-                        'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                        'results': results
-                    })
-                    for i, result in enumerate(results, 1):
-                        with st.expander(f"Result {i}: {result['description'][:100]}...", expanded=i==1):
-                            st.write(result['description'])
-                            if result['youtube_id']:
-                                st.video(f"https://youtube.com/watch?v={result['youtube_id']}&t={result['start_time']}")
-                            
-            with cols[1]:
-                if st.button("🤖 Process with GPT-4"):
-                    gpt_response = process_with_gpt4(voice_input)
-                    if gpt_response:
-                        st.markdown("**GPT-4 Response:**")
-                        st.write(gpt_response)
-                        
-            with cols[2]:
-                if st.button("🧠 Process with Claude"):
-                    claude_response = process_with_claude(voice_input)
-                    if claude_response:
-                        st.markdown("**Claude Response:**")
-                        st.write(claude_response)
+            if st.button("🔍 Search Videos"):
+                results = search.search(voice_input, num_results)
+                st.session_state['search_history'].append({
+                    'query': voice_input,
+                    'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                    'results': results
+                })
+                for i, result in enumerate(results, 1):
+                    with st.expander(f"Result {i}: {result['description'][:100]}...", expanded=i==1):
+                        st.write(result['description'])
+                        if result['youtube_id']:
+                            st.video(f"https://youtube.com/watch?v={result['youtube_id']}&t={result['start_time']}")
 
     with tab3:
         st.subheader("Search History")