now app.py

app.py

@@ -1,82 +1,236 @@
 import gradio as gr
 from huggingface_hub import InferenceClient
+from gradio_client import Client
+import os
+import uuid
+from anthropic import Anthropic
+
+from dotenv import load_dotenv, find_dotenv
+_ = load_dotenv(find_dotenv()) # read local .env file
 
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-    language,
-):
-    messages = [{"role": "system", "content": system_message}]
-
-    # Extract the language name without the flag emoji
-    language_name = language.split()[-1]
-    
-    # Add language instruction to the system message
-    language_instruction = f"Please respond in {language_name}."
-    messages[0]["content"] += " " + language_instruction
 
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
+HF_TOKEN = os.getenv('HF_TOKEN')
 
-    messages.append({"role": "user", "content": message})
+anthropic = Anthropic()
+MODEL_NAME = "claude-3-haiku-20240307"
 
-    response = ""
+# Define model parameters here
+SYSTEM_MESSAGE = "You are a friendly Chatbot, who gives short answers."
+MAX_TOKENS = 512
+TEMPERATURE = 0
+TOP_P = 0.95
 
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
+def get_completion(prompt):
+    return anthropic.messages.create(
+        model=MODEL_NAME,
+        max_tokens=MAX_TOKENS,
+        temperature=TEMPERATURE,
+        messages=[{
+            "role": 'user', "content": prompt
+        }]
+    ).content[0].text
 
-        response += token
-        yield response
+#chat_client = InferenceClient("HuggingFaceH4/zephyr-7b-beta", token="")
+tts_client = Client("xxxrokxxx/Multilingual-TTS", hf_token=HF_TOKEN)
 
-# Language options with flags
 languages = [
-    "🇺🇸 English",
-    "🇪🇸 Spanish",
-    "🇫🇷 French",
-    "🇩🇪 German",
-    "🇮🇹 Italian",
-    "🇨🇳 Chinese",
-    "🇯🇵 Japanese",
-    "🇸🇮 Slovenian",
-    "🇷🇺 Russian",
-    "🇻🇳 Vietnamese"
+    "English", "Spanish", "French", "German", "Italian",
+    "Chinese", "Japanese", "Slovenian", "Russian", "Vietnamese"
 ]
 
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-        gr.Dropdown(
-            choices=languages,
-            value="🇺🇸 English",
-            label="Language",
-        ),
-    ],
-)
+language_flags = {
+    "English": "🇬🇧", "Spanish": "🇪🇸", "French": "🇫🇷", "German": "🇩🇪", "Italian": "🇮🇹",
+    "Chinese": "🇨🇳", "Japanese": "🇯🇵", "Slovenian": "🇸🇮", "Russian": "🇷🇺", "Vietnamese": "🇻🇳"
+}
+
+def translate_text(text, from_lang, to_lang):
+    prompt = f"Translate the following text from {from_lang} to {to_lang}:\n\n{text}\n\nTranslation:"
+    return get_completion(prompt)
+
+def get_speakers(language):
+    try:
+        result = tts_client.predict(language=language, api_name="/get_speakers")
+        speakers = result[0]['choices']
+        return [speaker[0] for speaker in speakers]
+    except Exception as e:
+        print(f"Error getting speakers for {language}: {e}")
+        return ["Default"]
+
+def generate_unique_filename(extension=".wav"):
+    return str(uuid.uuid4()) + extension
+
+def to_voice(text, language, speaker):
+    try:
+        #print(f"Generating voice for text: {text[:50]}... in language: {language} with speaker: {speaker}")
+        _, audio_path = tts_client.predict(
+            text=text,
+            language_code=language,
+            speaker=speaker,
+            tashkeel_checkbox=False,
+            api_name="/text_to_speech_edge"
+        )
+        
+        #print(f"Audio generated at path: {audio_path}")
+        
+        # Create a new file with a shorter, unique name
+        new_filename = generate_unique_filename()
+        new_path = os.path.join(os.path.dirname(audio_path), new_filename)
+        os.rename(audio_path, new_path)
+        
+        print(f"Audio file renamed to: {new_path}")
+        return new_path
+    except Exception as e:
+        print(f"Error generating voice: {e}")
+        return None
+
+def respond(message, chat_history, language):
+    language_instruction = f"Please respond in {language}."
+    full_prompt = f"{SYSTEM_MESSAGE} {language_instruction}\n\nUser: {message}\nAssistant:"
+    
+    for human, ai in chat_history:
+        full_prompt += f"\n\nUser: {human}\nAssistant: {ai}"
+    
+    full_prompt += f"\n\nUser: {message}\nAssistant:"
+    
+    ai_message = get_completion(full_prompt)
+    return ai_message
+
+def print_like_dislike(x: gr.LikeData):
+    print(x.index, x.value, x.liked)
+    return x.liked
+
+def add_message(history, message, response_type):
+    history.append((message, None))
+    return history, gr.Textbox(value="", interactive=True)
+
+def bot(history, response_type, language1, language2, speaker):
+    human_message = history[-1][0]
+    ai_message = respond(human_message, history[:-1], language1)
+    
+    audio_path = None
+    if response_type in ["text + audio"]:
+        #print(f"Attempting to generate audio for response type: {response_type}")
+        
+        # If languages are different, translate before generating audio
+        if language1 != language2:
+            #print(f"Translating from {language1} to {language2}")
+            translated_message = translate_text(ai_message, language1, language2)
+            audio_text = translated_message
+        else:
+            audio_text = ai_message
+        
+        audio_path = to_voice(audio_text, language2, speaker)
+        #print(f"Audio path after generation: {audio_path}")
+    
+    history[-1] = (human_message, ai_message)
+    
+    return history, audio_path, response_type
+
+
+
+def update_speakers(language):
+    language = language.split(" ")[-1]  # Remove flag from language
+    speakers = get_speakers(language)
+    return gr.Dropdown(choices=speakers, value=speakers[0] if speakers else None, label="Speaker")
+
+custom_css = """
+.submit-btn, .play-btn {
+    background-color: transparent !important;
+    border: none !important;
+    padding: 0 !important;
+}
+.submit-btn:hover, .play-btn:hover {
+    background-color: transparent !important;
+}
+"""
+
+
+
+with gr.Blocks(css=custom_css, theme=gr.themes.Base()) as demo:
+    chatbot = gr.Chatbot(
+        elem_id="chatbot",
+        bubble_full_width=False,
+        height=400,
+        show_label=False,
+    )
+    
+    with gr.Row():
+        msg = gr.Textbox(
+            show_label=False,
+            placeholder="Enter your message...",
+            scale=9
+        )
+        submit_btn = gr.Button(
+            "➤", 
+            elem_classes=["submit-btn"],
+            scale=1
+        )
+
+    response_type = gr.Radio(
+        ["text", "text + audio"],
+        value="text",
+        label="Response Type",
+    )
+
+    with gr.Accordion("Language Selection", open=False):
+        with gr.Column():
+            gr.Markdown("### Text to Speech")
+            with gr.Row():
+                language1 = gr.Dropdown(choices=languages, label="Text Language", value="English")
+                language2 = gr.Dropdown(choices=languages, label="Speech Language", value="English")
+                initial_speakers = get_speakers("English")
+                speaker = gr.Dropdown(choices=initial_speakers, value=initial_speakers[0] if initial_speakers else None, label="Speaker")
+             
+            #gr.Markdown("### Speech to Text")
+            #with gr.Row():
+            #    language3 = gr.Dropdown(choices=languages, label="Speech Language", value="English")
+            #    language4 = gr.Dropdown(choices=languages, label="Text Language", value="English")
+
+
+
+
+    audio_visible = response_type in ["text + audio"]
+    print("Audio Visible", audio_visible)
+    audio_player = gr.Audio(label="Response Audio", visible=audio_visible, elem_id="audio-player", autoplay=True)
+    play_btn = gr.Button("🔊", elem_classes=["play-btn"], visible=False)
+
+    # Hidden components to store state
+    audio_path_state = gr.State()
+    response_type_state = gr.State()
+
+    # Event handlers
+    
+    language1.change(update_speakers, inputs=[language1], outputs=[speaker])
+    language2.change(update_speakers, inputs=[language2], outputs=[speaker])
+    
+    def process_response(history, audio_path, response_type):
+        #print(f"Processing response. Audio path: {audio_path}, Response type: {response_type}")
+        audio_visible = response_type in ["text + audio"] and audio_path is not None
+        return (
+            history,
+            audio_path if audio_visible else None,
+            audio_visible,
+            audio_path,
+            response_type
+        )
+    def play_audio(audio_path):
+        return gr.update(value=audio_path, visible=True, autoplay=True), gr.update(visible=True)
+
+    msg.submit(add_message, [chatbot, msg, response_type], [chatbot, msg]).then(
+        bot, [chatbot, response_type, language1, language2, speaker], [chatbot, audio_path_state, response_type_state]
+    ).then(
+        process_response, [chatbot, audio_path_state, response_type_state], [chatbot, audio_player, audio_path_state, response_type_state]
+    )
+
+    submit_btn.click(add_message, [chatbot, msg, response_type], [chatbot, msg]).then(
+        bot, [chatbot, response_type, language1, language2, speaker], [chatbot, audio_path_state, response_type_state]
+    ).then(
+        process_response, [chatbot, audio_path_state, response_type_state], [chatbot, audio_player, audio_path_state, response_type_state]
+    )
+
+    play_btn.click(play_audio, inputs=[audio_path_state], outputs=[audio_player, play_btn])
+
+    chatbot.like(print_like_dislike, None, None)
 
 if __name__ == "__main__":
     demo.launch()