Fix: Initial runtime errors with integration

index.html

@@ -18,11 +18,11 @@
         <button id="stopButton" disabled>Stop Translation</button>
     </div>
     <p id="status">Status: Not connected</p>
-
+    <div id="log"></div>
     <script>
         const startButton = document.getElementById('startButton');
         const stopButton = document.getElementById('stopButton');
-        const statusDiv = document.getElementById('status');
+        const statusDiv = document.getElementById('status'); // Corrected from status to statusDiv
         let socket;
         let mediaRecorder;
         let audioContext;
@@ -31,10 +31,12 @@
 
         const connectWebSocket = () => {
             const proto = window.location.protocol === "https:" ? "wss:" : "ws:";
-            socket = new WebSocket(`${proto}//${window.location.host}/ws`);
+            const wsUri = `${proto}//${window.location.host}/ws`;
+            statusDiv.textContent = `Status: Connecting to ${wsUri}...`;
+            socket = new WebSocket(wsUri);
 
             socket.onopen = () => {
-                statusDiv.textContent = 'Status: Connected. Press Start.';
+                statusDiv.textContent = 'Status: Connected. Ready to start.';
                 startButton.disabled = false;
             };
 
@@ -43,7 +45,9 @@
                     const reader = new FileReader();
                     reader.onload = function() {
                         const arrayBuffer = this.result;
-                        audioContext.decodeAudioData(arrayBuffer, (buffer) => {
+                        // Ensure audioContext is initialized before decoding
+                        if (audioContext) {
+                            audioContext.decodeAudioData(arrayBuffer, (buffer) => {
                             audioQueue.push(buffer);
                             if (!isPlaying) {
                                 playNextInQueue();
@@ -51,13 +55,18 @@
                         });
                     };
                     reader.readAsArrayBuffer(event.data);
+                } else {
+                    // Handle text messages from server (e.g., for logging)
+                    const logElement = document.createElement('p');
+                    logElement.textContent = event.data;
+                    document.getElementById('log').prepend(logElement);
                 }
             };
 
             socket.onclose = () => {
                 statusDiv.textContent = 'Status: Disconnected';
-                startButton.disabled = true;
-                stopButton.disabled = true;
+                startButton.disabled = false; // Allow user to try starting again
+                stopButton.disabled = true; 
             };
 
             socket.onerror = (error) => {
@@ -81,15 +90,11 @@
             }
         };
 
-
         startButton.onclick = async () => {
-            if (!socket || socket.readyState !== WebSocket.OPEN) {
-                connectWebSocket();
-            }
-
-            audioContext = new (window.AudioContext || window.webkitAudioContext)({ sampleRate: 16000 });
-
-            if (audioContext.state === 'suspended') {
+            // AudioContext must be resumed by a user gesture.
+            if (!audioContext) {
+                audioContext = new (window.AudioContext || window.webkitAudioContext)({ sampleRate: 16000 });
+            } else if (audioContext.state === 'suspended') {
                 await audioContext.resume();
             }
 
@@ -117,19 +122,17 @@
             if (mediaRecorder) {
                 mediaRecorder.stop();
             }
-            if (socket && socket.readyState === WebSocket.OPEN) {
-                socket.send(JSON.stringify({type: "stop"}));
-                socket.close();
-            }
+            // Don't close the socket, just stop sending data.
+            // The user might want to start and stop multiple times in one session.
             startButton.disabled = false;
             stopButton.disabled = true;
-            statusDiv.textContent = 'Status: Stopped. Re-connect to start again.';
+            statusDiv.textContent = 'Status: Stopped. Press Start to translate again.';
         };
 
         window.onload = () => {
-            startButton.disabled = false;
+            startButton.disabled = true;
             stopButton.disabled = true;
-            statusDiv.textContent = 'Status: Ready to connect.';
+            connectWebSocket(); // Connect automatically on page load
         };
 
     </script>

requirements.txt

@@ -4,5 +4,4 @@ websockets
 python-dotenv
 fastapi
 uvicorn
-python-multipart
 ffmpeg-python

server.py

@@ -61,7 +61,7 @@ async def handle_audio_input(websocket: WebSocket, input_queue: asyncio.Queue):
     print("Audio input handler stopped.")
 
 
-@app.websocket("/ws")
+@app.websocket("/ws") # This was correct, the error was in the old HTML. No change needed here, but confirming it's /ws.
 async def websocket_endpoint(websocket: WebSocket):
     await websocket.accept()
     print("WebSocket connection accepted.")

working.py

@@ -1,334 +0,0 @@
-"""
-Real-Time French/English Voice Translator - FIXED VERSION v4.2
-Improvements:
- - Removed noisy [audio_gen]/[tts] prints
- - Added TTS pre-buffer to eliminate start bursts
- - Added silence-based auto-finalization when no STT final detected
- - Switched to "latest_long" model for better segmentation
- - Added echo suppression (skip self-spoken TTS text)
-"""
-
-import asyncio
-import json
-import queue
-import threading
-import time
-from typing import Optional, Dict, List
-import pyaudio
-import websockets
-from google.cloud import speech
-import deepl
-import os
-from dotenv import load_dotenv
-import base64
-
-
-class VoiceTranslator:
-    def __init__(self, deepl_api_key: str, elevenlabs_api_key: str, elevenlabs_voice_id: str):
-        self.stt_client = speech.SpeechClient()
-        self.deepl_client = deepl.Translator(deepl_api_key)
-        self.elevenlabs_api_key = elevenlabs_api_key
-        self.voice_id = elevenlabs_voice_id
-
-        self.audio_rate = 16000
-        self.audio_chunk = 1024
-
-        self.audio_queue_en = queue.Queue()
-        self.audio_queue_fr = queue.Queue()
-        self.result_queue = queue.Queue()
-        self.is_recording = False
-        self.processing_lock = threading.Lock()
-
-        self.last_processed_transcript = ""
-        self.last_tts_text = ""
-
-        self.pyaudio_instance = pyaudio.PyAudio()
-        self.audio_stream = None
-
-    # ---------- AUDIO CAPTURE ----------
-
-    def _audio_generator(self, audio_queue: queue.Queue):
-        while self.is_recording:
-            try:
-                chunk = audio_queue.get(timeout=0.2)
-                if chunk:
-                    yield chunk
-            except queue.Empty:
-                continue
-
-    def _record_audio(self):
-        try:
-            stream = self.pyaudio_instance.open(
-                format=pyaudio.paInt16,
-                channels=1,
-                rate=self.audio_rate,
-                input=True,
-                frames_per_buffer=self.audio_chunk,
-            )
-            print("🎤 Recording started...")
-            while self.is_recording:
-                try:
-                    data = stream.read(self.audio_chunk, exception_on_overflow=False)
-                    if not data:
-                        continue
-                    self.audio_queue_en.put(data)
-                    self.audio_queue_fr.put(data)
-                except Exception as e:
-                    print(f"[recorder] error: {e}")
-                    break
-            stream.stop_stream()
-            stream.close()
-            print("🎤 Recording stopped.")
-        except Exception as e:
-            print(f"[recorder] fatal: {e}")
-
-    # ---------- TEXT TO SPEECH ----------
-
-    async def _stream_tts(self, text: str):
-        """Stream TTS with small pre-buffer to smooth playback."""
-        uri = (
-            f"wss://api.elevenlabs.io/v1/text-to-speech/{self.voice_id}"
-            f"/stream-input?model_id=eleven_flash_v2_5&output_format=pcm_16000"
-        )
-
-        try:
-            async with websockets.connect(uri) as websocket:
-                await websocket.send(json.dumps({
-                    "text": " ",
-                    "voice_settings": {"stability": 0.5, "similarity_boost": 0.8},
-                    "xi_api_key": self.elevenlabs_api_key,
-                }))
-                await websocket.send(json.dumps({"text": text, "try_trigger_generation": True}))
-                await websocket.send(json.dumps({"text": ""}))
-
-                if self.audio_stream is None:
-                    self.audio_stream = self.pyaudio_instance.open(
-                        format=pyaudio.paInt16,
-                        channels=1,
-                        rate=16000,
-                        output=True,
-                        frames_per_buffer=1024,
-                    )
-
-                prebuffer = bytearray()
-                playback_started = False
-                last_chunk_time = time.time()
-
-                async for message in websocket:
-                    if isinstance(message, bytes):
-                        prebuffer.extend(message)
-                        # Start playback after ~0.5 s of audio buffered
-                        if not playback_started and len(prebuffer) >= 16000:
-                            self.audio_stream.write(bytes(prebuffer))
-                            prebuffer.clear()
-                            playback_started = True
-                        elif playback_started:
-                            self.audio_stream.write(message)
-                        last_chunk_time = time.time()
-                        continue
-
-                    try:
-                        data = json.loads(message)
-                    except Exception:
-                        continue
-
-                    if data.get("audio"):
-                        audio_bytes = base64.b64decode(data["audio"])
-                        prebuffer.extend(audio_bytes)
-                        if not playback_started and len(prebuffer) >= 16000:
-                            self.audio_stream.write(bytes(prebuffer))
-                            prebuffer.clear()
-                            playback_started = True
-                        elif playback_started:
-                            self.audio_stream.write(audio_bytes)
-                        last_chunk_time = time.time()
-                    elif data.get("isFinal"):
-                        break
-                    elif data.get("error"):
-                        print("TTS error:", data["error"])
-                        break
-
-                if prebuffer:
-                    self.audio_stream.write(bytes(prebuffer))
-        except Exception as e:
-            print(f"[tts] error: {e}")
-
-    # ---------- TRANSLATION ----------
-
-    async def _process_result(self, transcript: str, confidence: Optional[float], language: str):
-        lang_flag = "🇫🇷" if language == "fr-FR" else "🇬🇧"
-        conf_display = f"{confidence:.2f}" if confidence is not None else "n/a"
-        print(f"{lang_flag} Heard ({language}, conf {conf_display}): {transcript}")
-
-        # Simple echo suppression
-        if transcript.strip().lower() == self.last_tts_text.strip().lower():
-            return
-
-        try:
-            if language == "fr-FR":
-                translated = self.deepl_client.translate_text(transcript, target_lang="EN-US").text
-                print(f"🌐 FR → EN: {translated}")
-            else:
-                translated = self.deepl_client.translate_text(transcript, target_lang="FR").text
-                print(f"🌐 EN → FR: {translated}")
-
-            self.last_tts_text = translated
-            print("🔊 Speaking...")
-            await self._stream_tts(translated)
-            print("✅ Done\n")
-
-        except Exception as e:
-            print(f"Translation error: {e}")
-
-    # ---------- STT STREAMING ----------
-
-    def _run_stt_stream(self, language: str, audio_queue: queue.Queue):
-        print(f"[stt] Thread start for {language}")
-
-        config = speech.RecognitionConfig(
-            encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16,
-            sample_rate_hertz=self.audio_rate,
-            language_code=language,
-            enable_automatic_punctuation=True,
-            model="latest_long",
-        )
-
-        streaming_config = speech.StreamingRecognitionConfig(
-            config=config, interim_results=True, single_utterance=False
-        )
-
-        def requests():
-            for content in self._audio_generator(audio_queue):
-                yield speech.StreamingRecognizeRequest(audio_content=content)
-
-        try:
-            responses = self.stt_client.streaming_recognize(streaming_config, requests())
-
-            last_update_time = time.time()
-            current_text = ""
-            for response in responses:
-                if not self.is_recording:
-                    break
-                if not response.results:
-                    continue
-
-                for result in response.results:
-                    if not result.alternatives:
-                        continue
-                    alt = result.alternatives[0]
-                    transcript = alt.transcript.strip()
-                    conf = getattr(alt, "confidence", None)
-                    current_text = transcript
-                    last_update_time = time.time()
-
-                    self.result_queue.put({
-                        "transcript": transcript,
-                        "confidence": conf,
-                        "language": language,
-                        "is_final": bool(result.is_final),
-                    })
-
-                # If we haven’t heard anything new for 1.2 s, flush it as “final”
-                if time.time() - last_update_time > 1.2 and current_text:
-                    self.result_queue.put({
-                        "transcript": current_text,
-                        "confidence": 0.5,
-                        "language": language,
-                        "is_final": True,
-                    })
-                    current_text = ""
-
-        except Exception as e:
-            print(f"[stt:{language}] exception: {e}")
-
-    # ---------- RESULT AGGREGATION ----------
-
-    async def _process_results_queue(self):
-        while self.is_recording:
-            try:
-                r = self.result_queue.get(timeout=0.2)
-                if r["is_final"] and r["transcript"] != self.last_processed_transcript:
-                    with self.processing_lock:
-                        self.last_processed_transcript = r["transcript"]
-                        await self._process_result(
-                            r["transcript"], r.get("confidence"), r["language"]
-                        )
-                await asyncio.sleep(0.01)
-            except queue.Empty:
-                await asyncio.sleep(0.05)
-            except Exception as e:
-                print("Queue error:", e)
-                await asyncio.sleep(0.1)
-
-    # ---------- CONTROL ----------
-
-    async def _run_dual_streams(self):
-        print("🔄 Dual-stream: English ⇄ French\n")
-        en_thread = threading.Thread(target=self._run_stt_stream, args=("en-US", self.audio_queue_en), daemon=True)
-        fr_thread = threading.Thread(target=self._run_stt_stream, args=("fr-FR", self.audio_queue_fr), daemon=True)
-        en_thread.start()
-        fr_thread.start()
-        await self._process_results_queue()
-
-    def start_translation(self):
-        if self.is_recording:
-            print("Already recording!")
-            return
-        self.is_recording = True
-        self.last_processed_transcript = ""
-        while not self.result_queue.empty():
-            try: self.result_queue.get_nowait()
-            except: break
-        threading.Thread(target=self._record_audio, daemon=True).start()
-        try:
-            asyncio.run(self._run_dual_streams())
-        except KeyboardInterrupt:
-            self.stop_translation()
-
-    def stop_translation(self):
-        print("\n⏹️  Stopping translation...")
-        self.is_recording = False
-        if self.audio_stream:
-            try:
-                self.audio_stream.stop_stream()
-                self.audio_stream.close()
-            except Exception:
-                pass
-            self.audio_stream = None
-
-    def cleanup(self):
-        self.stop_translation()
-        try:
-            self.pyaudio_instance.terminate()
-        except Exception:
-            pass
-
-
-# ---------- MAIN ----------
-
-def main():
-    load_dotenv()
-    google_creds = os.getenv("GOOGLE_APPLICATION_CREDENTIALS")
-    deepl_key = os.getenv("DEEPL_API_KEY")
-    eleven_key = os.getenv("ELEVENLABS_API_KEY")
-    voice_id = os.getenv("ELEVENLABS_VOICE_ID")
-
-    if not all([google_creds, deepl_key, eleven_key, voice_id]):
-        print("Missing API keys or credentials.")
-        return
-
-    translator = VoiceTranslator(deepl_key, eleven_key, voice_id)
-    print("Ready! Press ENTER to start, ENTER again to stop, Ctrl+C to quit.\n")
-
-    try:
-        while True:
-            input("Press ENTER to start speaking...")
-            threading.Thread(target=translator.start_translation, daemon=True).start()
-            input("Press ENTER to stop...\n")
-            translator.stop_translation()
-    except KeyboardInterrupt:
-        translator.cleanup()
-
-
-if __name__ == "__main__":
-    main()