Update app.py

app.py

@@ -1,6 +1,7 @@
 import gradio as gr
 import requests
 from transformers import pipeline
+import edge_tts
 import tempfile
 import asyncio
 import os
@@ -9,14 +10,15 @@ import json
 ENDPOINT_URL = "https://xzup8268xrmmxcma.us-east-1.aws.endpoints.huggingface.cloud"
 hf_token = os.getenv("HF_TOKEN")
 
-try:
-    asr = pipeline("automatic-speech-recognition", "facebook/wav2vec2-base-960h")
-except:
-    asr = None
-    print("ASR model failed to load, voice features disabled")
+asr = pipeline("automatic-speech-recognition", "facebook/wav2vec2-base-960h")
 
 INITIAL_MESSAGE = "Hi! I'm your music buddy—tell me about your mood and the type of tunes you're in the mood for today!"
 
+def speech_to_text(speech):
+    if speech is None:
+        return ""
+    return asr(speech)["text"]
+
 def classify_mood(input_string):
     input_string = input_string.lower()
     mood_words = {"happy", "sad", "instrumental", "party"}
@@ -25,9 +27,9 @@ def classify_mood(input_string):
             return word, True
     return None, False
 
-def generate(prompt, history):
+def generate(prompt, history, temperature=0.1, max_new_tokens=2048):
     if not hf_token:
-        return "Error: Please set your HF_TOKEN environment variable."
+        return "Error: Hugging Face authentication required. Please set your HF_TOKEN."
     
     formatted_prompt = format_prompt(prompt, history)
     
@@ -39,8 +41,8 @@ def generate(prompt, history):
     payload = {
         "model": "meta-llama/Llama-3.1-8B-Instruct",
         "messages": [{"role": "user", "content": formatted_prompt}],
-        "temperature": 0.1,
-        "max_tokens": 512,
+        "temperature": temperature,
+        "max_tokens": max_new_tokens,
         "stream": False
     }
 
@@ -53,13 +55,14 @@ def generate(prompt, history):
             
             mood, is_classified = classify_mood(output)
             if is_classified:
-                return f"🎵 Playing {mood.capitalize()} playlist for you! 🎵"
+                playlist_message = f"Playing {mood.capitalize()} playlist for you!"
+                return playlist_message
             return output
         else:
             return f"Error: {response.status_code} - {response.text}"
             
     except Exception as e:
-        return f"Error: {str(e)}"
+        return f"Error generating response: {str(e)}"
 
 def format_prompt(message, history):
     fixed_prompt = """
@@ -85,67 +88,104 @@ def format_prompt(message, history):
     prompt += f"User: {message}\nAssistant:"
     return prompt
 
-def chat_interface(message, history):
-    if not message.strip():
-        return history, ""
-    
-    response = generate(message, history)
-    history.append([message, response])
-    return history, ""
-
-def speech_to_text_simple(audio_file):
-    if not asr or not audio_file:
-        return "Voice recognition not available. Please type your message."
-    
+async def text_to_speech(text):
     try:
-        result = asr(audio_file)
-        return result["text"]
+        communicate = edge_tts.Communicate(text)
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_file:
+            tmp_path = tmp_file.name
+            await communicate.save(tmp_path)
+        return tmp_path
     except Exception as e:
-        return f"Voice processing error: {str(e)}"
-
-css = """
-.gradio-container {
-    max-width: 800px !important;
-    margin: auto !important;
-}
-"""
-
-with gr.Blocks(css=css, title="Music Mood Analyzer") as demo:
-    gr.Markdown("# 🎵 Music Mood Analyzer")
-    gr.Markdown("Tell me about your mood and I'll recommend the perfect playlist!")
+        print(f"TTS Error: {e}")
+        return None
+
+def process_input(input_text, history):
+    if not input_text:
+        return history, history, ""
+    response = generate(input_text, history)
+    history.append((input_text, response))
+    return history, history, ""
+
+async def generate_audio(history):
+    if history and len(history) > 0:
+        last_response = history[-1][1]
+        audio_path = await text_to_speech(last_response)
+        return audio_path
+    return None
+
+async def init_chat():
+    history = [("", INITIAL_MESSAGE)]
+    audio_path = await text_to_speech(INITIAL_MESSAGE)
+    return history, history, audio_path
+
+def handle_voice_upload(audio_file):
+    if audio_file is None:
+        return ""
+    return speech_to_text(audio_file)
+
+with gr.Blocks() as demo:
+    gr.Markdown("# Mood-Based Music Recommender with Continuous Voice Chat")
     
-    chatbot = gr.Chatbot(height=400, label="Chat")
+    chatbot = gr.Chatbot()
     
     with gr.Row():
         msg = gr.Textbox(
             placeholder="Type your message here...", 
-            label="Message",
+            label="Text Input",
             scale=4
         )
-        send_btn = gr.Button("Send", scale=1, variant="primary")
+        submit = gr.Button("Send", scale=1)
     
-    if asr:
-        gr.Markdown("### 🎤 Voice Input (Optional)")
-        audio_input = gr.Audio(
-            label="Record your voice", 
+    with gr.Row():
+        voice_input = gr.Audio(
+            label="🎤 Record your voice or upload audio file",
+            sources=["microphone", "upload"],
             type="filepath"
         )
-        transcribe_btn = gr.Button("Convert Speech to Text")
         
-        transcribe_btn.click(
-            speech_to_text_simple,
-            inputs=[audio_input],
-            outputs=[msg]
-        )
-    
-    def respond(message, history):
-        history, empty = chat_interface(message, history)
-        return history, empty
-    
-    msg.submit(respond, [msg, chatbot], [chatbot, msg])
-    send_btn.click(respond, [msg, chatbot], [chatbot, msg])
+    audio_output = gr.Audio(label="AI Response", autoplay=True)
+
+    state = gr.State([])
+
+    demo.load(init_chat, outputs=[state, chatbot, audio_output])
+
+    def submit_and_generate_audio(input_text, history):
+        new_state, new_chatbot, empty_msg = process_input(input_text, history)
+        return new_state, new_chatbot, empty_msg
+
+    msg.submit(
+        submit_and_generate_audio,
+        inputs=[msg, state],
+        outputs=[state, chatbot, msg]
+    ).then(
+        generate_audio,
+        inputs=[state],
+        outputs=[audio_output]
+    )
     
-    demo.load(lambda: [[None, INITIAL_MESSAGE]], None, chatbot)
+    submit.click(
+        submit_and_generate_audio,
+        inputs=[msg, state],
+        outputs=[state, chatbot, msg]
+    ).then(
+        generate_audio,
+        inputs=[state],
+        outputs=[audio_output]
+    )
+
+    voice_input.upload(
+        handle_voice_upload,
+        inputs=[voice_input],
+        outputs=[msg]
+    ).then(
+        submit_and_generate_audio,
+        inputs=[msg, state],
+        outputs=[state, chatbot, msg]
+    ).then(
+        generate_audio,
+        inputs=[state],
+        outputs=[audio_output]
+    )
 
 if __name__ == "__main__":
-    demo.launch(share=True, show_error=True)
+    demo.launch(share=True)