Update app.py

app.py

@@ -356,15 +356,34 @@ Sure! Here's the information you requested:
 """
 
 
+# def generate_bot_response(history, choice, retrieval_mode, model_choice):
+#     if not history:
+#         return
+
+#     # Select the model
+#     # selected_model = chat_model if model_choice == "LM-1" else phi_pipe
+#     selected_model = chat_model if model_choice == "LM-1" else (chat_model1 if model_choice == "LM-3" else phi_pipe)
+
+
+#     response, addresses = generate_answer(history[-1][0], choice, retrieval_mode, selected_model)
+#     history[-1][1] = ""
+
+#     for character in response:
+#         history[-1][1] += character
+#         yield history  # Stream each character as it is generated
+#         time.sleep(0.05)  # Add a slight delay to simulate streaming
+
+#     yield history  # Final yield with the complete response
+
+
+# Modified bot function to separate chatbot response and TTS generation
 def generate_bot_response(history, choice, retrieval_mode, model_choice):
     if not history:
         return
 
     # Select the model
-    # selected_model = chat_model if model_choice == "LM-1" else phi_pipe
     selected_model = chat_model if model_choice == "LM-1" else (chat_model1 if model_choice == "LM-3" else phi_pipe)
 
-
     response, addresses = generate_answer(history[-1][0], choice, retrieval_mode, selected_model)
     history[-1][1] = ""
 
@@ -397,8 +416,34 @@ def generate_tts_response(response, tts_choice):
 
 
 
+# import concurrent.futures
+# # Existing bot function with concurrent futures for parallel processing
+# def bot(history, choice, tts_choice, retrieval_mode, model_choice):
+#     # Initialize an empty response
+#     response = ""
+
+#     # Create a thread pool to handle both text generation and TTS conversion in parallel
+#     with concurrent.futures.ThreadPoolExecutor() as executor:
+#         # Start the bot response generation in parallel
+#         bot_future = executor.submit(generate_bot_response, history, choice, retrieval_mode, model_choice)
+
+#         # Wait for the text generation to start
+#         for history_chunk in bot_future.result():
+#             response = history_chunk[-1][1]  # Update the response with the current state
+#             yield history_chunk, None  # Stream the text output as it's generated
+
+#         # Once text is fully generated, start the TTS conversion
+#         tts_future = executor.submit(generate_tts_response, response, tts_choice)
+
+#         # Get the audio output after TTS is done
+#         audio_path = tts_future.result()
+
+#         # Stream the final text and audio output
+#         yield history, audio_path
+
+
 import concurrent.futures
-# Existing bot function with concurrent futures for parallel processing
+
 def bot(history, choice, tts_choice, retrieval_mode, model_choice):
     # Initialize an empty response
     response = ""
@@ -452,11 +497,21 @@ def generate_bot_response(history, choice, retrieval_mode, model_choice):
 
 
 
+# def generate_audio_after_text(response, tts_choice):
+#     # Generate TTS audio after text response is completed
+#     with concurrent.futures.ThreadPoolExecutor() as executor:
+#         tts_future = executor.submit(generate_tts_response, response, tts_choice)
+#         audio_path = tts_future.result()
+#         return audio_path
+
 def generate_audio_after_text(response, tts_choice):
     # Generate TTS audio after text response is completed
     with concurrent.futures.ThreadPoolExecutor() as executor:
-        tts_future = executor.submit(generate_tts_response, response, tts_choice)
-        audio_path = tts_future.result()
+        if tts_choice == "Alpha":
+            audio_future = executor.submit(generate_audio_elevenlabs, response)
+        elif tts_choice == "Beta":
+            audio_future = executor.submit(generate_audio_parler_tts, response)  # Use the updated Parler TTS generator
+        audio_path = audio_future.result()
         return audio_path
 
 import re
@@ -895,6 +950,78 @@ def generate_audio_elevenlabs(text):
 
 # chunking audio and then Process
 
+# import concurrent.futures
+# import tempfile
+# import os
+# import numpy as np
+# import logging
+# from queue import Queue
+# from threading import Thread
+# from scipy.io.wavfile import write as write_wav
+# from parler_tts import ParlerTTSForConditionalGeneration, ParlerTTSStreamer
+# from transformers import AutoTokenizer
+
+# # Ensure your device is set to CUDA
+# device = "cuda:0" if torch.cuda.is_available() else "cpu"
+
+# repo_id = "parler-tts/parler-tts-mini-v1"
+
+# def generate_audio_parler_tts(text):
+#     description = "A female speaker delivers a slightly expressive and animated speech with a moderate speed and pitch. The recording is of very high quality, with the speaker's voice sounding clear and very close up."
+#     chunk_size_in_s = 0.5
+
+#     # Initialize the tokenizer and model
+#     parler_tokenizer = AutoTokenizer.from_pretrained(repo_id)
+#     parler_model = ParlerTTSForConditionalGeneration.from_pretrained(repo_id).to(device)
+#     sampling_rate = parler_model.audio_encoder.config.sampling_rate
+#     frame_rate = parler_model.audio_encoder.config.frame_rate
+
+#     def generate(text, description, play_steps_in_s=0.5):
+#         play_steps = int(frame_rate * play_steps_in_s)
+#         streamer = ParlerTTSStreamer(parler_model, device=device, play_steps=play_steps)
+
+#         inputs = parler_tokenizer(description, return_tensors="pt").to(device)
+#         prompt = parler_tokenizer(text, return_tensors="pt").to(device)
+
+#         generation_kwargs = dict(
+#             input_ids=inputs.input_ids,
+#             prompt_input_ids=prompt.input_ids,
+#             attention_mask=inputs.attention_mask,
+#             prompt_attention_mask=prompt.attention_mask,
+#             streamer=streamer,
+#             do_sample=True,
+#             temperature=1.0,
+#             min_new_tokens=10,
+#         )
+
+#         thread = Thread(target=parler_model.generate, kwargs=generation_kwargs)
+#         thread.start()
+
+#         for new_audio in streamer:
+#             if new_audio.shape[0] == 0:
+#                 break
+#             # Save or process each audio chunk as it is generated
+#             yield sampling_rate, new_audio
+
+#     audio_segments = []
+#     for (sampling_rate, audio_chunk) in generate(text, description, chunk_size_in_s):
+#         audio_segments.append(audio_chunk)
+
+#         temp_audio_path = os.path.join(tempfile.gettempdir(), f"parler_tts_audio_chunk_{len(audio_segments)}.wav")
+#         write_wav(temp_audio_path, sampling_rate, audio_chunk.astype(np.float32))
+#         logging.debug(f"Saved chunk to {temp_audio_path}")
+
+
+#     # Combine all the audio chunks into one audio file
+#     combined_audio = np.concatenate(audio_segments)
+#     combined_audio_path = os.path.join(tempfile.gettempdir(), "parler_tts_combined_audio_stream.wav")
+
+#     write_wav(combined_audio_path, sampling_rate, combined_audio.astype(np.float32))
+
+#     logging.debug(f"Combined audio saved to {combined_audio_path}")
+#     return combined_audio_path
+
+
 import concurrent.futures
 import tempfile
 import os
@@ -913,7 +1040,7 @@ repo_id = "parler-tts/parler-tts-mini-v1"
 
 def generate_audio_parler_tts(text):
     description = "A female speaker delivers a slightly expressive and animated speech with a moderate speed and pitch. The recording is of very high quality, with the speaker's voice sounding clear and very close up."
-    chunk_size_in_s = 0.5
+    chunk_size_in_s = 3.0  # Setting buffer size to 3 seconds
 
     # Initialize the tokenizer and model
     parler_tokenizer = AutoTokenizer.from_pretrained(repo_id)
@@ -921,7 +1048,7 @@ def generate_audio_parler_tts(text):
     sampling_rate = parler_model.audio_encoder.config.sampling_rate
     frame_rate = parler_model.audio_encoder.config.frame_rate
 
-    def generate(text, description, play_steps_in_s=0.5):
+    def generate(text, description, play_steps_in_s=3.0):
         play_steps = int(frame_rate * play_steps_in_s)
         streamer = ParlerTTSStreamer(parler_model, device=device, play_steps=play_steps)
 
@@ -956,7 +1083,6 @@ def generate_audio_parler_tts(text):
         write_wav(temp_audio_path, sampling_rate, audio_chunk.astype(np.float32))
         logging.debug(f"Saved chunk to {temp_audio_path}")
 
-
     # Combine all the audio chunks into one audio file
     combined_audio = np.concatenate(audio_segments)
     combined_audio_path = os.path.join(tempfile.gettempdir(), "parler_tts_combined_audio_stream.wav")
@@ -967,6 +1093,7 @@ def generate_audio_parler_tts(text):
     return combined_audio_path
 
 
+
 def fetch_local_events():
     api_key = os.environ['SERP_API']
     url = f'https://serpapi.com/search.json?engine=google_events&q=Events+in+Birmingham&hl=en&gl=us&api_key={api_key}'
@@ -1392,6 +1519,18 @@ with gr.Blocks(theme='Pijush2023/scikit-learn-pijush') as demo:
             #     .then(fn=clear_textbox, inputs=[], outputs=[chat_input],api_name="api_clear_textbox")
             # )
 
+            # retriever_sequence = (
+            #     retriever_button.click(fn=stop_audio, inputs=[], outputs=[audio_output], api_name="api_stop_audio_recording")
+            #     .then(fn=add_message, inputs=[chatbot, chat_input], outputs=[chatbot, chat_input], api_name="api_addprompt_chathistory")
+            #     # First, generate the bot response
+            #     .then(fn=generate_bot_response, inputs=[chatbot, choice, retrieval_mode, model_choice], outputs=[chatbot], api_name="api_generate_bot_response")
+            #     # Then, generate the TTS response based on the bot's response
+            #     .then(fn=generate_tts_response, inputs=[chatbot, tts_choice], outputs=[audio_output], api_name="api_generate_tts_response")
+            #     .then(fn=show_map_if_details, inputs=[chatbot, choice], outputs=[location_output, location_output], api_name="api_show_map_details")
+            #     .then(fn=clear_textbox, inputs=[], outputs=[chat_input], api_name="api_clear_textbox")
+            # )
+
+            # Gradio bot interaction with audio streaming
             retriever_sequence = (
                 retriever_button.click(fn=stop_audio, inputs=[], outputs=[audio_output], api_name="api_stop_audio_recording")
                 .then(fn=add_message, inputs=[chatbot, chat_input], outputs=[chatbot, chat_input], api_name="api_addprompt_chathistory")
@@ -1417,13 +1556,26 @@ with gr.Blocks(theme='Pijush2023/scikit-learn-pijush') as demo:
             #     fn=clear_textbox, inputs=[], outputs=[chat_input],api_name="api_clear_textbox"
             # )
 
+            # chat_input.submit(fn=stop_audio, inputs=[], outputs=[audio_output], api_name="api_stop_audio_recording").then(
+            #     fn=add_message, inputs=[chatbot, chat_input], outputs=[chatbot, chat_input], api_name="api_addprompt_chathistory"
+            # ).then(
+            #     # First, generate the bot response
+            #     fn=generate_bot_response, inputs=[chatbot, choice, retrieval_mode, model_choice], outputs=[chatbot], api_name="api_generate_bot_response"
+            # ).then(
+            #     # Then, generate the TTS response based on the bot's response
+            #     fn=generate_tts_response, inputs=[chatbot, tts_choice], outputs=[audio_output], api_name="api_generate_tts_response"
+            # ).then(
+            #     fn=show_map_if_details, inputs=[chatbot, choice], outputs=[location_output, location_output], api_name="api_show_map_details"
+            # ).then(
+            #     fn=clear_textbox, inputs=[], outputs=[chat_input], api_name="api_clear_textbox"
+            # )
+
+            # The same logic for chat_input submission
             chat_input.submit(fn=stop_audio, inputs=[], outputs=[audio_output], api_name="api_stop_audio_recording").then(
                 fn=add_message, inputs=[chatbot, chat_input], outputs=[chatbot, chat_input], api_name="api_addprompt_chathistory"
             ).then(
-                # First, generate the bot response
                 fn=generate_bot_response, inputs=[chatbot, choice, retrieval_mode, model_choice], outputs=[chatbot], api_name="api_generate_bot_response"
             ).then(
-                # Then, generate the TTS response based on the bot's response
                 fn=generate_tts_response, inputs=[chatbot, tts_choice], outputs=[audio_output], api_name="api_generate_tts_response"
             ).then(
                 fn=show_map_if_details, inputs=[chatbot, choice], outputs=[location_output, location_output], api_name="api_show_map_details"
@@ -1436,7 +1588,6 @@ with gr.Blocks(theme='Pijush2023/scikit-learn-pijush') as demo:
 
 
 
-
             audio_input = gr.Audio(sources=["microphone"], streaming=True, type='numpy', every=0.1)
             audio_input.stream(transcribe_function, inputs=[state, audio_input], outputs=[state, chat_input], api_name="api_voice_to_text")