Update app.py

app.py

@@ -3,26 +3,23 @@ import asyncio
 import base64
 import io
 import cv2
-import sounddevice as sd
 import numpy as np
 import PIL.Image
 import mss
 from google import genai
 from google.genai import types
+from pydub import AudioSegment
+from pydub.playback import play
 import soundfile as sf
 
 # Configuration
 SAMPLE_RATE = 24000
-CHUNK_SIZE = 1024
 MODEL = "models/gemini-2.0-flash-exp"
 
 class GeminiTTS:
     def __init__(self, api_key):
         self.client = genai.Client(http_options={"api_version": "v1alpha"}, api_key=api_key)
-        self.audio_in_queue = asyncio.Queue()
-        self.out_queue = asyncio.Queue(maxsize=5)
         self.session = None
-        self.audio_stream = None
         
         self.config = types.LiveConnectConfig(
             response_modalities=["audio"],
@@ -59,21 +56,6 @@ class GeminiTTS:
         image_io.seek(0)
         return {"mime_type": "image/jpeg", "data": base64.b64encode(image_io.read()).decode()}
 
-    async def record_audio(self, duration=5):
-        """Record audio using sounddevice"""
-        print(f"Recording for {duration} seconds...")
-        recording = sd.rec(int(duration * SAMPLE_RATE), 
-                          samplerate=SAMPLE_RATE, 
-                          channels=1, 
-                          dtype='float32')
-        sd.wait()  # Wait until recording is finished
-        return recording
-
-    async def play_audio(self, audio_data):
-        """Play audio using sounddevice"""
-        sd.play(audio_data, samplerate=SAMPLE_RATE)
-        sd.wait()  # Wait until playback is finished
-
     async def process_input(self, text=None, mode="text"):
         try:
             async with self.client.aio.live.connect(model=MODEL, config=self.config) as session:
@@ -96,11 +78,12 @@ class GeminiTTS:
                 turn = session.receive()
                 async for response in turn:
                     if data := response.data:
-                        # Save audio to buffer
+                        # Convert to playable audio format
+                        audio_array = np.frombuffer(data, dtype=np.float32)
                         with io.BytesIO() as wav_buffer:
-                            sf.write(wav_buffer, data, SAMPLE_RATE, format='WAV')
-                            wav_buffer.seek(0)
-                            return (SAMPLE_RATE, wav_buffer.read())
+                            sf.write(wav_buffer, audio_array, SAMPLE_RATE, format='WAV')
+                            wav_bytes = wav_buffer.getvalue()
+                        return (SAMPLE_RATE, wav_bytes)
                     if text := response.text:
                         return text
                 
@@ -119,30 +102,10 @@ def create_gradio_interface():
     async def generate_response(text, mode):
         if not tts_handler:
             raise gr.Error("Please initialize the TTS system first with your API key")
-        
-        result = await tts_handler.process_input(text, mode)
-        
-        if isinstance(result, tuple) and len(result) == 2:
-            # Audio response (sample_rate, audio_data)
-            return result
-        else:
-            # Text response
-            return result
-
-    async def record_and_process():
-        if not tts_handler:
-            raise gr.Error("Please initialize the TTS system first with your API key")
-        
-        # Record audio
-        recording = await tts_handler.record_audio(duration=5)
-        
-        # Process audio (you would need to implement this part)
-        # For now, we'll just play it back
-        await tts_handler.play_audio(recording)
-        return (SAMPLE_RATE, recording.tobytes())
+        return await tts_handler.process_input(text, mode)
 
     with gr.Blocks(title="Gemini TTS Interface") as demo:
-        gr.Markdown("# 🎤 Gemini Text-to-Speech Interface with SoundDevice")
+        gr.Markdown("# 🎤 Gemini Text-to-Speech Interface")
         
         with gr.Row():
             api_key = gr.Textbox(label="Gemini API Key", type="password")
@@ -157,22 +120,29 @@ def create_gradio_interface():
                 text_btn = gr.Button("Generate Speech")
             
             text_output = gr.Audio(label="Generated Speech")
-            text_btn.click(generate_response, inputs=[text_input, gr.Text("text", visible=False)], outputs=text_output)
-        
-        with gr.Tab("Voice Input"):
-            record_btn = gr.Button("Record and Process (5 sec)")
-            voice_output = gr.Audio(label="Processed Audio")
-            record_btn.click(record_and_process, outputs=voice_output)
+            text_btn.click(
+                generate_response, 
+                inputs=[text_input, gr.Text("text", visible=False)], 
+                outputs=text_output
+            )
         
         with gr.Tab("Camera Input"):
             camera_btn = gr.Button("Capture and Process")
             camera_output = gr.Audio(label="Generated Speech from Camera")
-            camera_btn.click(generate_response, inputs=[gr.Text("", visible=False), gr.Text("camera", visible=False)], outputs=camera_output)
+            camera_btn.click(
+                generate_response, 
+                inputs=[gr.Text("", visible=False), gr.Text("camera", visible=False)], 
+                outputs=camera_output
+            )
         
         with gr.Tab("Screen Capture"):
             screen_btn = gr.Button("Capture Screen and Process")
             screen_output = gr.Audio(label="Generated Speech from Screen")
-            screen_btn.click(generate_response, inputs=[gr.Text("", visible=False), gr.Text("screen", visible=False)], outputs=screen_output)
+            screen_btn.click(
+                generate_response, 
+                inputs=[gr.Text("", visible=False), gr.Text("screen", visible=False)], 
+                outputs=screen_output
+            )
     
     return demo