Update app.py

Back to working code, no thanks to Claude

app.py

@@ -1,72 +1,127 @@
 import gradio as gr
 from huggingface_hub import InferenceClient
+import base64
 import os
+from google import genai
+from google.genai import types
+import spacy
+
 from dotenv import load_dotenv
 
 load_dotenv()
 HF_API_KEY = os.environ["HF_API_KEY"]
 
+"""
+For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
+"""
+nlp = spacy.load("en_core_web_md")
+# !python -m spacy download en_core_web_md
+
+def find_most_relevant_lyric(lyrics, user_input):
+    user_doc = nlp(user_input)
+    best_match = max(lyrics, key=lambda lyric: user_doc.similarity(nlp(lyric)))
+    return best_match
+
+def stitch_lyrics(lyrics):
+    return [lyrics[i] + " " + lyrics[i + line_number] for line_number in range(1,5) for i in range(len(lyrics) - line_number)]
+
+# Load lyrics from a text file
+def load_lyrics(filename):
+    with open(filename, "r", encoding="utf-8") as file:
+        lyrics = file.readlines()
+    return [line.strip() for line in lyrics if line.strip()]  # Remove empty lines
+    #return [line for line in lyrics]
+
+lyrics = load_lyrics("the_bends_lyrics.txt")
+stitched_lyrics = stitch_lyrics(lyrics)
+
 # Initialize Hugging Face Inference Client
 client = InferenceClient(model="google/gemma-2-2b-it", token=HF_API_KEY)
 
-# Create a very minimal chatbot interface
-with gr.Blocks(title="Minimal Gemma Chatbot") as demo:
-    gr.Markdown("# Simple Gemma Chatbot")
+system_message = "Please limit responses to only a few sentences."
+# Function to generate chatbot responses
+def chat_with_musician(user_input, history, artist):
+    if history is None:
+        history = []
+    messages = []
+    #messages.append({"role": "user", "content": system_message})
     
-    chatbot = gr.Chatbot()
-    msg = gr.Textbox(label="Message")
-    clear = gr.Button("Clear")
+    #for pair in history[-5:]:  # Keep only the last 5 exchanges
+    #    if len(pair) == 2:  # Only process valid (user, bot) pairs
+    #        user_msg, bot_msg = pair
+    #        messages.append({"role": "user", "content": user_msg})
+    #        messages.append({"role": "assistant", "content": bot_msg})
+    #for pair in history[-5:]:  # Keep only the last 5 exchanges
+    #    if len(pair) == 2:  # Only process valid (user, bot) pairs
+    #        user_msg, bot_msg = pair
+    #        messages.append({"role": "user", "content": user_msg})
+    #        messages.append({"role": "assistant", "content": bot_msg})
+    # Add the latest user message
+    messages.append({"role": "user", "content": system_message + "\n\n" + user_input})
+    try:
+        response = client.chat_completion(
+            messages=messages,
+            model="google/gemma-2-2b-it",
+            max_tokens=256,
+            temperature=0.7,
+            top_p=0.9
+        )
+        gemma_response= response["choices"][0]["message"]["content"]
+       # history.append({"role": "user", "content": user_msg})
+       # history.append({"role": "assistant", "content": gemma_response})
+    except Exception as e:
+        return f"Error: {str(e)}"
+    if artist == "Radiohead":
+        lyric_response = find_most_relevant_lyric(stitched_lyrics, 
+                        gemma_response)
+    if artist == "Google Gemma":
+        lyric_response = gemma_response
+    return lyric_response, history
     
-    def user(message, history):
-        # Return immediately to update the UI with the user's message
-        return "", history + [[message, None]]
+
     
-    def bot(history):
-        # Process the last user message
-        user_message = history[-1][0]
-        
-        try:
-            # Make a simple API call with just the current message
-            response = client.chat_completion(
-                messages=[{"role": "user", "content": user_message}],
-                model="google/gemma-2-2b-it",
-                max_tokens=256,
-                temperature=0.7
-            )
-            
-            # Print the response structure to help diagnose issues
-            print(f"API response: {response}")
-            
-            # Try to extract the bot message - handle different response formats
-            bot_message = None
-            if isinstance(response, dict):
-                if "choices" in response and len(response["choices"]) > 0:
-                    choice = response["choices"][0]
-                    if isinstance(choice, dict) and "message" in choice:
-                        message = choice["message"]
-                        if isinstance(message, dict) and "content" in message:
-                            bot_message = message["content"]
-            
-            # If we couldn't extract a message, use a fallback
-            if bot_message is None:
-                bot_message = "Sorry, I couldn't generate a proper response."
-                
-            # Update the last history item with the bot's response
-            history[-1][1] = bot_message
-            
-        except Exception as e:
-            print(f"Error: {str(e)}")
-            history[-1][1] = f"Error: {str(e)}"
-        
-        return history
+def chat_with_gemma(user_input, history):
+    if history is None:
+        history = []
+    messages = []
+    #messages.append({"role": "user", "content": system_message})
     
-    # Set up chained event handlers to separate user and bot responses
-    msg.submit(user, [msg, chatbot], [msg, chatbot]).then(
-        bot, chatbot, chatbot
-    )
+    #for pair in history[-5:]:  # Keep only the last 5 exchanges
+    #    if len(pair) == 2:  # Only process valid (user, bot) pairs
+    #        user_msg, bot_msg = pair
+    #        messages.append({"role": "user", "content": user_msg})
+    #        messages.append({"role": "assistant", "content": bot_msg})
     
-    clear.click(lambda: None, None, chatbot, queue=False)
+    # Add the latest user message
+    messages.append({"role": "user", "content": system_message + "\n\n" + user_input})
+    try:
+        response = client.chat_completion(
+            messages=messages,
+            model="google/gemma-2-2b-it",
+            max_tokens=512,
+            temperature=1,
+            top_p=0.75
+        )
+        bot_response = ["choices"][0]["message"]["content"]
+        history.append([user_input, bot_response])
+        return bot_response, history
+
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+# Gradio Chat Interface
+demo = gr.ChatInterface(
+    fn = chat_with_musician,
+    type="messages",
+    additional_inputs=[
+        gr.Dropdown(choices=["Radiohead", "Google Gemma"],
+                    value="Radiohead",
+                    label="Select artist",
+                    info="More coming soon"),
+    ],
+    title="Lyrical Chatbot",
+)
 
-# Launch the app
+# Launch the chatbot
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()