Update app.py

app.py

@@ -241,24 +241,24 @@ def load_mp3_viewer():
         if filename not in st.session_state['mp3_files']:
             st.session_state['mp3_files'][filename] = mp3
 
-async def save_chat_entry(username, message, is_markdown=False):
+async def save_chat_entry(username, message, voice, is_markdown=False):
+    if not message.strip():
+        return None, None
     central = pytz.timezone('US/Central')
     timestamp = datetime.now(central).strftime("%Y-%m-%d %H:%M:%S")
-    entry = f"[{timestamp}] {username}: {message}" if not is_markdown else f"[{timestamp}] {username}:\n```markdown\n{message}\n```"
+    entry = f"[{timestamp}] {username} ({voice}): {message}" if not is_markdown else f"[{timestamp}] {username} ({voice}):\n```markdown\n{message}\n```"
+    md_file = create_file(entry, username, "md")
     with open(CHAT_FILE, 'a') as f:
         f.write(f"{entry}\n")
-    voice = FUN_USERNAMES.get(username, "en-US-AriaNeural")
     audio_file, _ = await async_edge_tts_generate(message, voice, username)
     if audio_file:
         with open(HISTORY_FILE, 'a') as f:
             f.write(f"[{timestamp}] {username}: Audio - {audio_file}\n")
         st.session_state['mp3_files'][os.path.basename(audio_file)] = audio_file
-    else:
-        print(f"No audio generated for message: '{message}' by {username}")
     await broadcast_message(f"{username}|{message}", "chat")
     st.session_state.last_chat_update = time.time()
     st.session_state.chat_history.append(entry)
-    return audio_file
+    return md_file, audio_file
 
 async def load_chat():
     if not os.path.exists(CHAT_FILE):
@@ -267,11 +267,15 @@ async def load_chat():
     with open(CHAT_FILE, 'r') as f:
         content = f.read().strip()
     lines = content.split('\n')
-    numbered_content = "\n".join(f"{i+1}. {line}" for i, line in enumerate(lines) if line.strip())
+    # Remove duplicates and empty lines
+    unique_lines = list(dict.fromkeys(line for line in lines if line.strip()))
+    numbered_content = "\n".join(f"{i+1}. {line}" for i, line in enumerate(unique_lines))
     return numbered_content
 
 # Claude Search Function
 async def perform_claude_search(query, username):
+    if not query.strip():
+        return None, None
     client = anthropic.Anthropic(api_key=anthropic_key)
     response = client.messages.create(
         model="claude-3-sonnet-20240229",
@@ -282,22 +286,14 @@ async def perform_claude_search(query, username):
     st.markdown(f"### Claude's Reply 🧠\n{result}")
     
     # Save to chat history with audio
-    audio_file, _ = await async_edge_tts_generate(result, st.session_state['tts_voice'], username)
-    if audio_file:
-        central = pytz.timezone('US/Central')
-        timestamp = datetime.now(central).strftime("%Y-%m-%d %H:%M:%S")
-        entry = f"[{timestamp}] {username}:\n```markdown\nClaude Search: {query}\nResponse: {result}\n```"
-        with open(CHAT_FILE, 'a') as f:
-            f.write(f"{entry}\n")
-        with open(HISTORY_FILE, 'a') as f:
-            f.write(f"[{timestamp}] {username}: Audio - {audio_file}\n")
-        st.session_state['mp3_files'][os.path.basename(audio_file)] = audio_file
-        st.session_state.chat_history.append(entry)
-        play_and_download_audio(audio_file)
-    return result
+    voice = FUN_USERNAMES.get(username, "en-US-AriaNeural")
+    md_file, audio_file = await save_chat_entry(username, f"Claude Search: {query}\nResponse: {result}", voice, True)
+    return md_file, audio_file
 
 # ArXiv Search Function
 async def perform_arxiv_search(query, username):
+    if not query.strip():
+        return None, None
     # Step 1: Claude Search
     client = anthropic.Anthropic(api_key=anthropic_key)
     claude_response = client.messages.create(
@@ -317,26 +313,10 @@ async def perform_arxiv_search(query, username):
     result = f"🔎 {enhanced_query}\n\n{refs}"
     st.markdown(f"### ArXiv Results 🔍\n{result}")
 
-    # Parse papers and generate long audio
-    papers = parse_arxiv_refs(refs)
-    if papers:
-        long_audio_text = f"Claude Search: {query}\nResponse: {claude_result}\n\nArXiv Results:\n"
-        for i, paper in enumerate(papers, 1):
-            long_audio_text += f"Paper {i}: {paper['title']} by {paper['authors']}. Summary: {paper['summary']}\n"
-        audio_file, _ = await async_edge_tts_generate(long_audio_text, st.session_state['tts_voice'], username)
-        if audio_file:
-            central = pytz.timezone('US/Central')
-            timestamp = datetime.now(central).strftime("%Y-%m-%d %H:%M:%S")
-            entry = f"[{timestamp}] {username}:\n```markdown\nArXiv Search: {query}\nClaude Response: {claude_result}\nArXiv Results: {refs}\n```"
-            with open(CHAT_FILE, 'a') as f:
-                f.write(f"{entry}\n")
-            with open(HISTORY_FILE, 'a') as f:
-                f.write(f"[{timestamp}] {username}: Audio - {audio_file}\n")
-            st.session_state['mp3_files'][os.path.basename(audio_file)] = audio_file
-            st.session_state.chat_history.append(entry)
-            st.subheader("📝 Full ArXiv Audio")
-            play_and_download_audio(audio_file)
-    return result, papers
+    # Save to chat history with audio
+    voice = FUN_USERNAMES.get(username, "en-US-AriaNeural")
+    md_file, audio_file = await save_chat_entry(username, f"ArXiv Search: {query}\nClaude Response: {claude_result}\nArXiv Results: {refs}", voice, True)
+    return md_file, audio_file
 
 async def perform_ai_lookup(q, vocal_summary=True, extended_refs=False, titles_summary=True, full_audio=False, useArxiv=True, useArxivAudio=False):
     start = time.time()
@@ -350,7 +330,7 @@ async def perform_ai_lookup(q, vocal_summary=True, extended_refs=False, titles_s
     st.markdown(response.content[0].text)
 
     result = response.content[0].text
-    md_file = create_file(q, result, "System")
+    md_file = create_file(result, "System", "md")
     audio_file, _ = await async_edge_tts_generate(result, st.session_state['tts_voice'], "System")
     st.subheader("📝 Main Response Audio")
     play_and_download_audio(audio_file)
@@ -363,7 +343,7 @@ async def perform_ai_lookup(q, vocal_summary=True, extended_refs=False, titles_s
             q, 10, "Semantic Search", "mistralai/Mixtral-8x7B-Instruct-v0.1", api_name="/update_with_rag_md"
         )[0]
         result = f"🔎 {q}\n\n{refs}"
-        md_file = create_file(q, result, "System")
+        md_file = create_file(result, "System", "md")
         audio_file, _ = await async_edge_tts_generate(result, st.session_state['tts_voice'], "System")
         st.subheader("📝 ArXiv Response Audio")
         play_and_download_audio(audio_file)
@@ -386,16 +366,17 @@ async def websocket_handler(websocket, path):
     username = st.session_state.get('username', random.choice(list(FUN_USERNAMES.keys())))
     chat_content = await load_chat()
     if not any(f"Client-{client_id}" in line for line in chat_content.split('\n')):
-        await save_chat_entry("System 🌟", f"{username} has joined {START_ROOM}!")
+        await save_chat_entry("System 🌟", f"{username} has joined {START_ROOM}!", "en-US-AriaNeural")
     try:
         async for message in websocket:
             if '|' in message:
                 username, content = message.split('|', 1)
-                await save_chat_entry(username, content)
+                voice = FUN_USERNAMES.get(username, "en-US-AriaNeural")
+                await save_chat_entry(username, content, voice)
             else:
                 await websocket.send("ERROR|Message format: username|content")
     except websockets.ConnectionClosed:
-        await save_chat_entry("System 🌟", f"{username} has left {START_ROOM}!")
+        await save_chat_entry("System 🌟", f"{username} has left {START_ROOM}!", "en-US-AriaNeural")
     finally:
         if room_id in st.session_state.active_connections and client_id in st.session_state.active_connections[room_id]:
             del st.session_state.active_connections[room_id][client_id]
@@ -581,7 +562,7 @@ def main():
         available = [n for n in FUN_USERNAMES if not any(f"{n} has joined" in l for l in asyncio.run(load_chat()).split('\n'))]
         st.session_state.username = random.choice(available or list(FUN_USERNAMES.keys()))
         st.session_state.tts_voice = FUN_USERNAMES[st.session_state.username]
-        asyncio.run(save_chat_entry("System 🌟", f"{st.session_state.username} has joined {START_ROOM}!"))
+        asyncio.run(save_chat_entry("System 🌟", f"{st.session_state.username} has joined {START_ROOM}!", "en-US-AriaNeural"))
     save_username(st.session_state.username)
 
     st.title(f"{Site_Name} for {st.session_state.username}")
@@ -590,35 +571,18 @@ def main():
 
     # Speech Component at Top Level
     mycomponent = components.declare_component("mycomponent", path="mycomponent")
-    val = mycomponent(my_input_value="Hello from MyComponent")
-    if val:
-        val_stripped = val.replace('\\n', ' ')
-        edited_input = st.text_area("✏️ Edit Input:", value=val_stripped, height=100, key="speech_input")
-        run_option = st.selectbox("Model:", ["Chat", "Arxiv"], key="model_select")
-        col1, col2 = st.columns(2)
-        with col1:
-            st.checkbox("⚙ AutoRun", value=True, key="autorun")  # Let Streamlit manage autorun state
-        with col2:
-            full_audio = st.checkbox("📚 FullAudio", value=False, key="full_audio")
-
-        input_changed = (val != st.session_state.old_val)
-
-        if st.session_state.autorun and input_changed:
-            st.session_state.old_val = val
-            st.session_state.last_query = edited_input
-            if run_option == "Chat":
-                asyncio.run(save_chat_entry(st.session_state.username, edited_input, True))
-            elif run_option == "Arxiv":
-                asyncio.run(perform_ai_lookup(edited_input, useArxiv=True, useArxivAudio=full_audio))
-        elif st.button("▶ Run", key="run_button"):
+    val = mycomponent(my_input_value="")
+    if val and val != st.session_state.old_val:
+        val_stripped = val.strip().replace('\n', ' ')
+        if val_stripped:
             st.session_state.old_val = val
-            st.session_state.last_query = edited_input
-            if run_option == "Chat":
-                asyncio.run(save_chat_entry(st.session_state.username, edited_input, True))
-            elif run_option == "Arxiv":
-                asyncio.run(perform_ai_lookup(edited_input, useArxiv=True, useArxivAudio=full_audio))
+            voice = FUN_USERNAMES.get(st.session_state.username, "en-US-AriaNeural")
+            md_file, audio_file = asyncio.run(save_chat_entry(st.session_state.username, val_stripped, voice))
+            if audio_file:
+                play_and_download_audio(audio_file)
+            st.rerun()
 
-    tab_main = st.radio("Action:", ["🎤 Chat & Voice", "📸 Media", "🔍 ArXiv", "📚 PDF to Audio"], horizontal=True, key="tab_main")
+    tab_main = st.radio("Action:", ["🎤 Chat & Voice", "🔍 ArXiv", "📚 PDF to Audio"], horizontal=True, key="tab_main")
     useArxiv = st.checkbox("Search ArXiv", True, key="use_arxiv")
     useArxivAudio = st.checkbox("ArXiv Audio", False, key="use_arxiv_audio")
     st.checkbox("Autosend Chat", value=True, key="autosend")
@@ -630,23 +594,7 @@ def main():
         chat_content = asyncio.run(load_chat())
         chat_container = st.container()
         with chat_container:
-            lines = chat_content.split('\n')
-            for i, line in enumerate(lines):
-                if line.strip():
-                    col1, col2 = st.columns([5, 1])
-                    with col1:
-                        st.markdown(line)
-                        for mp3_name, mp3_path in st.session_state['mp3_files'].items():
-                            if st.session_state.username in mp3_name and any(word in mp3_name for word in line.split()):
-                                st.audio(mp3_path)
-                                break
-                    with col2:
-                        if st.button(f"👍", key=f"chat_vote_{i}"):
-                            user_hash = generate_user_hash()
-                            save_vote(QUOTE_VOTES_FILE, line, user_hash)
-                            st.session_state.timer_start = time.time()
-                            save_username(st.session_state.username)
-                            st.rerun()
+            st.markdown(chat_content)
 
         message = st.text_input(f"Message as {st.session_state.username}", key="message_input")
         paste_result = paste_image_button("📋 Paste Image or Text", key="paste_button_msg")
@@ -665,80 +613,48 @@ def main():
             col_send, col_claude, col_arxiv = st.columns([1, 1, 1])
             
             with col_send:
-                if st.session_state.autosend or st.button("Send 🚀", key="send_button"):  # Existing Send button
+                if st.session_state.autosend or st.button("Send 🚀", key="send_button"):
+                    voice = FUN_USERNAMES.get(st.session_state.username, "en-US-AriaNeural")
                     if message.strip():
-                        asyncio.run(save_chat_entry(st.session_state.username, message, True))
+                        md_file, audio_file = asyncio.run(save_chat_entry(st.session_state.username, message, voice, True))
+                        if audio_file:
+                            play_and_download_audio(audio_file)
                     if st.session_state.pasted_image_data:
-                        asyncio.run(save_chat_entry(st.session_state.username, f"Pasted image: {st.session_state.pasted_image_data}"))
+                        asyncio.run(save_chat_entry(st.session_state.username, f"Pasted image: {st.session_state.pasted_image_data}", voice))
                         st.session_state.pasted_image_data = None
                     st.session_state.timer_start = time.time()
                     save_username(st.session_state.username)
                     st.rerun()
 
             with col_claude:
-                if st.button("🧠 Claude", key="claude_button"):  # New Claude button
+                if st.button("🧠 Claude", key="claude_button"):
+                    voice = FUN_USERNAMES.get(st.session_state.username, "en-US-AriaNeural")
                     if message.strip():
-                        asyncio.run(perform_claude_search(message, st.session_state.username))
+                        md_file, audio_file = asyncio.run(perform_claude_search(message, st.session_state.username))
+                        if audio_file:
+                            play_and_download_audio(audio_file)
                         st.session_state.timer_start = time.time()
                         save_username(st.session_state.username)
                         st.rerun()
 
             with col_arxiv:
-                if st.button("🔍 ArXiv", key="arxiv_button"):  # New ArXiv button
+                if st.button("🔍 ArXiv", key="arxiv_button"):
+                    voice = FUN_USERNAMES.get(st.session_state.username, "en-US-AriaNeural")
                     if message.strip():
-                        asyncio.run(perform_arxiv_search(message, st.session_state.username))
+                        md_file, audio_file = asyncio.run(perform_arxiv_search(message, st.session_state.username))
+                        if audio_file:
+                            play_and_download_audio(audio_file)
                         st.session_state.timer_start = time.time()
                         save_username(st.session_state.username)
                         st.rerun()
 
-    # 📸 Media
-    elif tab_main == "📸 Media":
-        st.header("📸 Media Gallery")
-        all_files = sorted(glob.glob("*.md") + glob.glob("*.mp3") + glob.glob("*.png") + glob.glob("*.mp4"), key=os.path.getmtime, reverse=True)
-        md_files = [f for f in all_files if f.endswith('.md')]
-        mp3_files = [f for f in all_files if f.endswith('.mp3')]
-        png_files = [f for f in all_files if f.endswith('.png')]
-        mp4_files = [f for f in all_files if f.endswith('.mp4')]
-
-        st.subheader("All Submitted Text")
-        all_md_content = concatenate_markdown_files()
-        st.markdown(all_md_content)
-
-        st.subheader("🎵 Audio (MP3)")
-        for mp3 in mp3_files:
-            with st.expander(os.path.basename(mp3)):
-                st.audio(mp3)
-                st.markdown(get_download_link(mp3, "mp3"), unsafe_allow_html=True)
-
-        st.subheader("🖼️ Images (PNG)")
-        for png in png_files:
-            with st.expander(os.path.basename(png)):
-                st.image(png, use_container_width=True)
-                st.markdown(get_download_link(png, "png"), unsafe_allow_html=True)
-
-        st.subheader("🎥 Videos (MP4)")
-        for mp4 in mp4_files:
-            with st.expander(os.path.basename(mp4)):
-                st.video(mp4)
-                st.markdown(get_download_link(mp4, "mp4"), unsafe_allow_html=True)
-
-        uploaded_file = st.file_uploader("Upload Media", type=['png', 'mp4', 'mp3'], key="media_upload")
-        if uploaded_file:
-            filename = f"{format_timestamp_prefix(st.session_state.username)}-{hashlib.md5(uploaded_file.getbuffer()).hexdigest()[:8]}.{uploaded_file.name.split('.')[-1]}"
-            with open(filename, 'wb') as f:
-                f.write(uploaded_file.getbuffer())
-            asyncio.run(save_chat_entry(st.session_state.username, f"Uploaded: {filename}"))
-            st.session_state.timer_start = time.time()
-            save_username(st.session_state.username)
-            st.rerun()
-
     # 🔍 ArXiv
     elif tab_main == "🔍 ArXiv":
         st.subheader("🔍 Query ArXiv")
         q = st.text_input("🔍 Query:", key="arxiv_query")
         if q and q != st.session_state.last_query:
             st.session_state.last_query = q
-            if st.session_state.autosearch or st.button("🔍 Run", key="arxiv_run"):  # Use st.session_state.autosearch directly
+            if st.session_state.autosearch or st.button("🔍 Run", key="arxiv_run"):
                 result, papers = asyncio.run(perform_ai_lookup(q, useArxiv=useArxiv, useArxivAudio=useArxivAudio))
                 for i, p in enumerate(papers, 1):
                     with st.expander(f"{i}. 📄 {p['title']}"):
@@ -763,13 +679,44 @@ def main():
                         if audios.get(i):
                             st.audio(audios[i])
                             st.markdown(get_download_link(audios[i], "mp3"), unsafe_allow_html=True)
-                            asyncio.run(save_chat_entry(st.session_state.username, f"PDF Page {i+1} converted to audio: {audios[i]}"))
+                            voice = FUN_USERNAMES.get(st.session_state.username, "en-US-AriaNeural")
+                            asyncio.run(save_chat_entry(st.session_state.username, f"PDF Page {i+1} converted to audio: {audios[i]}", voice))
+
+    # Always Visible Media Gallery
+    st.header("📸 Media Gallery")
+    all_files = sorted(glob.glob("*.md") + glob.glob("*.mp3") + glob.glob("*.png") + glob.glob("*.mp4"), key=os.path.getmtime, reverse=True)
+    md_files = [f for f in all_files if f.endswith('.md')]
+    mp3_files = [f for f in all_files if f.endswith('.mp3')]
+    png_files = [f for f in all_files if f.endswith('.png')]
+    mp4_files = [f for f in all_files if f.endswith('.mp4')]
+
+    st.subheader("All Submitted Text")
+    all_md_content = concatenate_markdown_files()
+    st.markdown(all_md_content)
+
+    st.subheader("🎵 Audio (MP3)")
+    for mp3 in mp3_files:
+        with st.expander(os.path.basename(mp3)):
+            st.audio(mp3)
+            st.markdown(get_download_link(mp3, "mp3"), unsafe_allow_html=True)
+
+    st.subheader("🖼️ Images (PNG)")
+    for png in png_files:
+        with st.expander(os.path.basename(png)):
+            st.image(png, use_container_width=True)
+            st.markdown(get_download_link(png, "png"), unsafe_allow_html=True)
+
+    st.subheader("🎥 Videos (MP4)")
+    for mp4 in mp4_files:
+        with st.expander(os.path.basename(mp4)):
+            st.video(mp4)
+            st.markdown(get_download_link(mp4, "mp4"), unsafe_allow_html=True)
 
     # 🗂️ Sidebar with Dialog and Audio
     st.sidebar.subheader("Voice Settings")
     new_username = st.sidebar.selectbox("Change Name/Voice", list(FUN_USERNAMES.keys()), index=list(FUN_USERNAMES.keys()).index(st.session_state.username), key="username_select")
     if new_username != st.session_state.username:
-        asyncio.run(save_chat_entry("System 🌟", f"{st.session_state.username} changed to {new_username}"))
+        asyncio.run(save_chat_entry("System 🌟", f"{st.session_state.username} changed to {new_username}", "en-US-AriaNeural"))
         st.session_state.username, st.session_state.tts_voice = new_username, FUN_USERNAMES[new_username]
         st.session_state.timer_start = time.time()
         save_username(st.session_state.username)
@@ -777,24 +724,7 @@ def main():
 
     st.sidebar.markdown("### 💬 Chat Dialog & Media")
     chat_content = asyncio.run(load_chat())
-    lines = chat_content.split('\n')
-    all_files = sorted(glob.glob("*.md") + glob.glob("*.mp3") + glob.glob("*.png") + glob.glob("*.mp4"), key=os.path.getmtime, reverse=True)
-    for line in lines[-10:]:
-        if line.strip():
-            st.sidebar.markdown(f"**{line}**")
-            for f in all_files:
-                f_name = os.path.basename(f)
-                if st.session_state.username in f_name and any(word in f_name for word in line.split()):
-                    if f.endswith('.mp3'):
-                        st.sidebar.audio(f)
-                        st.sidebar.markdown(get_download_link(f, "mp3"), unsafe_allow_html=True)
-                    elif f.endswith('.png'):
-                        st.sidebar.image(f, use_container_width=True)
-                        st.sidebar.markdown(get_download_link(f, "png"), unsafe_allow_html=True)
-                    elif f.endswith('.mp4'):
-                        st.sidebar.video(f)
-                        st.sidebar.markdown(get_download_link(f, "mp4"), unsafe_allow_html=True)
-                    break
+    st.sidebar.markdown(chat_content)
 
     st.sidebar.subheader("Vote Totals")
     chat_votes = load_votes(QUOTE_VOTES_FILE)
@@ -804,10 +734,6 @@ def main():
     for image, count in image_votes.items():
         st.sidebar.write(f"{image}: {count} votes")
 
-    md_files = [f for f in all_files if f.endswith('.md')]
-    mp3_files = [f for f in all_files if f.endswith('.mp3')]
-    png_files = [f for f in all_files if f.endswith('.png')]
-    mp4_files = [f for f in all_files if f.endswith('.mp4')]
     st.sidebar.markdown("### 📂 File History")
     for f in all_files[:10]:
         st.sidebar.write(f"{FILE_EMOJIS.get(f.split('.')[-1], '📄')} {os.path.basename(f)}")