Update backup13.app.py

backup13.app.py

@@ -126,7 +126,7 @@ def init_session_state():
         'enable_audio': True, 'download_link_cache': {}, 'username': None,
         'autosend': True, 'autosearch': True, 'last_message': "", 'last_query': "",
         'mp3_files': {}, 'timer_start': time.time(), 'quote_index': 0,
-        'quote_source': "famous"
+        'quote_source': "famous", 'last_sent_transcript': "", 'old_val': None
     }
     for k, v in defaults.items():
         if k not in st.session_state:
@@ -213,13 +213,21 @@ async def async_edge_tts_generate(text, voice, username, rate=0, pitch=0, file_f
         return st.session_state['audio_cache'][cache_key], 0
     start_time = time.time()
     text = clean_text_for_tts(text)
-    if not text:
+    if not text or text == "No text":
+        print(f"Skipping audio generation for empty/invalid text: '{text}'")
         return None, 0
     filename = f"{format_timestamp_prefix(username)}-{hashlib.md5(text.encode()).hexdigest()[:8]}.{file_format}"
-    communicate = edge_tts.Communicate(text, voice, rate=f"{rate:+d}%", pitch=f"{pitch:+d}Hz")
-    await communicate.save(filename)
-    st.session_state['audio_cache'][cache_key] = filename
-    return filename, time.time() - start_time
+    try:
+        communicate = edge_tts.Communicate(text, voice, rate=f"{rate:+d}%", pitch=f"{pitch:+d}Hz")
+        await communicate.save(filename)
+        st.session_state['audio_cache'][cache_key] = filename
+        return filename, time.time() - start_time
+    except edge_tts.exceptions.NoAudioReceived as e:
+        print(f"No audio received for text: '{text}' with voice: {voice}. Error: {e}")
+        return None, 0
+    except Exception as e:
+        print(f"Error generating audio for text: '{text}' with voice: {voice}. Error: {e}")
+        return None, 0
 
 def play_and_download_audio(file_path):
     if file_path and os.path.exists(file_path):
@@ -245,6 +253,8 @@ async def save_chat_entry(username, message, is_markdown=False):
         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)
@@ -260,6 +270,44 @@ async def load_chat():
     numbered_content = "\n".join(f"{i+1}. {line}" for i, line in enumerate(lines) if line.strip())
     return numbered_content
 
+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()
+    client = anthropic.Anthropic(api_key=anthropic_key)
+    response = client.messages.create(
+        model="claude-3-sonnet-20240229",
+        max_tokens=1000,
+        messages=[{"role": "user", "content": q}]
+    )
+    st.write("Claude's reply 🧠:")
+    st.markdown(response.content[0].text)
+
+    result = response.content[0].text
+    md_file = create_file(q, result, "System")
+    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)
+
+    if useArxiv:
+        q = q + result
+        st.write('Running Arxiv RAG with Claude inputs.')
+        gradio_client = Client("awacke1/Arxiv-Paper-Search-And-QA-RAG-Pattern")
+        refs = gradio_client.predict(
+            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")
+        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)
+
+        papers = parse_arxiv_refs(refs)
+        if papers and useArxivAudio:
+            await create_paper_audio_files(papers, q)
+        return result, papers
+    elapsed = time.time() - start
+    st.write(f"**Total Elapsed:** {elapsed:.2f} s")
+    return result, []
+
 # 🌐 WebSocket Handling
 async def websocket_handler(websocket, path):
     client_id = str(uuid.uuid4())
@@ -392,28 +440,6 @@ async def create_paper_audio_files(papers, query):
         if p['full_audio']:
             p['download_base64'] = get_download_link(p['full_audio'])
 
-async def perform_ai_lookup(q, useArxiv=True, useArxivAudio=False):
-    client = anthropic.Anthropic(api_key=anthropic_key)
-    response = client.messages.create(model="claude-3-sonnet-20240229", max_tokens=1000, messages=[{"role": "user", "content": q}])
-    result = response.content[0].text
-    st.markdown("### Claude's Reply 🧠\n" + result)
-    md_file = create_file(result, "System", "md")
-    audio_file, _ = await async_edge_tts_generate(result, st.session_state['tts_voice'], "System")
-    play_and_download_audio(audio_file)
-
-    if useArxiv:
-        q += result
-        gradio_client = Client("awacke1/Arxiv-Paper-Search-And-QA-RAG-Pattern")
-        refs = gradio_client.predict(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, audio_file = create_file(result, "System", "md"), (await async_edge_tts_generate(result, st.session_state['tts_voice'], "System"))[0]
-        play_and_download_audio(audio_file)
-        papers = parse_arxiv_refs(refs)
-        if papers and useArxivAudio:
-            await create_paper_audio_files(papers, q)
-        return result, papers
-    return result, []
-
 def save_vote(file, item, user_hash):
     timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
     entry = f"[{timestamp}] {user_hash} voted for {item}"
@@ -474,35 +500,63 @@ def create_zip_of_files(md_files, mp3_files, png_files, mp4_files, query):
     return zip_name
 
 # 🎮 Main Interface
-async def async_interface():
+def main():
     init_session_state()
     load_mp3_viewer()
     saved_username = load_username()
     if saved_username and saved_username in FUN_USERNAMES:
         st.session_state.username = saved_username
     if not st.session_state.username:
-        available = [n for n in FUN_USERNAMES if not any(f"{n} has joined" in l for l in (await load_chat()).split('\n'))]
+        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]
-        await 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}!"))
     save_username(st.session_state.username)
 
     st.title(f"{Site_Name} for {st.session_state.username}")
     update_marquee_settings_ui()
     display_marquee(f"🚀 Welcome to {START_ROOM} | 🤖 {st.session_state.username}", st.session_state['marquee_settings'], "welcome")
 
-    if not st.session_state.server_task:
-        st.session_state.server_task = asyncio.create_task(run_websocket_server())
+    # 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:
+            autorun = st.checkbox("⚙ AutoRun", value=True, key="autorun")
+        with col2:
+            full_audio = st.checkbox("📚 FullAudio", value=False, key="full_audio")
+
+        input_changed = (val != st.session_state.old_val)
+
+        if 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"):
+            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))
 
     tab_main = st.radio("Action:", ["🎤 Chat & Voice", "📸 Media", "🔍 ArXiv", "📚 PDF to Audio"], horizontal=True)
-    useArxiv, useArxivAudio = st.checkbox("Search ArXiv", True), st.checkbox("ArXiv Audio", False)
-    st.session_state.autosend = st.checkbox("Autosend Chat", value=True)
-    st.session_state.autosearch = st.checkbox("Autosearch ArXiv", value=True)
+    useArxiv = st.checkbox("Search ArXiv", True, key="use_arxiv")
+    useArxivAudio = st.checkbox("ArXiv Audio", False, key="use_arxiv_audio")
+    st.session_state.autosend = st.checkbox("Autosend Chat", value=True, key="autosend")
+    st.session_state.autosearch = st.checkbox("Autosearch ArXiv", value=True, key="autosearch")
 
     # 🎤 Chat & Voice
     if tab_main == "🎤 Chat & Voice":
         st.subheader(f"{START_ROOM} Chat 💬")
-        chat_content = await load_chat()
+        chat_content = asyncio.run(load_chat())
         chat_container = st.container()
         with chat_container:
             lines = chat_content.split('\n')
@@ -531,46 +585,21 @@ async def async_interface():
                 message = st.text_input(f"Message as {st.session_state.username}", key="message_input_paste", value=st.session_state.message_text)
             else:
                 st.image(paste_result.image_data, caption="Pasted Image")
-                filename = await save_pasted_image(paste_result.image_data, st.session_state.username)
+                filename = asyncio.run(save_pasted_image(paste_result.image_data, st.session_state.username))
                 if filename:
                     st.session_state.pasted_image_data = filename
         if (message and message != st.session_state.last_message) or st.session_state.pasted_image_data:
             st.session_state.last_message = message
-            if st.session_state.autosend or st.button("Send 🚀"):
+            if st.session_state.autosend or st.button("Send 🚀", key="send_button"):
                 if message.strip():
-                    await save_chat_entry(st.session_state.username, message, True)
+                    asyncio.run(save_chat_entry(st.session_state.username, message, True))
                 if st.session_state.pasted_image_data:
-                    await 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}"))
                     st.session_state.pasted_image_data = None
                 st.session_state.timer_start = time.time()
                 save_username(st.session_state.username)
                 st.rerun()
-                
-        st.subheader("🎤 Speech-to-Chat")
-        from mycomponent import mycomponent  # Correct import
-        transcript_data = mycomponent(default_value=st.session_state.get('last_transcript', ''), key="speech_input")
-        if transcript_data and 'value' in transcript_data:
-            transcript = transcript_data['value'].strip()
-            if transcript:
-                st.write(f"🎙️ You said: {transcript}")
-                if transcript != st.session_state.last_transcript:
-                    st.session_state.last_transcript = transcript
-                    if st.session_state.autosend:
-                        await save_chat_entry(st.session_state.username, transcript, True)
-                        st.session_state.timer_start = time.time()
-                        save_username(st.session_state.username)
-                        # Update chat display without full rerun to reduce flicker
-                        with chat_container:
-                            st.markdown(await load_chat())
-                    else:
-                        if st.button("Send to Chat", key="send_transcript"):
-                            await save_chat_entry(st.session_state.username, transcript, True)
-                            st.session_state.timer_start = time.time()
-                            save_username(st.session_state.username)
-                            st.rerun()
-        else:
-            st.write("🎙️ Speak to transcribe your message...")
-            
+
     # 📸 Media
     elif tab_main == "📸 Media":
         st.header("📸 Media Gallery")
@@ -602,23 +631,24 @@ async def async_interface():
                 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'])
+        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())
-            await save_chat_entry(st.session_state.username, f"Uploaded: {filename}")
+            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"):
-                result, papers = await perform_ai_lookup(q, useArxiv, useArxivAudio)
+            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']}"):
                         st.markdown(f"**{p['date']} | {p['title']}** — [Link]({p['url']})")
@@ -629,8 +659,8 @@ async def async_interface():
     # 📚 PDF to Audio
     elif tab_main == "📚 PDF to Audio":
         audio_processor = AudioProcessor()
-        pdf_file = st.file_uploader("Choose PDF", "pdf")
-        max_pages = st.slider('Pages', 1, 100, 10)
+        pdf_file = st.file_uploader("Choose PDF", "pdf", key="pdf_upload")
+        max_pages = st.slider('Pages', 1, 100, 10, key="pdf_pages")
         if pdf_file:
             with st.spinner('Processing...'):
                 texts, audios, total = process_pdf(pdf_file, max_pages, st.session_state['tts_voice'], audio_processor)
@@ -642,20 +672,20 @@ async def async_interface():
                         if audios.get(i):
                             st.audio(audios[i])
                             st.markdown(get_download_link(audios[i], "mp3"), unsafe_allow_html=True)
-                            await save_chat_entry(st.session_state.username, f"PDF Page {i+1} converted to audio: {audios[i]}")
+                            asyncio.run(save_chat_entry(st.session_state.username, f"PDF Page {i+1} converted to audio: {audios[i]}"))
 
     # 🗂️ 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))
+    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:
-        await 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}"))
         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)
         st.rerun()
 
     st.sidebar.markdown("### 💬 Chat Dialog & Media")
-    chat_content = await load_chat()
+    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:]:
@@ -690,13 +720,13 @@ async def async_interface():
     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)}")
-    if st.sidebar.button("⬇️ Zip All"):
+    if st.sidebar.button("⬇️ Zip All", key="zip_all"):
         zip_name = create_zip_of_files(md_files, mp3_files, png_files, mp4_files, "latest_query")
         if zip_name:
             st.sidebar.markdown(get_download_link(zip_name, "zip"), unsafe_allow_html=True)
 
-def main():
-    asyncio.run(async_interface())
+    if not st.session_state.server_task:
+        st.session_state.server_task = asyncio.create_task(run_websocket_server())
 
 if __name__ == "__main__":
     main()