Update app.py

app.py

@@ -722,9 +722,8 @@ def generate_audio_elevenlabs(text):
         return None
 
 
-# Parler TTS integration
-
 repo_id = "parler-tts/parler-tts-mini-v1"
+
 parler_model = ParlerTTSForConditionalGeneration.from_pretrained(repo_id).to(device)
 parler_tokenizer = AutoTokenizer.from_pretrained(repo_id)
 parler_feature_extractor = AutoFeatureExtractor.from_pretrained(repo_id)
@@ -792,200 +791,6 @@ def generate_audio_parler_tts(text):
     logging.debug(f"Audio saved to {combined_audio_path}")
     return combined_audio_path
 
-# Streaming Parler-TTS with the Base Streamer
-
-import io
-import math
-from queue import Queue
-from threading import Thread
-from typing import Optional
-
-from transformers.generation.streamers import BaseStreamer
-
-class ParlerTTSStreamer(BaseStreamer):
-    def __init__(
-        self,
-        model: ParlerTTSForConditionalGeneration,
-        device: Optional[str] = None,
-        play_steps: Optional[int] = 10,
-        stride: Optional[int] = None,
-        timeout: Optional[float] = None,
-    ):
-        self.decoder = model.decoder
-        self.audio_encoder = model.audio_encoder
-        self.generation_config = model.generation_config
-        self.device = device if device is not None else model.device
-
-        self.play_steps = play_steps
-        if stride is not None:
-            self.stride = stride
-        else:
-            hop_length = math.floor(self.audio_encoder.config.sampling_rate / self.audio_encoder.config.frame_rate)
-            self.stride = hop_length * (play_steps - self.decoder.num_codebooks) // 6
-        self.token_cache = None
-        self.to_yield = 0
-
-        self.audio_queue = Queue()
-        self.stop_signal = None
-        self.timeout = timeout
-
-    def apply_delay_pattern_mask(self, input_ids):
-        _, delay_pattern_mask = self.decoder.build_delay_pattern_mask(
-            input_ids[:, :1],
-            bos_token_id=self.generation_config.bos_token_id,
-            pad_token_id=self.generation_config.decoder_start_token_id,
-            max_length=input_ids.shape[-1],
-        )
-        input_ids = self.decoder.apply_delay_pattern_mask(input_ids, delay_pattern_mask)
-
-        mask = (delay_pattern_mask != self.generation_config.bos_token_id) & (delay_pattern_mask != self.generation_config.pad_token_id)
-        input_ids = input_ids[mask].reshape(1, self.decoder.num_codebooks, -1)
-        input_ids = input_ids[None, ...]
-
-        input_ids = input_ids.to(self.audio_encoder.device)
-
-        decode_sequentially = (
-            self.generation_config.bos_token_id in input_ids
-            or self.generation_config.pad_token_id in input_ids
-            or self.generation_config.eos_token_id in input_ids
-        )
-        if not decode_sequentially:
-            output_values = self.audio_encoder.decode(
-                input_ids,
-                audio_scales=[None],
-            )
-        else:
-            sample = input_ids[:, 0]
-            sample_mask = (sample >= self.audio_encoder.config.codebook_size).sum(dim=(0, 1)) == 0
-            sample = sample[:, :, sample_mask]
-            output_values = self.audio_encoder.decode(sample[None, ...], [None])
-
-        audio_values = output_values.audio_values[0, 0]
-        return audio_values.cpu().float().numpy()
-
-    def put(self, value):
-        batch_size = value.shape[0] // self.decoder.num_codebooks
-        if batch_size > 1:
-            raise ValueError("ParlerTTSStreamer only supports batch size 1")
-
-        if self.token_cache is None:
-            self.token_cache = value
-        else:
-            self.token_cache = torch.concatenate([self.token_cache, value[:, None]], dim=-1)
-
-        if self.token_cache.shape[-1] % self.play_steps == 0:
-            audio_values = self.apply_delay_pattern_mask(self.token_cache)
-            self.on_finalized_audio(audio_values[self.to_yield : -self.stride])
-            self.to_yield += len(audio_values) - self.to_yield - self.stride
-
-    def end(self):
-        if self.token_cache is not None:
-            audio_values = self.apply_delay_pattern_mask(self.token_cache)
-        else:
-            audio_values = np.zeros(self.to_yield)
-
-        self.on_finalized_audio(audio_values[self.to_yield :], stream_end=True)
-
-    def on_finalized_audio(self, audio: np.ndarray, stream_end: bool = False):
-        self.audio_queue.put(audio, timeout=self.timeout)
-        if stream_end:
-            self.audio_queue.put(self.stop_signal, timeout=self.timeout)
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        value = self.audio_queue.get(timeout=self.timeout)
-        if not isinstance(value, np.ndarray) and value == self.stop_signal:
-            raise StopIteration()
-        else:
-            return value
-
-def numpy_to_mp3(audio_array, sampling_rate):
-    if np.issubdtype(audio_array.dtype, np.floating):
-        max_val = np.max(np.abs(audio_array))
-        audio_array = (audio_array / max_val) * 32767
-        audio_array = audio_array.astype(np.int16)
-
-    audio_segment = AudioSegment(
-        audio_array.tobytes(),
-        frame_rate=sampling_rate,
-        sample_width=audio_array.dtype.itemsize,
-        channels=1
-    )
-
-    mp3_io = io.BytesIO()
-    audio_segment.export(mp3_io, format="mp3", bitrate="320k")
-
-    mp3_bytes = mp3_io.getvalue()
-    mp3_io.close()
-
-    return mp3_bytes
-
-sampling_rate = model.audio_encoder.config.sampling_rate
-frame_rate = model.audio_encoder.config.frame_rate
-
-def generate_base(text, description, play_steps_in_s=2.0):
-    play_steps = int(frame_rate * play_steps_in_s)
-    streamer = ParlerTTSStreamer(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,
-        streamer=streamer,
-        do_sample=True,
-        temperature=1.0,
-        min_new_tokens=10,
-    )
-
-    set_seed(SEED)
-    thread = Thread(target=model.generate, kwargs=generation_kwargs)
-    thread.start()
-
-    for new_audio in streamer:
-        print(f"Sample of length: {round(new_audio.shape[0] / sampling_rate, 2)} seconds")
-        yield numpy_to_mp3(new_audio, sampling_rate=sampling_rate)
-
-css = """
-        #share-btn-container {
-            display: flex;
-            padding-left: 0.5rem !important;
-            padding-right: 0.5rem !important;
-            background-color: #000000;
-            justify-content: center;
-            align-items: center;
-            border-radius: 9999px !important; 
-            width: 13rem;
-            margin-top: 10px;
-            margin-left: auto;
-            flex: unset !important;
-        }
-        #share-btn {
-            all: initial;
-            color: #ffffff;
-            font-weight: 600;
-            cursor: pointer;
-            font-family: 'IBM Plex Sans', sans-serif;
-            margin-left: 0.5rem !important;
-            padding-top: 0.25rem !important;
-            padding-bottom: 0.25rem !important;
-            right:0;
-        }
-        #share-btn * {
-            all: unset !important;
-        }
-        #share-btn-container div:nth-child(-n+2){
-            width: auto !important;
-            min-height: 0px !important;
-        }
-        #share-btn-container .wrap {
-            display: none !important;
-        }
-"""
-
 
 
 
@@ -1325,136 +1130,11 @@ def fetch_google_flights(departure_id="JFK", arrival_id="BHM", outbound_date=cur
     
     return flight_info
 
-# with gr.Blocks(theme='Pijush2023/scikit-learn-pijush') as demo:
-#     with gr.Row():
-#         with gr.Column():
-#             state = gr.State()
-
-#             chatbot = gr.Chatbot([], elem_id="RADAR:Channel 94.1", bubble_full_width=False)
-#             choice = gr.Radio(label="Select Style", choices=["Details", "Conversational"], value="Conversational")
-#             retrieval_mode = gr.Radio(label="Retrieval Mode", choices=["VDB", "KGF"], value="VDB")
-#             model_choice = gr.Dropdown(label="Choose Model", choices=["GPT-4o", "Phi-3.5"], value="GPT-4o")
-            
-            
-#             # Link the dropdown change to handle_retrieval_mode_change
-#             model_choice.change(fn=handle_retrieval_mode_change, inputs=model_choice, outputs=[retrieval_mode, choice])
-
-
-#             gr.Markdown("<h1 style='color: red;'>Talk to RADAR</h1>", elem_id="voice-markdown")
-
-#             chat_input = gr.Textbox(show_copy_button=True, interactive=True, show_label=False, label="ASK Radar !!!", placeholder="Hey Radar...!!")
-#             tts_choice = gr.Radio(label="Select TTS System", choices=["Alpha", "Beta"], value="Alpha")
-#             retriever_button = gr.Button("Retriever")
-
-#             clear_button = gr.Button("Clear")
-#             clear_button.click(lambda:[None,None], outputs=[chat_input, state])
-
-#             gr.Markdown("<h1 style='color: red;'>Radar Map</h1>", elem_id="Map-Radar")
-#             location_output = gr.HTML()
-#             audio_output = gr.Audio(interactive=False, autoplay=True)
-
-#             def stop_audio():
-#                 audio_output.stop()
-#                 return None
-
-#             retriever_sequence = (
-#                 retriever_button.click(fn=stop_audio, inputs=[], outputs=[audio_output], api_name="Ask_Retriever")
-#                 .then(fn=add_message, inputs=[chatbot, chat_input], outputs=[chatbot, chat_input], api_name="voice_query")
-#                 .then(fn=bot, inputs=[chatbot, choice, tts_choice, retrieval_mode, model_choice], outputs=[chatbot, audio_output], api_name="generate_voice_response")
-#                 .then(fn=show_map_if_details, inputs=[chatbot, choice], outputs=[location_output, location_output], api_name="map_finder")
-#                 .then(fn=clear_textbox, inputs=[], outputs=[chat_input])
-#             )
-
-#             chat_input.submit(fn=stop_audio, inputs=[], outputs=[audio_output])
-#             chat_input.submit(fn=add_message, inputs=[chatbot, chat_input], outputs=[chatbot, chat_input], api_name="voice_query").then(
-#                 fn=bot, inputs=[chatbot, choice, tts_choice, retrieval_mode, model_choice], outputs=[chatbot, audio_output], api_name="generate_voice_response"
-#             ).then(
-#                 fn=show_map_if_details, inputs=[chatbot, choice], outputs=[location_output, location_output], api_name="map_finder"
-#             ).then(
-#                 fn=clear_textbox, inputs=[], outputs=[chat_input]
-#             )
-
-#             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="voice_query_to_text")
-
-#             # retrieval_mode.change(fn=handle_retrieval_mode_change, inputs=retrieval_mode, outputs=[choice, choice])
-#             model_choice.change(fn=handle_retrieval_mode_change, inputs=model_choice, outputs=[choice, retrieval_mode])
-
-
-#         # with gr.Column():
-#         #     weather_output = gr.HTML(value=fetch_local_weather())
-#         #     news_output = gr.HTML(value=fetch_local_news())
-#         #     events_output = gr.HTML(value=fetch_local_events())
-
-      
 
-# demo.queue()
-# demo.launch(share=True)
 
 
 
-# with gr.Blocks(theme='Pijush2023/scikit-learn-pijush') as demo:
-#     with gr.Row():
-#         with gr.Column():
-#             state = gr.State()
-
-#             chatbot = gr.Chatbot([], elem_id="RADAR:Channel 94.1", bubble_full_width=False)
-#             choice = gr.Radio(label="Select Style", choices=["Details", "Conversational"], value="Conversational")
-#             retrieval_mode = gr.Radio(label="Retrieval Mode", choices=["VDB", "KGF"], value="VDB")
-#             model_choice = gr.Dropdown(label="Choose Model", choices=["GPT-4o", "Phi-3.5"], value="GPT-4o")
-
-#             # Link the dropdown change to handle_model_choice_change
-#             model_choice.change(fn=handle_model_choice_change, inputs=model_choice, outputs=[retrieval_mode, choice, choice])
-
-#             gr.Markdown("<h1 style='color: red;'>Talk to RADAR</h1>", elem_id="voice-markdown")
-
-#             chat_input = gr.Textbox(show_copy_button=True, interactive=True, show_label=False, label="ASK Radar !!!", placeholder="Hey Radar...!!")
-#             tts_choice = gr.Radio(label="Select TTS System", choices=["Alpha", "Beta"], value="Alpha")
-#             retriever_button = gr.Button("Retriever")
-
-#             clear_button = gr.Button("Clear")
-#             clear_button.click(lambda: [None, None], outputs=[chat_input, state])
-
-#             gr.Markdown("<h1 style='color: red;'>Radar Map</h1>", elem_id="Map-Radar")
-#             location_output = gr.HTML()
-#             audio_output = gr.Audio(interactive=False, autoplay=True)
-
-#             def stop_audio():
-#                 audio_output.stop()
-#                 return None
-
-#             retriever_sequence = (
-#                 retriever_button.click(fn=stop_audio, inputs=[], outputs=[audio_output], api_name="Ask_Retriever")
-#                 .then(fn=add_message, inputs=[chatbot, chat_input], outputs=[chatbot, chat_input], api_name="voice_query")
-#                 .then(fn=bot, inputs=[chatbot, choice, tts_choice, retrieval_mode, model_choice], outputs=[chatbot, audio_output], api_name="generate_voice_response")
-#                 .then(fn=show_map_if_details, inputs=[chatbot, choice], outputs=[location_output, location_output], api_name="map_finder")
-#                 .then(fn=clear_textbox, inputs=[], outputs=[chat_input])
-#             )
-
-#             chat_input.submit(fn=stop_audio, inputs=[], outputs=[audio_output])
-#             chat_input.submit(fn=add_message, inputs=[chatbot, chat_input], outputs=[chatbot, chat_input], api_name="voice_query").then(
-#                 fn=bot, inputs=[chatbot, choice, tts_choice, retrieval_mode, model_choice], outputs=[chatbot, audio_output], api_name="generate_voice_response"
-#             ).then(
-#                 fn=show_map_if_details, inputs=[chatbot, choice], outputs=[location_output, location_output], api_name="map_finder"
-#             ).then(
-#                 fn=clear_textbox, inputs=[], outputs=[chat_input]
-#             )
-
-#             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="voice_query_to_text")
-
-#         # with gr.Column():
-#         #     weather_output = gr.HTML(value=fetch_local_weather())
-#         #     news_output = gr.HTML(value=fetch_local_news())
-#         #     events_output = gr.HTML(value=fetch_local_events())
-
-# demo.queue()
-# demo.launch(share=True)
-
-
-
-
-with gr.Blocks(theme='Pijush2023/scikit-learn-pijush', css=css) as demo:
+with gr.Blocks(theme='Pijush2023/scikit-learn-pijush') as demo:
     with gr.Row():
         with gr.Column():
             state = gr.State()
@@ -1464,6 +1144,7 @@ with gr.Blocks(theme='Pijush2023/scikit-learn-pijush', css=css) as demo:
             retrieval_mode = gr.Radio(label="Retrieval Mode", choices=["VDB", "KGF"], value="VDB")
             model_choice = gr.Dropdown(label="Choose Model", choices=["GPT-4o", "Phi-3.5"], value="GPT-4o")
 
+            # Link the dropdown change to handle_model_choice_change
             model_choice.change(fn=handle_model_choice_change, inputs=model_choice, outputs=[retrieval_mode, choice, choice])
 
             gr.Markdown("<h1 style='color: red;'>Talk to RADAR</h1>", elem_id="voice-markdown")
@@ -1479,6 +1160,10 @@ with gr.Blocks(theme='Pijush2023/scikit-learn-pijush', css=css) as demo:
             location_output = gr.HTML()
             audio_output = gr.Audio(interactive=False, autoplay=True)
 
+            def stop_audio():
+                audio_output.stop()
+                return None
+
             retriever_sequence = (
                 retriever_button.click(fn=stop_audio, inputs=[], outputs=[audio_output], api_name="Ask_Retriever")
                 .then(fn=add_message, inputs=[chatbot, chat_input], outputs=[chatbot, chat_input], api_name="voice_query")
@@ -1499,20 +1184,10 @@ with gr.Blocks(theme='Pijush2023/scikit-learn-pijush', css=css) 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="voice_query_to_text")
 
-        with gr.Column():
-            with gr.Tab("Base"):
-                with gr.Row():
-                    with gr.Column():
-                        input_text = gr.Textbox(label="Input Text", lines=2, value="Please surprise me and speak in whatever voice you enjoy.", elem_id="input_text")
-                        description = gr.Textbox(label="Description", lines=2, value="", elem_id="input_description")
-                        play_seconds = gr.Slider(3.0, 7.0, value=3.0, step=2, label="Streaming interval in seconds", info="Lower = shorter chunks, lower latency, more codec steps")
-                        run_button = gr.Button("Generate Audio", variant="primary")
-                    with gr.Column():
-                        audio_out = gr.Audio(label="Parler-TTS generation", format="mp3", elem_id="audio_out", streaming=True, autoplay=True)
-
-                inputs = [input_text, description, play_seconds]
-                outputs = [audio_out]
-                run_button.click(fn=generate_base, inputs=inputs, outputs=outputs, queue=True)
+        # with gr.Column():
+        #     weather_output = gr.HTML(value=fetch_local_weather())
+        #     news_output = gr.HTML(value=fetch_local_news())
+        #     events_output = gr.HTML(value=fetch_local_events())
 
 demo.queue()
 demo.launch(share=True)