RealTimeSTT 0.3.101__tar.gz → 0.3.103__tar.gz

{realtimestt-0.3.101/realtimestt.egg-info → realtimestt-0.3.103}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: realtimestt
-Version: 0.3.101
+Version: 0.3.103
 Summary: A fast Voice Activity Detection and Transcription System
 Home-page: https://github.com/KoljaB/RealTimeSTT
 Author: Kolja Beigel

{realtimestt-0.3.101 → realtimestt-0.3.103}/RealtimeSTT/audio_recorder.py

@@ -34,6 +34,7 @@ from scipy.signal import resample
 import signal as system_signal
 from ctypes import c_bool
 from scipy import signal
+from .safepipe import SafePipe
 import soundfile as sf
 import faster_whisper
 import openwakeword
@@ -93,7 +94,7 @@ if platform.system() != 'Darwin':
 class TranscriptionWorker:
     def __init__(self, conn, stdout_pipe, model_path, download_root, compute_type, gpu_device_index, device,
                  ready_event, shutdown_event, interrupt_stop_event, beam_size, initial_prompt, suppress_tokens,
-                 batch_size, faster_whisper_vad_filter):
+                 batch_size, faster_whisper_vad_filter, normalize_audio):
         self.conn = conn
         self.stdout_pipe = stdout_pipe
         self.model_path = model_path
@@ -109,6 +110,7 @@ class TranscriptionWorker:
         self.suppress_tokens = suppress_tokens
         self.batch_size = batch_size
         self.faster_whisper_vad_filter = faster_whisper_vad_filter
+        self.normalize_audio = normalize_audio
         self.queue = queue.Queue()
 
     def custom_print(self, *args, **kwargs):
@@ -120,13 +122,16 @@ class TranscriptionWorker:
 
     def poll_connection(self):
         while not self.shutdown_event.is_set():
-            if self.conn.poll(0.01):
-                try:
+            try:
+                # Use a longer timeout to reduce polling frequency
+                if self.conn.poll(0.01):  # Increased from 0.01 to 0.5 seconds
                     data = self.conn.recv()
                     self.queue.put(data)
-                except Exception as e:
-                    logging.error(f"Error receiving data from connection: {e}", exc_info=True)
-            else:
+                else:
+                    # Sleep only if no data, but use a shorter sleep
+                    time.sleep(TIME_SLEEP)
+            except Exception as e:
+                logging.error(f"Error receiving data from connection: {e}", exc_info=True)
                 time.sleep(TIME_SLEEP)
 
     def run(self):
@@ -170,15 +175,32 @@ class TranscriptionWorker:
         try:
             while not self.shutdown_event.is_set():
                 try:
-                    audio, language = self.queue.get(timeout=0.1)
+                    audio, language, use_prompt = self.queue.get(timeout=0.1)
                     try:
                         logging.debug(f"Transcribing audio with language {language}")
+                        start_t = time.time()
+
+                        # normalize audio to -0.95 dBFS
+                        if audio is not None and audio .size > 0:
+                            if self.normalize_audio:
+                                peak = np.max(np.abs(audio))
+                                if peak > 0:
+                                    audio = (audio / peak) * 0.95
+                        else:
+                            logging.error("Received None audio for transcription")
+                            self.conn.send(('error', "Received None audio for transcription"))
+                            continue
+
+                        prompt = None
+                        if use_prompt:
+                            prompt = self.initial_prompt if self.initial_prompt else None
+
                         if self.batch_size > 0:
                             segments, info = model.transcribe(
                                 audio,
                                 language=language if language else None,
                                 beam_size=self.beam_size,
-                                initial_prompt=self.initial_prompt,
+                                initial_prompt=prompt,
                                 suppress_tokens=self.suppress_tokens,
                                 batch_size=self.batch_size, 
                                 vad_filter=self.faster_whisper_vad_filter
@@ -188,13 +210,13 @@ class TranscriptionWorker:
                                 audio,
                                 language=language if language else None,
                                 beam_size=self.beam_size,
-                                initial_prompt=self.initial_prompt,
+                                initial_prompt=prompt,
                                 suppress_tokens=self.suppress_tokens,
                                 vad_filter=self.faster_whisper_vad_filter
                             )
-
+                        elapsed = time.time() - start_t
                         transcription = " ".join(seg.text for seg in segments).strip()
-                        logging.debug(f"Final text detected with main model: {transcription}")
+                        logging.debug(f"Final text detected with main model: {transcription} in {elapsed:.4f}s")
                         self.conn.send(('success', (transcription, info)))
                     except Exception as e:
                         logging.error(f"General error in transcription: {e}", exc_info=True)
@@ -277,6 +299,8 @@ class AudioToTextRecorder:
                  on_vad_stop=None,
                  on_vad_detect_start=None,
                  on_vad_detect_stop=None,
+                 on_turn_detection_start=None,
+                 on_turn_detection_stop=None,
 
                  # Wake word parameters
                  wakeword_backend: str = "",
@@ -309,6 +333,7 @@ class AudioToTextRecorder:
                  no_log_file: bool = False,
                  use_extended_logging: bool = False,
                  faster_whisper_vad_filter: bool = True,
+                 normalize_audio: bool = False,
                  ):
         """
         Initializes an audio recorder and  transcription
@@ -436,6 +461,14 @@ class AudioToTextRecorder:
             called when the system stops listening for voice activity. This is
             not called when VAD actually stops (use on_vad_stop for this), but
             when the system stops listening for it.
+        - on_turn_detection_start (callable, default=None): Callback function
+            to be called when the system starts to listen for a turn of speech.
+        - on_turn_detection_stop (callable, default=None): Callback function to
+            be called when the system stops listening for a turn of speech.
+        - wakeword_backend (str, default=""): Specifies the backend library to
+            use for wake word detection. Supported options include 'pvporcupine'
+            for using the Porcupine wake word engine or 'oww' for using the
+            OpenWakeWord engine.
         - wakeword_backend (str, default="pvporcupine"): Specifies the backend
             library to use for wake word detection. Supported options include
             'pvporcupine' for using the Porcupine wake word engine or 'oww' for
@@ -530,6 +563,9 @@ class AudioToTextRecorder:
             the system will additionally use the VAD filter from the faster_whisper library
             for voice activity detection. This filter is more robust against
             background noise but requires additional GPU resources.
+        - normalize_audio (bool, default=False): If set to True, the system will
+            normalize the audio to a specific range before processing. This can
+            help improve the quality of the transcription.
 
         Raises:
             Exception: Errors related to initializing transcription
@@ -564,6 +600,8 @@ class AudioToTextRecorder:
         self.on_vad_stop = on_vad_stop
         self.on_vad_detect_start = on_vad_detect_start
         self.on_vad_detect_stop = on_vad_detect_stop
+        self.on_turn_detection_start = on_turn_detection_start
+        self.on_turn_detection_stop = on_turn_detection_stop
         self.on_wakeword_detection_start = on_wakeword_detection_start
         self.on_wakeword_detection_end = on_wakeword_detection_end
         self.on_recorded_chunk = on_recorded_chunk
@@ -641,6 +679,7 @@ class AudioToTextRecorder:
         self.early_transcription_on_silence = early_transcription_on_silence
         self.use_extended_logging = use_extended_logging
         self.faster_whisper_vad_filter = faster_whisper_vad_filter
+        self.normalize_audio = normalize_audio
         self.awaiting_speech_end = False
 
         # ----------------------------------------------------------------------------
@@ -687,8 +726,9 @@ class AudioToTextRecorder:
         self.interrupt_stop_event = mp.Event()
         self.was_interrupted = mp.Event()
         self.main_transcription_ready_event = mp.Event()
-        self.parent_transcription_pipe, child_transcription_pipe = mp.Pipe()
-        self.parent_stdout_pipe, child_stdout_pipe = mp.Pipe()
+
+        self.parent_transcription_pipe, child_transcription_pipe = SafePipe()
+        self.parent_stdout_pipe, child_stdout_pipe = SafePipe()
 
         # Set device for model
         self.device = "cuda" if self.device == "cuda" and torch.cuda.is_available() else "cpu"
@@ -711,6 +751,7 @@ class AudioToTextRecorder:
                 self.suppress_tokens,
                 self.batch_size,
                 self.faster_whisper_vad_filter,
+                self.normalize_audio,
             )
         )
 
@@ -784,7 +825,7 @@ class AudioToTextRecorder:
                 for _ in range(len(self.wake_words_list))
             ]
 
-            if self.wakeword_backend in {'pvp', 'pvporcupine'}:
+            if wake_words and self.wakeword_backend in {'pvp', 'pvporcupine'}:
 
                 try:
                     self.porcupine = pvporcupine.create(
@@ -797,7 +838,8 @@ class AudioToTextRecorder:
                 except Exception as e:
                     logger.exception(
                         "Error initializing porcupine "
-                        f"wake word detection engine: {e}"
+                        f"wake word detection engine: {e}. "
+                        f"Wakewords: {self.wake_words_list}."
                     )
                     raise
 
@@ -805,7 +847,7 @@ class AudioToTextRecorder:
                     "Porcupine wake word detection engine initialized successfully"
                 )
 
-            elif self.wakeword_backend in {'oww', 'openwakeword', 'openwakewords'}:
+            elif wake_words and self.wakeword_backend in {'oww', 'openwakeword', 'openwakewords'}:
                     
                 openwakeword.utils.download_models()
 
@@ -848,7 +890,7 @@ class AudioToTextRecorder:
                 )
             
             else:
-                logger.exception(f"Wakeword engine {self.wakeword_backend} unknown/unsupported. Please specify one of: pvporcupine, openwakeword.")
+                logger.exception(f"Wakeword engine {self.wakeword_backend} unknown/unsupported or wake_words not specified. Please specify one of: pvporcupine, openwakeword.")
 
 
         # Setup voice activity detection model WebRTC
@@ -972,6 +1014,10 @@ class AudioToTextRecorder:
         worker = TranscriptionWorker(*args, **kwargs)
         worker.run()
 
+    def _run_callback(self, cb, *args, **kwargs):
+        if cb:
+            threading.Thread(target=cb, args=args, kwargs=kwargs, daemon=True).start()
+
     @staticmethod
     def _audio_data_worker(
         audio_queue,
@@ -1441,14 +1487,22 @@ class AudioToTextRecorder:
             raise  # Re-raise the exception after cleanup
 
 
-    def perform_final_transcription(self, audio_bytes=None):
+    def perform_final_transcription(self, audio_bytes=None, use_prompt=True):
         start_time = 0
         with self.transcription_lock:
+            if audio_bytes is None:
+                audio_bytes = copy.deepcopy(self.audio)
+
+            if audio_bytes is None or len(audio_bytes) == 0:
+                print("No audio data available for transcription")
+                #logger.info("No audio data available for transcription")
+                return ""
+
             try:
                 if self.transcribe_count == 0:
                     logger.debug("Adding transcription request, no early transcription started")
                     start_time = time.time()  # Start timing
-                    self.parent_transcription_pipe.send((audio_bytes, self.language))
+                    self.parent_transcription_pipe.send((audio_bytes, self.language, use_prompt))
                     self.transcribe_count += 1
 
                 while self.transcribe_count > 0:
@@ -1651,7 +1705,7 @@ class AudioToTextRecorder:
         self.start_recording_event.set()
 
         if self.on_recording_start:
-            self.on_recording_start()
+            self._run_callback(self.on_recording_start)
 
         return self
 
@@ -1695,7 +1749,7 @@ class AudioToTextRecorder:
         self.last_recording_stop_time = self.recording_stop_time
 
         if self.on_recording_stop:
-            self.on_recording_stop()
+            self._run_callback(self.on_recording_stop)
 
         return self
 
@@ -1870,7 +1924,7 @@ class AudioToTextRecorder:
                     if self.on_recorded_chunk:
                         if self.use_extended_logging:
                             logger.debug('Debug: Calling on_recorded_chunk')
-                        self.on_recorded_chunk(data)
+                        self._run_callback(self.on_recorded_chunk, data)
 
                     if self.use_extended_logging:
                         logger.debug('Debug: Checking if handle_buffer_overflow is True')
@@ -1940,7 +1994,7 @@ class AudioToTextRecorder:
                             if self.on_wakeword_timeout:
                                 if self.use_extended_logging:
                                     logger.debug('Debug: Calling on_wakeword_timeout')
-                                self.on_wakeword_timeout()
+                                self._run_callback(self.on_wakeword_timeout)
                     delay_was_passed = wake_word_activation_delay_passed
 
                     if self.use_extended_logging:
@@ -1993,7 +2047,7 @@ class AudioToTextRecorder:
                             if self.on_wakeword_detected:
                                 if self.use_extended_logging:
                                     logger.debug('Debug: Calling on_wakeword_detected')
-                                self.on_wakeword_detected()
+                                self._run_callback(self.on_wakeword_detected)
 
                     if self.use_extended_logging:
                         logger.debug('Debug: Checking voice activity conditions')
@@ -2010,7 +2064,7 @@ class AudioToTextRecorder:
                         if self._is_voice_active():
 
                             if self.on_vad_start:
-                               self.on_vad_start()
+                               self._run_callback(self.on_vad_start)
 
                             if self.use_extended_logging:
                                 logger.debug('Debug: Voice activity detected')
@@ -2040,7 +2094,13 @@ class AudioToTextRecorder:
 
                     if self.use_extended_logging:
                         logger.debug('Debug: Resetting speech_end_silence_start')
-                    self.speech_end_silence_start = 0
+
+                    if self.speech_end_silence_start != 0:
+                        self.speech_end_silence_start = 0
+                        if self.on_turn_detection_stop:
+                            if self.use_extended_logging:
+                                logger.debug('Debug: Calling on_turn_detection_stop')
+                            self._run_callback(self.on_turn_detection_stop)
 
                 else:
                     if self.use_extended_logging:
@@ -2097,6 +2157,11 @@ class AudioToTextRecorder:
 
                                 self.speech_end_silence_start = time.time()
                                 self.awaiting_speech_end = True
+                                if self.on_turn_detection_start:
+                                    if self.use_extended_logging:
+                                        logger.debug('Debug: Calling on_turn_detection_start')
+
+                                    self._run_callback(self.on_turn_detection_start)
 
                             if self.use_extended_logging:
                                 logger.debug('Debug: Checking early transcription conditions')
@@ -2111,7 +2176,7 @@ class AudioToTextRecorder:
 
                                     if self.use_extended_logging:
                                         logger.debug("Debug: early transcription request pipe send")
-                                    self.parent_transcription_pipe.send((audio, self.language))
+                                    self.parent_transcription_pipe.send((audio, self.language, True))
                                     if self.use_extended_logging:
                                         logger.debug("Debug: early transcription request pipe send return")
                                     self.allowed_to_early_transcribe = False
@@ -2123,7 +2188,14 @@ class AudioToTextRecorder:
                             if self.speech_end_silence_start:
                                 if self.use_extended_logging:
                                     logger.info("Resetting self.speech_end_silence_start")
-                                self.speech_end_silence_start = 0
+
+                                if self.speech_end_silence_start != 0:
+                                    self.speech_end_silence_start = 0
+                                    if self.on_turn_detection_stop:
+                                        if self.use_extended_logging:
+                                            logger.debug('Debug: Calling on_turn_detection_stop')
+                                        self._run_callback(self.on_turn_detection_stop)
+
                                 self.allowed_to_early_transcribe = True
 
                         if self.use_extended_logging:
@@ -2134,7 +2206,7 @@ class AudioToTextRecorder:
                                 self.post_speech_silence_duration:
 
                             if self.on_vad_stop:
-                                self.on_vad_stop()
+                                self._run_callback(self.on_vad_stop)
 
                             if self.use_extended_logging:
                                 logger.debug('Debug: Formatting silence start time')
@@ -2155,9 +2227,12 @@ class AudioToTextRecorder:
                             self.frames.append(data)
                             self.stop()
                             if not self.is_recording:
-                                if self.use_extended_logging:
-                                    logger.debug('Debug: Resetting speech_end_silence_start')
-                                self.speech_end_silence_start = 0
+                                if self.speech_end_silence_start != 0:
+                                    self.speech_end_silence_start = 0
+                                    if self.on_turn_detection_stop:
+                                        if self.use_extended_logging:
+                                            logger.debug('Debug: Calling on_turn_detection_stop')
+                                        self._run_callback(self.on_turn_detection_stop)
 
                                 if self.use_extended_logging:
                                     logger.debug('Debug: Handling non-wake word scenario')
@@ -2192,7 +2267,7 @@ class AudioToTextRecorder:
                     if self.wakeword_detected and self.on_wakeword_timeout:
                         if self.use_extended_logging:
                             logger.debug('Debug: Calling on_wakeword_timeout')
-                        self.on_wakeword_timeout()
+                        self._run_callback(self.on_wakeword_timeout)
                     self.wakeword_detected = False
 
                 if self.use_extended_logging:
@@ -2283,7 +2358,7 @@ class AudioToTextRecorder:
                     if self.use_main_model_for_realtime:
                         with self.transcription_lock:
                             try:
-                                self.parent_transcription_pipe.send((audio_array, self.language))
+                                self.parent_transcription_pipe.send((audio_array, self.language, True))
                                 if self.parent_transcription_pipe.poll(timeout=5):  # Wait for 5 seconds
                                     logger.debug("Receive from realtime worker after transcription request to main model")
                                     status, result = self.parent_transcription_pipe.recv()
@@ -2304,6 +2379,13 @@ class AudioToTextRecorder:
                                 continue
                     else:
                         # Perform transcription and assemble the text
+                        if self.normalize_audio:
+                            # normalize audio to -0.95 dBFS
+                            if audio_array is not None and audio_array.size > 0:
+                                peak = np.max(np.abs(audio_array))
+                                if peak > 0:
+                                    audio_array = (audio_array / peak) * 0.95
+
                         if self.realtime_batch_size > 0:
                             segments, info = self.realtime_model_type.transcribe(
                                 audio_array,
@@ -2372,20 +2454,17 @@ class AudioToTextRecorder:
                             )
 
                         if matching_pos < 0:
-                            if self.realtime_stabilized_safetext:
-                                self._on_realtime_transcription_stabilized(
-                                    self._preprocess_output(
-                                        self.realtime_stabilized_safetext,
-                                        True
-                                    )
-                                )
-                            else:
-                                self._on_realtime_transcription_stabilized(
-                                    self._preprocess_output(
-                                        self.realtime_transcription_text,
-                                        True
-                                    )
-                                )
+                            # pick which text to send
+                            text_to_send = (
+                                self.realtime_stabilized_safetext
+                                if self.realtime_stabilized_safetext
+                                else self.realtime_transcription_text
+                            )
+                            # preprocess once
+                            processed = self._preprocess_output(text_to_send, True)
+                            # invoke on its own thread
+                            self._run_callback(self._on_realtime_transcription_stabilized, processed)
+
                         else:
                             # We found parts of the stabilized text
                             # in the transcripted text
@@ -2398,17 +2477,10 @@ class AudioToTextRecorder:
                             # AND at the same time delivers fresh detected
                             # parts on the first run without the need for
                             # two transcriptions
-                            self._on_realtime_transcription_stabilized(
-                                self._preprocess_output(output_text, True)
-                                )
+                            self._run_callback(self._on_realtime_transcription_stabilized, self._preprocess_output(output_text, True))
 
                         # Invoke the callback with the transcribed text
-                        self._on_realtime_transcription_update(
-                            self._preprocess_output(
-                                self.realtime_transcription_text,
-                                True
-                            )
-                        )
+                        self._run_callback(self._on_realtime_transcription_update, self._preprocess_output(self.realtime_transcription_text,True))
 
                 # If not recording, sleep briefly before checking again
                 else:
@@ -2572,21 +2644,21 @@ class AudioToTextRecorder:
         # Execute callbacks based on transitioning FROM a particular state
         if old_state == "listening":
             if self.on_vad_detect_stop:
-                self.on_vad_detect_stop()
+                self._run_callback(self.on_vad_detect_stop)
         elif old_state == "wakeword":
             if self.on_wakeword_detection_end:
-                self.on_wakeword_detection_end()
+                self._run_callback(self.on_wakeword_detection_end)
 
         # Execute callbacks based on transitioning TO a particular state
         if new_state == "listening":
             if self.on_vad_detect_start:
-                self.on_vad_detect_start()
+                self._run_callback(self.on_vad_detect_start)
             self._set_spinner("speak now")
             if self.spinner and self.halo:
                 self.halo._interval = 250
         elif new_state == "wakeword":
             if self.on_wakeword_detection_start:
-                self.on_wakeword_detection_start()
+                self._run_callback(self.on_wakeword_detection_start)
             self._set_spinner(f"say {self.wake_words}")
             if self.spinner and self.halo:
                 self.halo._interval = 500
@@ -2709,7 +2781,7 @@ class AudioToTextRecorder:
         """
         if self.on_realtime_transcription_stabilized:
             if self.is_recording:
-                self.on_realtime_transcription_stabilized(text)
+                self._run_callback(self.on_realtime_transcription_stabilized, text)
 
     def _on_realtime_transcription_update(self, text):
         """
@@ -2727,7 +2799,7 @@ class AudioToTextRecorder:
         """
         if self.on_realtime_transcription_update:
             if self.is_recording:
-                self.on_realtime_transcription_update(text)
+                self._run_callback(self.on_realtime_transcription_update, text)
 
     def __enter__(self):
         """

{realtimestt-0.3.101 → realtimestt-0.3.103}/RealtimeSTT/audio_recorder_client.py

@@ -6,13 +6,13 @@ from urllib.parse import urlparse
 from datetime import datetime
 from websocket import WebSocketApp
 from websocket import ABNF
+import numpy as np
 import subprocess
 import threading
 import platform
 import logging
-import socket
 import struct
-import signal
+import base64
 import wave
 import json
 import time
@@ -60,6 +60,23 @@ class bcolors:
     BOLD = '\033[1m'
     UNDERLINE = '\033[4m'
 
+def format_timestamp_ns(timestamp_ns: int) -> str:
+    # Split into whole seconds and the nanosecond remainder
+    seconds = timestamp_ns // 1_000_000_000
+    remainder_ns = timestamp_ns % 1_000_000_000
+
+    # Convert seconds part into a datetime object (local time)
+    dt = datetime.fromtimestamp(seconds)
+
+    # Format the main time as HH:MM:SS
+    time_str = dt.strftime("%H:%M:%S")
+
+    # For instance, if you want milliseconds, divide the remainder by 1e6 and format as 3-digit
+    milliseconds = remainder_ns // 1_000_000
+    formatted_timestamp = f"{time_str}.{milliseconds:03d}"
+
+    return formatted_timestamp
+
 class AudioToTextRecorderClient:
     """
     A class responsible for capturing audio from the microphone, detecting
@@ -112,8 +129,12 @@ class AudioToTextRecorderClient:
                  pre_recording_buffer_duration: float = (
                      INIT_PRE_RECORDING_BUFFER_DURATION
                  ),
+                 on_vad_start=None,
+                 on_vad_stop=None,
                  on_vad_detect_start=None,
                  on_vad_detect_stop=None,
+                 on_turn_detection_start=None,
+                 on_turn_detection_stop=None,
 
                  # Wake word parameters
                  wakeword_backend: str = "pvporcupine",
@@ -151,6 +172,7 @@ class AudioToTextRecorderClient:
                  data_url: str = DEFAULT_DATA_URL,
                  autostart_server: bool = True,
                  output_wav_file: str = None,
+                 faster_whisper_vad_filter: bool = False,
                  ):
 
         # Set instance variables from constructor parameters
@@ -190,8 +212,13 @@ class AudioToTextRecorderClient:
         self.min_length_of_recording = min_length_of_recording
         self.min_gap_between_recordings = min_gap_between_recordings
         self.pre_recording_buffer_duration = pre_recording_buffer_duration
+
+        self.on_vad_start = on_vad_start
+        self.on_vad_stop = on_vad_stop
         self.on_vad_detect_start = on_vad_detect_start
         self.on_vad_detect_stop = on_vad_detect_stop
+        self.on_turn_detection_start = on_turn_detection_start
+        self.on_turn_detection_stop = on_turn_detection_stop
 
         # Wake word parameters
         self.wakeword_backend = wakeword_backend
@@ -221,6 +248,7 @@ class AudioToTextRecorderClient:
         self.allowed_latency_limit = allowed_latency_limit
         self.no_log_file = no_log_file
         self.use_extended_logging = use_extended_logging
+        self.faster_whisper_vad_filter = faster_whisper_vad_filter
 
         # Server URLs
         self.control_url = control_url
@@ -315,12 +343,24 @@ class AudioToTextRecorderClient:
             print(f"Error in AudioToTextRecorderClient.text(): {e}")
             return ""
 
-    def feed_audio(self, chunk, original_sample_rate=16000):
+    def feed_audio(self, chunk, audio_meta_data, original_sample_rate=16000):
+        # Start with the base metadata
         metadata = {"sampleRate": original_sample_rate}
+
+        # Merge additional metadata if provided
+        if audio_meta_data:
+            server_sent_to_stt_ns = time.time_ns()
+            audio_meta_data["server_sent_to_stt"] = server_sent_to_stt_ns
+            metadata["server_sent_to_stt_formatted"] = format_timestamp_ns(server_sent_to_stt_ns)
+
+            metadata.update(audio_meta_data)
+
+        # Convert metadata to JSON and prepare the message
         metadata_json = json.dumps(metadata)
         metadata_length = len(metadata_json)
         message = struct.pack('<I', metadata_length) + metadata_json.encode('utf-8') + chunk
 
+        # Send the message if the connection is running
         if self.is_running:
             self.data_ws.send(message, opcode=ABNF.OPCODE_BINARY)
 
@@ -339,6 +379,9 @@ class AudioToTextRecorderClient:
     def clear_audio_queue(self):
         self.call_method("clear_audio_queue")
 
+    def perform_final_transcription(self):
+        self.call_method("perform_final_transcription")
+
     def stop(self):
         self.call_method("stop")
 
@@ -424,8 +467,8 @@ class AudioToTextRecorderClient:
         #     args += ['--allowed_latency_limit', str(self.allowed_latency_limit)]
         # if self.no_log_file:
         #     args.append('--no_log_file')  # flag, no need for True
-        # if self.debug_mode:
-        #     args.append('--debug')  # flag, no need for True/False
+        if self.debug_mode:
+            args.append('--debug')  # flag, no need for True/False
             
         if self.language:
             args += ['--language', self.language]
@@ -668,14 +711,36 @@ class AudioToTextRecorderClient:
                 if self.on_recording_stop:
                     self.on_recording_stop()
             elif data.get('type') == 'transcription_start':
+                audio_bytes_base64 = data.get('audio_bytes_base64')
+                decoded_bytes = base64.b64decode(audio_bytes_base64)
+
+                # Reconstruct the np.int16 array from the decoded bytes
+                audio_array = np.frombuffer(decoded_bytes, dtype=np.int16)
+
+                # If the original data was normalized, convert to np.float32 and normalize
+                INT16_MAX_ABS_VALUE = 32768.0
+                normalized_audio = audio_array.astype(np.float32) / INT16_MAX_ABS_VALUE
+
                 if self.on_transcription_start:
-                    self.on_transcription_start()
+                    self.on_transcription_start(normalized_audio)
             elif data.get('type') == 'vad_detect_start':
                 if self.on_vad_detect_start:
                     self.on_vad_detect_start()
             elif data.get('type') == 'vad_detect_stop':
                 if self.on_vad_detect_stop:
                     self.on_vad_detect_stop()
+            elif data.get('type') == 'vad_start':
+                if self.on_vad_start:
+                    self.on_vad_start()
+            elif data.get('type') == 'vad_stop':
+                if self.on_vad_stop:
+                    self.on_vad_stop()
+            elif data.get('type') == 'start_turn_detection':
+                if self.on_turn_detection_start:
+                    self.on_turn_detection_start()
+            elif data.get('type') == 'stop_turn_detection':
+                if self.on_turn_detection_stop:
+                    self.on_turn_detection_stop()
             elif data.get('type') == 'wakeword_detected':
                 if self.on_wakeword_detected:
                     self.on_wakeword_detected()

realtimestt-0.3.103/RealtimeSTT/safepipe.py

@@ -0,0 +1,245 @@
+import sys
+import multiprocessing as mp
+import queue
+import threading
+import time
+import logging
+
+# Configure logging. Adjust level and formatting as needed.
+# logging.basicConfig(level=logging.DEBUG,
+#                     format='[%(asctime)s] %(levelname)s:%(name)s: %(message)s')
+logger = logging.getLogger(__name__)
+
+try:
+    # Only set the start method if it hasn't been set already.
+    if sys.platform.startswith('linux') or sys.platform == 'darwin':  # For Linux or macOS
+        mp.set_start_method("spawn")
+    elif mp.get_start_method(allow_none=True) is None:
+        mp.set_start_method("spawn")
+except RuntimeError as e:
+    logger.debug("Start method has already been set. Details: %s", e)
+
+
+class ParentPipe:
+    """
+    A thread-safe wrapper around the 'parent end' of a multiprocessing pipe.
+    All actual pipe operations happen in a dedicated worker thread, so it's safe
+    for multiple threads to call send(), recv(), or poll() on the same ParentPipe
+    without interfering.
+    """
+    def __init__(self, parent_synthesize_pipe):
+        self.name = "ParentPipe"
+        self._pipe = parent_synthesize_pipe  # The raw pipe.
+        self._closed = False  # A flag to mark if close() has been called.
+
+        # The request queue for sending operations to the worker.
+        self._request_queue = queue.Queue()
+
+        # This event signals the worker thread to stop.
+        self._stop_event = threading.Event()
+
+        # Worker thread that executes actual .send(), .recv(), .poll() calls.
+        self._worker_thread = threading.Thread(
+            target=self._pipe_worker,
+            name=f"{self.name}_Worker",
+            daemon=True
+        )
+        self._worker_thread.start()
+
+    def _pipe_worker(self):
+        while not self._stop_event.is_set():
+            try:
+                request = self._request_queue.get(timeout=0.1)
+            except queue.Empty:
+                continue
+
+            if request["type"] == "CLOSE":
+                # Exit worker loop on CLOSE request.
+                break
+
+            try:
+                if request["type"] == "SEND":
+                    data = request["data"]
+                    logger.debug("[%s] Worker: sending => %s", self.name, data)
+                    self._pipe.send(data)
+                    request["result_queue"].put(None)
+
+                elif request["type"] == "RECV":
+                    logger.debug("[%s] Worker: receiving...", self.name)
+                    data = self._pipe.recv()
+                    request["result_queue"].put(data)
+
+                elif request["type"] == "POLL":
+                    timeout = request.get("timeout", 0.0)
+                    logger.debug("[%s] Worker: poll() with timeout: %s", self.name, timeout)
+                    result = self._pipe.poll(timeout)
+                    request["result_queue"].put(result)
+
+            except (EOFError, BrokenPipeError, OSError) as e:
+                # When the other end has closed or an error occurs,
+                # log and notify the waiting thread.
+                logger.debug("[%s] Worker: pipe closed or error occurred (%s). Shutting down.", self.name, e)
+                request["result_queue"].put(None)
+                break
+
+            except Exception as e:
+                logger.exception("[%s] Worker: unexpected error.", self.name)
+                request["result_queue"].put(e)
+                break
+
+        logger.debug("[%s] Worker: stopping.", self.name)
+        try:
+            self._pipe.close()
+        except Exception as e:
+            logger.debug("[%s] Worker: error during pipe close: %s", self.name, e)
+
+    def send(self, data):
+        """
+        Synchronously asks the worker thread to perform .send().
+        """
+        if self._closed:
+            logger.debug("[%s] send() called but pipe is already closed", self.name)
+            return
+        logger.debug("[%s] send() requested with: %s", self.name, data)
+        result_queue = queue.Queue()
+        request = {
+            "type": "SEND",
+            "data": data,
+            "result_queue": result_queue
+        }
+        self._request_queue.put(request)
+        result_queue.get()  # Wait until sending completes.
+        logger.debug("[%s] send() completed", self.name)
+
+    def recv(self):
+        """
+        Synchronously asks the worker to perform .recv() and returns the data.
+        """
+        if self._closed:
+            logger.debug("[%s] recv() called but pipe is already closed", self.name)
+            return None
+        logger.debug("[%s] recv() requested", self.name)
+        result_queue = queue.Queue()
+        request = {
+            "type": "RECV",
+            "result_queue": result_queue
+        }
+        self._request_queue.put(request)
+        data = result_queue.get()
+
+        # Log a preview for huge byte blobs.
+        if isinstance(data, tuple) and len(data) == 2 and isinstance(data[1], bytes):
+            data_preview = (data[0], f"<{len(data[1])} bytes>")
+        else:
+            data_preview = data
+        logger.debug("[%s] recv() returning => %s", self.name, data_preview)
+        return data
+
+    def poll(self, timeout=0.0):
+        """
+        Synchronously checks whether data is available.
+        Returns True if data is ready, or False otherwise.
+        """
+        if self._closed:
+            return False
+        logger.debug("[%s] poll() requested with timeout: %s", self.name, timeout)
+        result_queue = queue.Queue()
+        request = {
+            "type": "POLL",
+            "timeout": timeout,
+            "result_queue": result_queue
+        }
+        self._request_queue.put(request)
+        try:
+            # Use a slightly longer timeout to give the worker a chance.
+            result = result_queue.get(timeout=timeout + 0.1)
+        except queue.Empty:
+            result = False
+        logger.debug("[%s] poll() returning => %s", self.name, result)
+        return result
+
+    def close(self):
+        """
+        Closes the pipe and stops the worker thread. The _closed flag makes
+        sure no further operations are attempted.
+        """
+        if self._closed:
+            return
+        logger.debug("[%s] close() called", self.name)
+        self._closed = True
+        stop_request = {"type": "CLOSE", "result_queue": queue.Queue()}
+        self._request_queue.put(stop_request)
+        self._stop_event.set()
+        self._worker_thread.join()
+        logger.debug("[%s] closed", self.name)
+
+
+def SafePipe(debug=False):
+    """
+    Returns a pair: (thread-safe parent pipe, raw child pipe).
+    """
+    parent_synthesize_pipe, child_synthesize_pipe = mp.Pipe()
+    parent_pipe = ParentPipe(parent_synthesize_pipe)
+    return parent_pipe, child_synthesize_pipe
+
+
+def child_process_code(child_end):
+    """
+    Example child process code that receives messages, logs them,
+    sends acknowledgements, and then closes.
+    """
+    for i in range(3):
+        msg = child_end.recv()
+        logger.debug("[Child] got: %s", msg)
+        child_end.send(f"ACK: {msg}")
+    child_end.close()
+
+
+if __name__ == "__main__":
+    parent_pipe, child_pipe = SafePipe()
+
+    # Create child process with the child_process_code function.
+    p = mp.Process(target=child_process_code, args=(child_pipe,))
+    p.start()
+
+    # Event to signal sender threads to stop if needed.
+    stop_polling_event = threading.Event()
+
+    def sender_thread(n):
+        try:
+            parent_pipe.send(f"hello_from_thread_{n}")
+        except Exception as e:
+            logger.debug("[sender_thread_%s] send exception: %s", n, e)
+            return
+
+        # Use a poll loop with error handling.
+        for _ in range(10):
+            try:
+                if parent_pipe.poll(0.1):
+                    reply = parent_pipe.recv()
+                    logger.debug("[sender_thread_%s] got: %s", n, reply)
+                    break
+                else:
+                    logger.debug("[sender_thread_%s] no data yet...", n)
+            except (OSError, EOFError, BrokenPipeError) as e:
+                logger.debug("[sender_thread_%s] poll/recv exception: %s. Exiting thread.", n, e)
+                break
+
+            # Allow exit if a shutdown is signaled.
+            if stop_polling_event.is_set():
+                logger.debug("[sender_thread_%s] stop event set. Exiting thread.", n)
+                break
+
+    threads = []
+    for i in range(3):
+        t = threading.Thread(target=sender_thread, args=(i,))
+        t.start()
+        threads.append(t)
+
+    for t in threads:
+        t.join()
+
+    # Signal shutdown to any polling threads, then close the pipe.
+    stop_polling_event.set()
+    parent_pipe.close()
+    p.join()

{realtimestt-0.3.101 → realtimestt-0.3.103}/RealtimeSTT_server/stt_server.py

@@ -64,6 +64,7 @@ stt-server [OPTIONS]
     - `--handle_buffer_overflow`: Handle buffer overflow during transcription.
     - `--suppress_tokens`: Suppress tokens during transcription.
     - `--allowed_latency_limit`: Allowed latency limit for real-time transcription.
+    - `--faster_whisper_vad_filter`: Enable VAD filter for Faster Whisper; default False.
 
 
 ### WebSocket Interface:
@@ -81,6 +82,7 @@ from datetime import datetime
 import logging
 import asyncio
 import pyaudio
+import base64
 import sys
 
 
@@ -185,6 +187,9 @@ allowed_parameters = [
     'recording_stop_time',
     'last_transcription_bytes',
     'last_transcription_bytes_b64',
+    'speech_end_silence_start',
+    'is_recording',
+    'use_wake_words',
 ]
 
 # Queues and connections for control and data
@@ -222,6 +227,23 @@ def debug_print(message):
         thread_name = threading.current_thread().name
         print(f"{Fore.CYAN}[DEBUG][{timestamp}][{thread_name}] {message}{Style.RESET_ALL}", file=sys.stderr)
 
+def format_timestamp_ns(timestamp_ns: int) -> str:
+    # Split into whole seconds and the nanosecond remainder
+    seconds = timestamp_ns // 1_000_000_000
+    remainder_ns = timestamp_ns % 1_000_000_000
+
+    # Convert seconds part into a datetime object (local time)
+    dt = datetime.fromtimestamp(seconds)
+
+    # Format the main time as HH:MM:SS
+    time_str = dt.strftime("%H:%M:%S")
+
+    # For instance, if you want milliseconds, divide the remainder by 1e6 and format as 3-digit
+    milliseconds = remainder_ns // 1_000_000
+    formatted_timestamp = f"{time_str}.{milliseconds:03d}"
+
+    return formatted_timestamp
+
 def text_detected(text, loop):
     global prev_text
 
@@ -332,11 +354,28 @@ def on_wakeword_detection_end(loop):
     asyncio.run_coroutine_threadsafe(audio_queue.put(message), loop)
 
 def on_transcription_start(_audio_bytes, loop):
+    bytes_b64 = base64.b64encode(_audio_bytes.tobytes()).decode('utf-8')
+    message = json.dumps({
+        'type': 'transcription_start',
+        'audio_bytes_base64': bytes_b64
+    })
+    asyncio.run_coroutine_threadsafe(audio_queue.put(message), loop)
+
+def on_turn_detection_start(loop):
+    print("&&& stt_server on_turn_detection_start")
+    message = json.dumps({
+        'type': 'start_turn_detection'
+    })
+    asyncio.run_coroutine_threadsafe(audio_queue.put(message), loop)
+
+def on_turn_detection_stop(loop):
+    print("&&& stt_server on_turn_detection_stop")
     message = json.dumps({
-        'type': 'transcription_start'
+        'type': 'stop_turn_detection'
     })
     asyncio.run_coroutine_threadsafe(audio_queue.put(message), loop)
 
+
 # def on_realtime_transcription_update(text, loop):
 #     # Send real-time transcription updates to the client
 #     text = preprocess_text(text)
@@ -385,6 +424,8 @@ def parse_arguments():
 
     parser.add_argument('-D', '--debug', action='store_true', help='Enable debug logging for detailed server operations')
 
+    parser.add_argument('--debug_websockets', action='store_true', help='Enable debug logging for detailed server websocket operations')
+
     parser.add_argument('-W', '--write', metavar='FILE', help='Save received audio to a WAV file')
     
     parser.add_argument('-b', '--batch', '--batch_size', type=int, default=16, help='Batch size for inference. This parameter controls the number of audio chunks processed in parallel during transcription. Default is 16.')
@@ -492,6 +533,9 @@ def parse_arguments():
     parser.add_argument('--allowed_latency_limit', type=int, default=100,
                         help='Maximal amount of chunks that can be unprocessed in queue before discarding chunks.. Default is 100.')
 
+    parser.add_argument('--faster_whisper_vad_filter', action='store_true',
+                        help='Enable VAD filter for Faster Whisper. Default is False.')
+
     parser.add_argument('--logchunks', action='store_true', help='Enable logging of incoming audio chunks (periods)')
 
     # Parse arguments
@@ -503,12 +547,17 @@ def parse_arguments():
     log_incoming_chunks = args.logchunks
     dynamic_silence_timing = args.silence_timing
 
-    if debug_logging:
-        loglevel = logging.DEBUG
-        logging.basicConfig(level=loglevel, format='[%(asctime)s] %(levelname)s - %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
-    else:
-        loglevel = logging.WARNING
 
+    ws_logger = logging.getLogger('websockets')
+    if args.debug_websockets:
+        # If app debug is on, let websockets be verbose too
+        ws_logger.setLevel(logging.DEBUG)
+        # Ensure it uses the handler configured by basicConfig
+        ws_logger.propagate = False # Prevent duplicate messages if it also propagates to root
+    else:
+        # If app debug is off, silence websockets below WARNING
+        ws_logger.setLevel(logging.WARNING)
+        ws_logger.propagate = True # Allow WARNING/ERROR messages to reach root logger's handler
 
     # Replace escaped newlines with actual newlines in initial_prompt
     if args.initial_prompt:
@@ -675,7 +724,7 @@ async def data_handler(websocket):
         while True:
             message = await websocket.recv()
             if isinstance(message, bytes):
-                if debug_logging:
+                if extended_logging:
                     debug_print(f"Received audio chunk (size: {len(message)} bytes)")
                 elif log_incoming_chunks:
                     print(".", end='', flush=True)
@@ -685,7 +734,14 @@ async def data_handler(websocket):
                 metadata = json.loads(metadata_json)
                 sample_rate = metadata['sampleRate']
 
-                debug_print(f"Processing audio chunk with sample rate {sample_rate}")
+                if 'server_sent_to_stt' in metadata:
+                    stt_received_ns = time.time_ns()
+                    metadata["stt_received"] = stt_received_ns
+                    metadata["stt_received_formatted"] = format_timestamp_ns(stt_received_ns)
+                    print(f"Server received audio chunk of length {len(message)} bytes, metadata: {metadata}")
+
+                if extended_logging:
+                    debug_print(f"Processing audio chunk with sample rate {sample_rate}")
                 chunk = message[4+metadata_length:]
 
                 if writechunks:
@@ -697,10 +753,13 @@ async def data_handler(websocket):
 
                     wav_file.writeframes(chunk)
 
-                resampled_chunk = decode_and_resample(chunk, sample_rate, 16000)
-
-                debug_print(f"Resampled chunk size: {len(resampled_chunk)} bytes")
-                recorder.feed_audio(resampled_chunk)
+                if sample_rate != 16000:
+                    resampled_chunk = decode_and_resample(chunk, sample_rate, 16000)
+                    if extended_logging:
+                        debug_print(f"Resampled chunk size: {len(resampled_chunk)} bytes")
+                    recorder.feed_audio(resampled_chunk)
+                else:
+                    recorder.feed_audio(chunk)
             else:
                 print(f"{bcolors.WARNING}Received non-binary message on data connection{bcolors.ENDC}")
     except websockets.exceptions.ConnectionClosed as e:
@@ -780,6 +839,9 @@ async def main_async():
         'on_wakeword_detection_start': make_callback(loop, on_wakeword_detection_start),
         'on_wakeword_detection_end': make_callback(loop, on_wakeword_detection_end),
         'on_transcription_start': make_callback(loop, on_transcription_start),
+        'on_turn_detection_start': make_callback(loop, on_turn_detection_start),
+        'on_turn_detection_stop': make_callback(loop, on_turn_detection_stop),
+
         # 'on_recorded_chunk': make_callback(loop, on_recorded_chunk),
         'no_log_file': True,  # Disable logging to file
         'use_extended_logging': args.use_extended_logging,
@@ -790,6 +852,7 @@ async def main_async():
         'handle_buffer_overflow': args.handle_buffer_overflow,
         'suppress_tokens': args.suppress_tokens,
         'allowed_latency_limit': args.allowed_latency_limit,
+        'faster_whisper_vad_filter': args.faster_whisper_vad_filter,
     }
 
     try:

{realtimestt-0.3.101 → realtimestt-0.3.103/realtimestt.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: realtimestt
-Version: 0.3.101
+Version: 0.3.103
 Summary: A fast Voice Activity Detection and Transcription System
 Home-page: https://github.com/KoljaB/RealTimeSTT
 Author: Kolja Beigel

{realtimestt-0.3.101 → realtimestt-0.3.103}/realtimestt.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ RealtimeSTT/__init__.py
 RealtimeSTT/audio_input.py
 RealtimeSTT/audio_recorder.py
 RealtimeSTT/audio_recorder_client.py
+RealtimeSTT/safepipe.py
 RealtimeSTT/warmup_audio.wav
 RealtimeSTT_server/__init__.py
 RealtimeSTT_server/install_packages.py

{realtimestt-0.3.101 → realtimestt-0.3.103}/setup.py

@@ -14,7 +14,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setuptools.setup(
     name="realtimestt",
-    version="0.3.101",
+    version="0.3.103",
     author="Kolja Beigel",
     author_email="kolja.beigel@web.de",
     description="A fast Voice Activity Detection and Transcription System",