Update app.py

app.py

@@ -7,6 +7,7 @@ import torch
 import json
 import os
 import glob
+import random
 from pathlib import Path
 from datetime import datetime, timedelta
 import edge_tts
@@ -20,37 +21,51 @@ from datasets import load_dataset
 import base64
 import re
 
-# 🧠 Initialize session state variables
-SESSION_VARS = {
-    'search_history': [],          # Track search history
-    'last_voice_input': "",        # Last voice input
-    'transcript_history': [],      # Conversation history
-    'should_rerun': False,         # Trigger for UI updates
-    'search_columns': [],          # Available search columns
-    'initial_search_done': False,  # First search flag
-    'tts_voice': "en-US-AriaNeural", # Default voice
-    'arxiv_last_query': "",        # Last ArXiv search
-    'dataset_loaded': False,       # Dataset load status
-    'current_page': 0,            # Current data page
-    'data_cache': None,           # Data cache
-    'dataset_info': None,         # Dataset metadata
-    'nps_submitted': False,       # Track if user submitted NPS
-    'nps_last_shown': None,       # When NPS was last shown
-    'old_val': None,              # Previous voice input value
-    'voice_text': None            # Processed voice text
-}
+# -------------------- Configuration & Constants --------------------
+# User name assignment
+USER_NAMES = [
+    "Alex", "Jordan", "Taylor", "Morgan", "Rowan", "Avery", "Riley", "Quinn",
+    "Casey", "Jesse", "Reese", "Skyler", "Ellis", "Devon", "Aubrey", "Kendall",
+    "Parker", "Dakota", "Sage", "Finley"
+]
 
-# Constants
 ROWS_PER_PAGE = 100
 MIN_SEARCH_SCORE = 0.3
 EXACT_MATCH_BOOST = 2.0
+SAVED_INPUTS_DIR = "saved_inputs"
+os.makedirs(SAVED_INPUTS_DIR, exist_ok=True)
+
+# -------------------- Session State Initialization --------------------
+SESSION_VARS = {
+    'search_history': [],
+    'last_voice_input': "",
+    'transcript_history': [],
+    'should_rerun': False,
+    'search_columns': [],
+    'initial_search_done': False,
+    'tts_voice': "en-US-AriaNeural",
+    'arxiv_last_query': "",
+    'dataset_loaded': False,
+    'current_page': 0,
+    'data_cache': None,
+    'dataset_info': None,
+    'nps_submitted': False,
+    'nps_last_shown': None,
+    'old_val': None,
+    'voice_text': None,
+    'user_name': None,   # New: Track user name
+    'max_items': 100      # Default max items
+}
 
-# Initialize session state
 for var, default in SESSION_VARS.items():
     if var not in st.session_state:
         st.session_state[var] = default
 
-# Voice Component Setup
+# Assign user name if not assigned
+if st.session_state['user_name'] is None:
+    st.session_state['user_name'] = random.choice(USER_NAMES)
+
+# -------------------- Utility Functions --------------------
 def create_voice_component():
     """Create the voice input component"""
     mycomponent = components.declare_component(
@@ -59,9 +74,7 @@ def create_voice_component():
     )
     return mycomponent
 
-# Utility Functions
 def clean_for_speech(text: str) -> str:
-    """Clean text for speech synthesis"""
     text = text.replace("\n", " ")
     text = text.replace("</s>", " ")
     text = text.replace("#", "")
@@ -82,7 +95,6 @@ async def edge_tts_generate_audio(text, voice="en-US-AriaNeural", rate=0, pitch=
     return out_fn
 
 def speak_with_edge_tts(text, voice="en-US-AriaNeural", rate=0, pitch=0):
-    """Wrapper for edge TTS generation"""
     return asyncio.run(edge_tts_generate_audio(text, voice, rate, pitch))
 
 def play_and_download_audio(file_path):
@@ -94,12 +106,10 @@ def play_and_download_audio(file_path):
 
 @st.cache_resource
 def get_model():
-    """Get sentence transformer model"""
     return SentenceTransformer('all-MiniLM-L6-v2')
 
 @st.cache_data
 def load_dataset_page(dataset_id, token, page, rows_per_page):
-    """Load dataset page with caching"""
     try:
         start_idx = page * rows_per_page
         end_idx = start_idx + rows_per_page
@@ -116,7 +126,6 @@ def load_dataset_page(dataset_id, token, page, rows_per_page):
 
 @st.cache_data
 def get_dataset_info(dataset_id, token):
-    """Get dataset info with caching"""
     try:
         dataset = load_dataset(dataset_id, token=token, streaming=True)
         return dataset['train'].info
@@ -125,7 +134,6 @@ def get_dataset_info(dataset_id, token):
         return None
 
 def fetch_dataset_info(dataset_id):
-    """Fetch dataset information"""
     info_url = f"https://huggingface.co/api/datasets/{dataset_id}"
     try:
         response = requests.get(info_url, timeout=30)
@@ -136,18 +144,30 @@ def fetch_dataset_info(dataset_id):
     return None
 
 def generate_filename(text):
-    """Generate unique filename from text"""
     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
     safe_text = re.sub(r'[^\w\s-]', '', text[:50]).strip().lower()
     safe_text = re.sub(r'[-\s]+', '-', safe_text)
-    return f"{timestamp}_{safe_text}"
+    return f"{timestamp}_{safe_text}.md"
+
+def save_input_as_md(text):
+    if not text.strip():
+        return
+    fn = generate_filename(text)
+    full_path = os.path.join(SAVED_INPUTS_DIR, fn)
+    with open(full_path, 'w', encoding='utf-8') as f:
+        f.write(f"# User: {st.session_state['user_name']}\n")
+        f.write(f"**Timestamp:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
+        f.write(text)
+    return full_path
+
+def list_saved_inputs():
+    files = sorted(glob.glob(os.path.join(SAVED_INPUTS_DIR, "*.md")))
+    return files
 
 def render_result(result):
-    """Render a single search result"""
     score = result.get('relevance_score', 0)
     result_filtered = {k: v for k, v in result.items() 
                       if k not in ['relevance_score', 'video_embed', 'description_embed', 'audio_embed']}
-    
     if 'youtube_id' in result:
         st.video(f"https://youtube.com/watch?v={result['youtube_id']}&t={result.get('start_time', 0)}")
     
@@ -183,8 +203,6 @@ def render_result(result):
                 play_and_download_audio(audio_file)
 
 class FastDatasetSearcher:
-    """Fast dataset search with semantic and token matching"""
-    
     def __init__(self, dataset_id="tomg-group-umd/cinepile"):
         self.dataset_id = dataset_id
         self.text_model = get_model()
@@ -197,18 +215,16 @@ class FastDatasetSearcher:
             st.session_state['dataset_info'] = get_dataset_info(self.dataset_id, self.token)
 
     def load_page(self, page=0):
-        """Load a specific page of data"""
         return load_dataset_page(self.dataset_id, self.token, page, ROWS_PER_PAGE)
 
     def quick_search(self, query, df):
-        """Perform quick search with semantic similarity"""
         if df.empty or not query.strip():
             return df
         
         try:
             searchable_cols = []
             for col in df.columns:
-                sample_val = df[col].iloc[0]
+                sample_val = df[col].iloc[0] if len(df) > 0 else ""
                 if not isinstance(sample_val, (np.ndarray, bytes)):
                     searchable_cols.append(col)
             
@@ -253,7 +269,7 @@ class FastDatasetSearcher:
                 if text.strip():
                     text_tokens = set(text.lower().split())
                     matching_terms = query_terms.intersection(text_tokens)
-                    keyword_score = len(matching_terms) / len(query_terms)
+                    keyword_score = len(matching_terms) / len(query_terms) if len(query_terms) > 0 else 0.0
                     
                     text_embedding = self.text_model.encode([text], show_progress_bar=False)[0]
                     semantic_score = float(cosine_similarity([query_embedding], [text_embedding])[0][0])
@@ -286,9 +302,13 @@ class FastDatasetSearcher:
             st.error(f"Search error: {str(e)}")
             return df
 
+# -------------------- Main App --------------------
 def main():
     st.title("🎥 Smart Video & Voice Search")
     
+    # Load saved inputs (conversation history)
+    saved_files = list_saved_inputs()
+    
     # Initialize components
     voice_component = create_voice_component()
     search = FastDatasetSearcher()
@@ -296,176 +316,31 @@ def main():
     # Voice input at top level
     voice_val = voice_component(my_input_value="Start speaking...")
     
-    # Show voice input if detected
+    # User can override max items
+    with st.sidebar:
+        st.write(f"**Current User:** {st.session_state['user_name']}")
+        st.session_state['max_items'] = st.number_input("Max Items per search iteration:", min_value=1, max_value=1000, value=st.session_state['max_items'])
+        st.subheader("📝 Saved Inputs:")
+        # Show saved md files in order
+        for fpath in saved_files:
+            fname = os.path.basename(fpath)
+            st.write(f"- [{fname}]({fpath})")
+    
     if voice_val:
         voice_text = str(voice_val).strip()
         edited_input = st.text_area("✏️ Edit Voice Input:", value=voice_text, height=100)
         
+        # Auto-run default True now
         run_option = st.selectbox("Select Search Type:", 
-                                ["Quick Search", "Deep Search", "Voice Summary"])
+                                  ["Quick Search", "Deep Search", "Voice Summary"])
         
         col1, col2 = st.columns(2)
         with col1:
-            autorun = st.checkbox("⚡ Auto-Run", value=False)
+            autorun = st.checkbox("⚡ Auto-Run", value=True)
         with col2:
             full_audio = st.checkbox("🔊 Full Audio", value=False)
         
         input_changed = (voice_text != st.session_state.get('old_val'))
         
         if autorun and input_changed:
-            st.session_state['old_val'] = voice_text
-            with st.spinner("Processing voice input..."):
-                if run_option == "Quick Search":
-                    results = search.quick_search(edited_input, search.load_page())
-                    for i, result in enumerate(results.iterrows(), 1):
-                        with st.expander(f"Result {i}", expanded=(i==1)):
-                            render_result(result[1])
-                            
-                elif run_option == "Deep Search":
-                    with st.spinner("Performing deep search..."):
-                        results = []
-                        for page in range(3):  # Search first 3 pages
-                            df = search.load_page(page)
-                            results.extend(search.quick_search(edited_input, df).iterrows())
-                        
-                        for i, result in enumerate(results, 1):
-                            with st.expander(f"Result {i}", expanded=(i==1)):
-                                render_result(result[1])
-                                
-                elif run_option == "Voice Summary":
-                    audio_file = speak_with_edge_tts(edited_input)
-                    if audio_file:
-                        play_and_download_audio(audio_file)
-                        
-        elif st.button("🔍 Search", key="voice_input_search"):
-            st.session_state['old_val'] = voice_text
-            with st.spinner("Processing..."):
-                results = search.quick_search(edited_input, search.load_page())
-                for i, result in enumerate(results.iterrows(), 1):
-                    with st.expander(f"Result {i}", expanded=(i==1)):
-                        render_result(result[1])
-    
-    # Create main tabs
-    tab1, tab2, tab3, tab4 = st.tabs([
-        "🔍 Search", "🎙️ Voice", "💾 History", "⚙️ Settings"
-    ])
-    
-    with tab1:
-        st.subheader("🔍 Search")
-        col1, col2 = st.columns([3, 1])
-        with col1:
-            query = st.text_input("Enter search query:", 
-                                value="" if st.session_state['initial_search_done'] else "")
-        with col2:
-            search_column = st.selectbox("Search in:", 
-                                       ["All Fields"] + st.session_state['search_columns'])
-        
-        col3, col4 = st.columns(2)
-        with col3:
-            num_results = st.slider("Max results:", 1, 100, 20)
-        with col4:
-            search_button = st.button("🔍 Search", key="main_search_button")
-        
-        if (search_button or not st.session_state['initial_search_done']) and query:
-            st.session_state['initial_search_done'] = True
-            selected_column = None if search_column == "All Fields" else search_column
-            
-            with st.spinner("Searching..."):
-                df = search.load_page()
-                results = search.quick_search(query, df)
-                
-                if len(results) > 0:
-                    st.session_state['search_history'].append({
-                        'query': query,
-                        'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                        'results': results[:5]
-                    })
-                    
-                    st.write(f"Found {len(results)} results:")
-                    for i, (_, result) in enumerate(results.iterrows(), 1):
-                        if i > num_results:
-                            break
-                        with st.expander(f"Result {i}", expanded=(i==1)):
-                            render_result(result)
-                else:
-                    st.warning("No matching results found.")
-    
-    with tab2:
-        st.subheader("🎙️ Voice Input")
-        st.write("Use the voice input above to start speaking, or record a new message:")
-        
-        col1, col2 = st.columns(2)
-        with col1:
-            if st.button("🎙️ Start New Recording", key="start_recording_button"):
-                st.session_state['recording'] = True
-                st.experimental_rerun()
-        with col2:
-            if st.button("🛑 Stop Recording", key="stop_recording_button"):
-                st.session_state['recording'] = False
-                st.experimental_rerun()
-        
-        if st.session_state.get('recording', False):
-            voice_component = create_voice_component()
-            new_val = voice_component(my_input_value="Recording...")
-            if new_val:
-                st.text_area("Recorded Text:", value=new_val, height=100)
-                if st.button("🔍 Search with Recording", key="recording_search_button"):
-                    with st.spinner("Processing recording..."):
-                        df = search.load_page()
-                        results = search.quick_search(new_val, df)
-                        for i, (_, result) in enumerate(results.iterrows(), 1):
-                            with st.expander(f"Result {i}", expanded=(i==1)):
-                                render_result(result)
-    
-    with tab3:
-        st.subheader("💾 Search History")
-        if not st.session_state['search_history']:
-            st.info("No search history yet. Try searching for something!")
-        else:
-            for entry in reversed(st.session_state['search_history']):
-                with st.expander(f"🕒 {entry['timestamp']} - {entry['query']}", expanded=False):
-                    for i, result in enumerate(entry['results'], 1):
-                        st.write(f"**Result {i}:**")
-                        if isinstance(result, pd.Series):
-                            render_result(result)
-                        else:
-                            st.write(result)
-    
-    with tab4:
-        st.subheader("⚙️ Settings")
-        st.write("Voice Settings:")
-        default_voice = st.selectbox(
-            "Default Voice:",
-            [
-                "en-US-AriaNeural",
-                "en-US-GuyNeural",
-                "en-GB-SoniaNeural",
-                "en-GB-TonyNeural"
-            ],
-            index=0,
-            key="default_voice_setting"
-        )
-        
-        st.write("Search Settings:")
-        st.slider("Minimum Search Score:", 0.0, 1.0, MIN_SEARCH_SCORE, 0.1, key="min_search_score")
-        st.slider("Exact Match Boost:", 1.0, 3.0, EXACT_MATCH_BOOST, 0.1, key="exact_match_boost")
-        
-        if st.button("🗑️ Clear Search History", key="clear_history_button"):
-            st.session_state['search_history'] = []
-            st.success("Search history cleared!")
-            st.experimental_rerun()
-    
-    # Sidebar with metrics
-    with st.sidebar:
-        st.subheader("📊 Search Metrics")
-        total_searches = len(st.session_state['search_history'])
-        st.metric("Total Searches", total_searches)
-        
-        if total_searches > 0:
-            recent_searches = st.session_state['search_history'][-5:]
-            st.write("Recent Searches:")
-            for entry in reversed(recent_searches):
-                st.write(f"🔍 {entry['query']}")
-
-if __name__ == "__main__":
-    main()
+