Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,161 +1,95 @@
 import streamlit as st
-import sys
 import os
-
-#-------------------------------------
-import pyttsx3
-import time
 from llama_index.llms.groq import Groq
+import streamlit.components.v1 as components
+
+# Ensure Streamlit config directory is set
+os.environ["STREAMLIT_CONFIG_DIR"] = "/app/.streamlit"
 
 class TextToSpeechChat:
-    def __init__(self, api_key="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"):
+    def __init__(self, api_key="your_api_key"):
         # Initialize the LLM
         self.llm = Groq(model="llama3-70b-8192", api_key=api_key)
-        
-        # Initialize text-to-speech engine
-        self.tts_engine = pyttsx3.init()
-        self.setup_tts()
-        
-        # Initialize speech enabled flag
-        self.speech_enabled = True
-        
-    def setup_tts(self):
-        """Configure text-to-speech settings"""
-        # Get available voices
-        voices = self.tts_engine.getProperty('voices')
-        
-        # Set voice (use first available voice)
-        if voices:
-            self.tts_engine.setProperty('voice', voices[0].id)
-        else:
-            print("⚠️ No voices available for text-to-speech")
-        
-        # Set speech rate (words per minute)
-        self.tts_engine.setProperty('rate', 150)
-        
-        # Set volume (0.0 to 1.0)
-        self.tts_engine.setProperty('volume', 0.9)
-        
-        print("🔊 Text-to-speech engine initialized")
-    
+        self.speech_enabled = st.session_state.get("speech_enabled", True)
+
     def speak_text(self, text):
-        """Convert text to speech with error handling"""
-        if not text.strip():
+        """Convert text to speech using browser's SpeechSynthesis API"""
+        if not text.strip() or not self.speech_enabled:
             return
-            
         try:
-            print(f"🗣️ Speaking paragraph: {text}")
-            self.tts_engine.say(text)
-            self.tts_engine.runAndWait()
+            safe_text = text.replace('"', '\\"').replace('\n', ' ')
+            js_code = f"""
+            <script>
+                function speak(text) {{
+                    const utterance = new SpeechSynthesisUtterance(text);
+                    utterance.rate = 1.0;
+                    utterance.volume = 0.9;
+                    const voices = window.speechSynthesis.getVoices();
+                    if (voices.length > 0) {{
+                        utterance.voice = voices[0];
+                    }}
+                    window.speechSynthesis.speak(utterance);
+                }}
+                window.speechSynthesis.onvoiceschanged = function() {{
+                    speak("{safe_text}");
+                }};
+                window.speechSynthesis.getVoices();
+            </script>
+            """
+            components.html(js_code, height=0)
+            st.write(f"🗣️ Speaking: {text}")
         except Exception as e:
-            print(f"❌ Speech error: {e}")
-    
+            st.error(f"❌ Speech error: {e}")
+
     def get_llm_response(self, prompt):
         """Get response from LLM and speak paragraphs in real-time if enabled"""
         try:
-            print("🤖 Generating response...")
+            st.write("🤖 Generating response...")
             response = self.llm.stream_complete(prompt)
-            
-            # Collect the full response and buffer for paragraphs
             full_response = ""
             buffer = ""
             
+            response_container = st.empty()
             for r in response:
                 delta = r.delta
                 full_response += delta
                 buffer += delta
-                print(delta, end="", flush=True)
+                response_container.write(full_response, unsafe_allow_html=True)
                 
-                # Check for paragraph boundary (\n\n)
                 if self.speech_enabled and "\n\n" in buffer:
-                    # Split buffer into paragraphs
                     paragraphs = buffer.split("\n\n")
-                    # Speak all complete paragraphs (all but the last part)
                     for paragraph in paragraphs[:-1]:
                         if paragraph.strip():
                             self.speak_text(paragraph.strip())
-                    # Keep the last part (incomplete paragraph) in buffer
                     buffer = paragraphs[-1]
             
-            # Speak any remaining buffered text
             if self.speech_enabled and buffer.strip():
                 self.speak_text(buffer.strip())
             
-            print()  # New line after response
             return full_response
-            
         except Exception as e:
             error_msg = f"❌ Error getting LLM response: {e}"
-            print(error_msg)
+            st.error(error_msg)
             if self.speech_enabled:
                 self.speak_text(error_msg)
             return error_msg
-    
-    def chat_with_speech(self):
-        """Interactive chat with text-to-speech output"""
-        print("🎯 TEXT-TO-SPEECH CHAT")
-        print("=" * 50)
-        print("💡 Type your message and press Enter")
-        print("🗣️ The AI response will be spoken aloud paragraph by paragraph as it generates")
-        print("💬 Type 'quit' or 'exit' to end the chat")
-        print("🔇 Type 'mute' to disable speech")
-        print("🔊 Type 'unmute' to enable speech")
-        print("=" * 50)
-        
-        # Test speech engine at startup
-        self.speak_text("Text-to-speech chat started.")
-        
-        while True:
-            try:
-                # Get user input
-                user_input = input("\n👤 You: ").strip()
-                
-                if not user_input:
-                    continue
-                    
-                # Check for commands
-                if user_input.lower() in ['quit', 'exit', 'q']:
-                    self.speak_text("Goodbye!")
-                    print("👋 Goodbye!")
-                    break
-                elif user_input.lower() == 'mute':
-                    self.speech_enabled = False
-                    print("🔇 Speech disabled")
-                    continue
-                elif user_input.lower() == 'unmute':
-                    self.speech_enabled = True
-                    print("🔊 Speech enabled")
-                    self.speak_text("Speech enabled.")
-                    continue
-                
-                # Get AI response, which now speaks paragraphs in real-time
-                print("\n🤖 AI: ", end="")
-                response = self.get_llm_response(user_input)
-                
-            except KeyboardInterrupt:
-                self.speak_text("Goodbye!")
-                print("\n👋 Goodbye!")
-                break
-            except Exception as e:
-                print(f"❌ Error: {e}")
-                if self.speech_enabled:
-                    self.speak_text(f"Error: {str(e)}")
 
 def main(user_input):
     chat = TextToSpeechChat()
     response = chat.get_llm_response(user_input)
     return response
 
-#-----------------------------------
+# Streamlit UI
+st.title("Simple Streamlit UI")
 
+# Speech toggle
+if "speech_enabled" not in st.session_state:
+    st.session_state.speech_enabled = True
 
-# Title of the app
-st.title("Simple Streamlit UI")
+st.checkbox("Enable Speech", value=st.session_state.speech_enabled, key="speech_enabled")
 
-# Text input
 user_input = st.text_input("Enter something:")
-
-# Button
 if st.button("Submit"):
-    st.write("You entered:", main(user_input))
-    
+    st.write("You entered:", user_input)
+    response = main(user_input)
+    st.write("Response:", response)