Update app.py

app.py

@@ -1,24 +1,22 @@
 import gradio as gr
 import requests
 from transformers import pipeline
-import edge_tts
 import tempfile
 import asyncio
 import os
 import json
 
-ENDPOINT_URL = "https://l8opkfvazwgxqljm.us-east-1.aws.endpoints.huggingface.cloud"
+ENDPOINT_URL = "https://xzup8268xrmmxcma.us-east-1.aws.endpoints.huggingface.cloud"
 hf_token = os.getenv("HF_TOKEN")
 
-asr = pipeline("automatic-speech-recognition", "facebook/wav2vec2-base-960h")
+try:
+    asr = pipeline("automatic-speech-recognition", "facebook/wav2vec2-base-960h")
+except:
+    asr = None
+    print("ASR model failed to load, voice features disabled")
 
 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"}
@@ -27,9 +25,9 @@ def classify_mood(input_string):
             return word, True
     return None, False
 
-def generate(prompt, history, temperature=0.1, max_new_tokens=2048):
+def generate(prompt, history):
     if not hf_token:
-        return "Error: Hugging Face authentication required. Please set your HF_TOKEN."
+        return "Error: Please set your HF_TOKEN environment variable."
     
     formatted_prompt = format_prompt(prompt, history)
     
@@ -41,8 +39,8 @@ def generate(prompt, history, temperature=0.1, max_new_tokens=2048):
     payload = {
         "model": "meta-llama/Llama-3.1-8B-Instruct",
         "messages": [{"role": "user", "content": formatted_prompt}],
-        "temperature": temperature,
-        "max_tokens": max_new_tokens,
+        "temperature": 0.1,
+        "max_tokens": 512,
         "stream": False
     }
 
@@ -55,136 +53,93 @@ def generate(prompt, history, temperature=0.1, max_new_tokens=2048):
             
             mood, is_classified = classify_mood(output)
             if is_classified:
-                playlist_message = f"Playing {mood.capitalize()} playlist for you!"
-                return playlist_message
+                return f"🎵 Playing {mood.capitalize()} playlist for you! 🎵"
             return output
         else:
             return f"Error: {response.status_code} - {response.text}"
             
     except Exception as e:
-        return f"Error generating response: {str(e)}"
+        return f"Error: {str(e)}"
 
 def format_prompt(message, history):
-    fixed_prompt = """
-    You are a smart mood analyzer tasked with determining the user's mood for a music recommendation system. Your goal is to classify the user's mood into one of four categories: Happy, Sad, Instrumental, or Party.
-    Instructions:
-    1. Engage in a conversation with the user to understand their mood.
-    2. Ask relevant questions to guide the conversation towards mood classification.
-    3. If the user's mood is clear, respond with a single word: "Happy", "Sad", "Instrumental", or "Party".
-    4. If the mood is unclear, continue the conversation with a follow-up question.
-    5. Limit the conversation to a maximum of 5 exchanges.
-    6. Do not classify the mood prematurely if it's not evident from the user's responses.
-    7. Focus on the user's emotional state rather than specific activities or preferences.
-    8. If unable to classify after 5 exchanges, respond with "Unclear" to indicate the need for more information.
-    Remember: Your primary goal is mood classification. Stay on topic and guide the conversation towards understanding the user's emotional state.
-    """
-    prompt = f"{fixed_prompt}\n"
+    prompt = """You are a mood analyzer for music recommendations. Classify user mood as: Happy, Sad, Instrumental, or Party.
+
+Instructions:
+1. Chat with the user to understand their mood
+2. When clear, respond with ONLY one word: Happy, Sad, Instrumental, or Party
+3. If unclear, ask a follow-up question
+4. Maximum 5 exchanges
+
+"""
     
-    for i, (user_prompt, bot_response) in enumerate(history):
-        prompt += f"User: {user_prompt}\nAssistant: {bot_response}\n"
-        if i == 3:
-            prompt += "Note: This is the last exchange. Classify the mood if possible or respond with 'Unclear'.\n"
+    for user_msg, bot_msg in history:
+        if user_msg.strip():
+            prompt += f"User: {user_msg}\nAssistant: {bot_msg}\n"
     
     prompt += f"User: {message}\nAssistant:"
     return prompt
 
-async def text_to_speech(text):
+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."
+    
     try:
-        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
+        result = asr(audio_file)
+        return result["text"]
     except Exception as e:
-        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 Voice Chat")
+        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!")
     
-    chatbot = gr.Chatbot()
+    chatbot = gr.Chatbot(height=400, label="Chat")
     
     with gr.Row():
         msg = gr.Textbox(
             placeholder="Type your message here...", 
-            label="Text Input",
+            label="Message",
             scale=4
         )
-        submit = gr.Button("Send", scale=1)
+        send_btn = gr.Button("Send", scale=1, variant="primary")
     
-    with gr.Row():
-        voice_input = gr.File(
-            label="Upload Voice Recording (or record using your device)", 
-            file_types=[".wav", ".mp3", ".m4a", ".ogg"]
+    if asr:
+        gr.Markdown("### 🎤 Voice Input (Optional)")
+        audio_input = gr.Audio(
+            label="Record your voice", 
+            type="filepath"
         )
+        transcribe_btn = gr.Button("Convert Speech to Text")
         
-    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]
-    )
+        transcribe_btn.click(
+            speech_to_text_simple,
+            inputs=[audio_input],
+            outputs=[msg]
+        )
     
-    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]
-    )
+    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])
+    
+    demo.load(lambda: [[None, INITIAL_MESSAGE]], None, chatbot)
 
 if __name__ == "__main__":
-    demo.launch(share=True)
+    demo.launch(share=True, show_error=True)