Upload 12 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+src/web/demo.png filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,15 @@
+# ベースイメージを指定
+FROM python:3.11-slim
+
+# 作業ディレクトリを設定
+WORKDIR /app
+
+# 必要なパッケージをインストール
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# アプリケーションのソースコードをコピー
+COPY . .
+
+# サーバーを起動するコマンドを指定
+CMD ["python", "./whisper_fastapi_online_server.py", "--host", "localhost", "--port", "8000", "--lan", "en", "--model", "tiny"]

requirements.txt

@@ -0,0 +1,5 @@
+librosa
+soundfile
+fastapi
+ffmpeg-python
+faster-whisper

src/diarization/diarization_online.py

@@ -0,0 +1,110 @@
+from diart import SpeakerDiarization
+from diart.inference import StreamingInference
+from diart.sources import AudioSource
+from rx.subject import Subject
+import threading
+import numpy as np
+import asyncio
+
+class WebSocketAudioSource(AudioSource):
+    """
+    Simple custom AudioSource that blocks in read()
+    until close() is called.
+    push_audio() is used to inject new PCM chunks.
+    """
+    def __init__(self, uri: str = "websocket", sample_rate: int = 16000):
+        super().__init__(uri, sample_rate)
+        self._close_event = threading.Event()
+        self._closed = False
+
+    def read(self):
+        self._close_event.wait()
+
+    def close(self):
+        if not self._closed:
+            self._closed = True
+            self.stream.on_completed()
+            self._close_event.set()
+
+    def push_audio(self, chunk: np.ndarray):
+        chunk = np.expand_dims(chunk, axis=0)
+        if not self._closed:
+            self.stream.on_next(chunk)
+
+
+def create_pipeline(SAMPLE_RATE):
+    diar_pipeline = SpeakerDiarization()
+    ws_source = WebSocketAudioSource(uri="websocket_source", sample_rate=SAMPLE_RATE)
+    inference = StreamingInference(
+        pipeline=diar_pipeline,
+        source=ws_source,
+        do_plot=False,
+        show_progress=False,
+    )
+    return inference, ws_source
+
+
+def init_diart(SAMPLE_RATE):
+    inference, ws_source = create_pipeline(SAMPLE_RATE)
+
+    def diar_hook(result):
+        """
+        Hook called each time Diart processes a chunk.
+        result is (annotation, audio).
+        We store the label of the last segment in 'current_speaker'.
+        """
+        global l_speakers
+        l_speakers = []
+        annotation, audio = result
+        for speaker in annotation._labels:            
+            segments_beg = annotation._labels[speaker].segments_boundaries_[0]
+            segments_end = annotation._labels[speaker].segments_boundaries_[-1]
+            asyncio.create_task(
+            l_speakers_queue.put({"speaker": speaker, "beg": segments_beg, "end": segments_end})
+        )
+
+    l_speakers_queue = asyncio.Queue()
+    inference.attach_hooks(diar_hook)
+
+    # Launch Diart in a background thread
+    loop = asyncio.get_event_loop()
+    diar_future = loop.run_in_executor(None, inference)
+    return inference, l_speakers_queue, ws_source
+
+
+class DiartDiarization():
+    def __init__(self, SAMPLE_RATE):
+        self.inference, self.l_speakers_queue, self.ws_source = init_diart(SAMPLE_RATE)
+        self.segment_speakers = []
+
+    async def diarize(self, pcm_array):
+        self.ws_source.push_audio(pcm_array)
+        self.segment_speakers = []
+        while not self.l_speakers_queue.empty():
+            self.segment_speakers.append(await self.l_speakers_queue.get())
+    
+    def close(self):
+        self.ws_source.close()
+
+
+    def assign_speakers_to_chunks(self, chunks):
+        """
+        Go through each chunk and see which speaker(s) overlap
+        that chunk's time range in the Diart annotation.
+        Then store the speaker label(s) (or choose the most overlapping).
+        This modifies `chunks` in-place or returns a new list with assigned speakers.
+        """
+        if not self.segment_speakers:
+            return chunks
+
+        for segment in self.segment_speakers:
+            seg_beg = segment["beg"]
+            seg_end = segment["end"]
+            speaker = segment["speaker"]
+            for ch in chunks:
+                if seg_end <= ch["beg"] or seg_beg >= ch["end"]:
+                    continue
+                # We have overlap. Let's just pick the speaker (could be more precise in a more complex implementation)
+                ch["speaker"] = speaker
+
+        return chunks

src/web/live_transcription.html

@@ -0,0 +1,269 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8"/>
+  <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
+  <title>Audio Transcription</title>
+  <style>
+    body {
+      font-family: 'Inter', sans-serif;
+      margin: 20px;
+      text-align: center;
+    }
+    #recordButton {
+      width: 80px;
+      height: 80px;
+      font-size: 36px;
+      border: none;
+      border-radius: 50%;
+      background-color: white;
+      cursor: pointer;
+      box-shadow: 0 0px 10px rgba(0, 0, 0, 0.2);
+      transition: background-color 0.3s ease, transform 0.2s ease;
+    }
+    #recordButton.recording {
+      background-color: #ff4d4d;
+      color: white;
+    }
+    #recordButton:active {
+      transform: scale(0.95);
+    }
+    #status {
+      margin-top: 20px;
+      font-size: 16px;
+      color: #333;
+    }
+    .settings-container {
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      gap: 15px;
+      margin-top: 20px;
+    }
+    .settings {
+      display: flex;
+      flex-direction: column;
+      align-items: flex-start;
+      gap: 5px;
+    }
+    #chunkSelector,
+    #websocketInput {
+      font-size: 16px;
+      padding: 5px;
+      border-radius: 5px;
+      border: 1px solid #ddd;
+      background-color: #f9f9f9;
+    }
+    #websocketInput {
+      width: 200px;
+    }
+    #chunkSelector:focus,
+    #websocketInput:focus {
+      outline: none;
+      border-color: #007bff;
+    }
+    label {
+      font-size: 14px;
+    }
+    /* Speaker-labeled transcript area */
+    #linesTranscript {
+      margin: 20px auto;
+      max-width: 600px;
+      text-align: left;
+      font-size: 16px;
+    }
+    #linesTranscript p {
+      margin: 5px 0;
+    }
+    #linesTranscript strong {
+      color: #333;
+    }
+    /* Grey buffer styling */
+    .buffer {
+      color: rgb(180, 180, 180);
+      font-style: italic;
+      margin-left: 4px;
+    }
+  </style>
+</head>
+<body>
+
+  <div class="settings-container">
+    <button id="recordButton">🎙️</button>
+    <div class="settings">
+      <div>
+        <label for="chunkSelector">Chunk size (ms):</label>
+        <select id="chunkSelector">
+          <option value="500" selected>500 ms</option>
+          <option value="1000">1000 ms</option>
+          <option value="2000">2000 ms</option>
+          <option value="3000">3000 ms</option>
+          <option value="4000">4000 ms</option>
+          <option value="5000">5000 ms</option>
+        </select>
+      </div>
+      <div>
+        <label for="websocketInput">WebSocket URL:</label>
+        <input id="websocketInput" type="text" value="ws://localhost:8000/asr" />
+      </div>
+    </div>
+  </div>
+
+  <p id="status"></p>
+
+  <!-- Speaker-labeled transcript -->
+  <div id="linesTranscript"></div>
+
+  <script>
+    let isRecording = false;
+    let websocket = null;
+    let recorder = null;
+    let chunkDuration = 500;
+    let websocketUrl = "ws://localhost:8000/asr";
+    let userClosing = false;
+
+    const statusText = document.getElementById("status");
+    const recordButton = document.getElementById("recordButton");
+    const chunkSelector = document.getElementById("chunkSelector");
+    const websocketInput = document.getElementById("websocketInput");
+    const linesTranscriptDiv = document.getElementById("linesTranscript");
+
+    chunkSelector.addEventListener("change", () => {
+      chunkDuration = parseInt(chunkSelector.value);
+    });
+
+    websocketInput.addEventListener("change", () => {
+      const urlValue = websocketInput.value.trim();
+      if (!urlValue.startsWith("ws://") && !urlValue.startsWith("wss://")) {
+        statusText.textContent = "Invalid WebSocket URL (must start with ws:// or wss://)";
+        return;
+      }
+      websocketUrl = urlValue;
+      statusText.textContent = "WebSocket URL updated. Ready to connect.";
+    });
+
+    function setupWebSocket() {
+      return new Promise((resolve, reject) => {
+        try {
+          websocket = new WebSocket(websocketUrl);
+        } catch (error) {
+          statusText.textContent = "Invalid WebSocket URL. Please check and try again.";
+          reject(error);
+          return;
+        }
+
+        websocket.onopen = () => {
+          statusText.textContent = "Connected to server.";
+          resolve();
+        };
+
+        websocket.onclose = () => {
+          if (userClosing) {
+            statusText.textContent = "WebSocket closed by user.";
+          } else {
+            statusText.textContent =
+              "Disconnected from the WebSocket server. (Check logs if model is loading.)";
+          }
+          userClosing = false;
+        };
+
+        websocket.onerror = () => {
+          statusText.textContent = "Error connecting to WebSocket.";
+          reject(new Error("Error connecting to WebSocket"));
+        };
+
+        // Handle messages from server
+        websocket.onmessage = (event) => {
+          const data = JSON.parse(event.data);
+          /*
+            The server might send:
+            {
+              "lines": [
+                {"speaker": 0, "text": "Hello."},
+                {"speaker": 1, "text": "Bonjour."},
+                ...
+              ],
+              "buffer": "..."
+            }
+          */
+          const { lines = [], buffer = "" } = data;
+          renderLinesWithBuffer(lines, buffer);
+        };
+      });
+    }
+
+    function renderLinesWithBuffer(lines, buffer) {
+      // Clears if no lines
+      if (!Array.isArray(lines) || lines.length === 0) {
+        linesTranscriptDiv.innerHTML = "";
+        return;
+      }
+      // Build the HTML
+      // The buffer is appended to the last line if it's non-empty
+      const linesHtml = lines.map((item, idx) => {
+        let textContent = item.text;
+        if (idx === lines.length - 1 && buffer) {
+          textContent += `<span class="buffer">${buffer}</span>`;
+        }
+        return `<p><strong>Speaker ${item.speaker}:</strong> ${textContent}</p>`;
+      }).join("");
+
+      linesTranscriptDiv.innerHTML = linesHtml;
+    }
+
+    async function startRecording() {
+      try {
+        const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+        recorder = new MediaRecorder(stream, { mimeType: "audio/webm" });
+        recorder.ondataavailable = (e) => {
+          if (websocket && websocket.readyState === WebSocket.OPEN) {
+            websocket.send(e.data);
+          }
+        };
+        recorder.start(chunkDuration);
+        isRecording = true;
+        updateUI();
+      } catch (err) {
+        statusText.textContent = "Error accessing microphone. Please allow microphone access.";
+      }
+    }
+
+    function stopRecording() {
+      userClosing = true;
+      if (recorder) {
+        recorder.stop();
+        recorder = null;
+      }
+      isRecording = false;
+
+      if (websocket) {
+        websocket.close();
+        websocket = null;
+      }
+
+      updateUI();
+    }
+
+    async function toggleRecording() {
+      if (!isRecording) {
+        linesTranscriptDiv.innerHTML = "";
+        try {
+          await setupWebSocket();
+          await startRecording();
+        } catch (err) {
+          statusText.textContent = "Could not connect to WebSocket or access mic. Aborted.";
+        }
+      } else {
+        stopRecording();
+      }
+    }
+
+    function updateUI() {
+      recordButton.classList.toggle("recording", isRecording);
+      statusText.textContent = isRecording ? "Recording..." : "Click to start transcription";
+    }
+
+    recordButton.addEventListener("click", toggleRecording);
+  </script>
+</body>
+</html>

src/whisper/timestaped_words.py

@@ -0,0 +1,108 @@
+from typing import List
+
+class TimeStampedSegment:
+    """
+    Represents a segment of text with start and end timestamps.
+
+    Attributes:
+        start (float): The start time of the segment.
+        end (float): The end time of the segment.
+        text (str): The text of the segment.
+    """
+    def __init__(self, start: float, end: float, text: str):
+        self.start = start
+        self.end = end
+        self.text = text
+
+    def __str__(self):
+        return f'{self.start} - {self.end}: {self.text}'
+    
+    def __repr__(self):
+        return self.__str__()
+    
+    def shift(self, shift: float):
+        """
+        Shifts the segment by a given amount of time.
+
+        Args:
+            shift (float): The amount of time to shift the segment.
+
+        Returns:
+            TimeStampedSegment: A new segment shifted by the given amount of time.
+
+        Example:
+            >>> segment = TimeStampedSegment(0.0, 1.0, "Hello")
+            >>> segment.shift(1.0)
+            1.0 - 2.0: Hello
+        """
+        return TimeStampedSegment(self.start + shift, self.end + shift, self.text)
+    
+    def append_text(self, text: str):
+        """
+        Appends text to the segment.
+
+        Args:
+            text (str): The text to append.
+
+        Example:
+            >>> segment = TimeStampedSegment(0.0, 1.0, "Hello")
+            >>> segment.append_text("!")
+            >>> segment
+            0.0 - 1.0: Hello!
+        """
+        self.text += text
+    
+    def __eq__(self, other):
+        return self.start == other.start and self.end == other.end and self.text == other.text
+    
+    def __add__(self, other):
+        if isinstance(other, (int, float)):
+            return self.shift(other)
+        elif isinstance(other, str):
+            return TimeStampedSegment(self.start, self.end, self.text + other)
+        else:
+            raise TypeError(f"unsupported operand type(s) for +: '{type(self).__name__}' and '{type(other).__name__}'")
+
+class TimeStampedText:
+    """
+    Represents a collection of TimeStampedSegment instances.
+
+    Attributes:
+        segments (List[TimeStampedSegment]): The list of segments.
+    """
+    def __init__(self):
+        self.segments: List[TimeStampedSegment] = []
+
+    def add_segment(self, segment: TimeStampedSegment):
+        """
+        Adds a segment to the collection.
+
+        Args:
+            segment (TimeStampedSegment): The segment to add.
+
+        Example:
+            >>> tst = TimeStampedText()
+            >>> tst.add_segment(TimeStampedSegment(0.0, 1.0, "Hello"))
+            >>> tst.add_segment(TimeStampedSegment(1.0, 2.0, "world"))
+            >>> len(tst)
+            2
+        """
+        self.segments.append(segment)
+
+    def __repr__(self):
+        return f"TimeStampedText(segments={self.segments})"
+
+    def __iter__(self):
+        return iter(self.segments)
+
+    def __getitem__(self, index):
+        return self.segments[index]
+
+    def __len__(self):
+        return len(self.segments)
+    
+    # TODO: a function from_whisper_res()
+
+if __name__ == "__main__":
+    import doctest
+    doctest.testmod(verbose=True)

src/whisper_streaming/backends.py

@@ -0,0 +1,368 @@
+import sys
+import logging
+
+import io
+import soundfile as sf
+import math
+
+
+logger = logging.getLogger(__name__)
+
+class ASRBase:
+    sep = " "  # join transcribe words with this character (" " for whisper_timestamped,
+    # "" for faster-whisper because it emits the spaces when neeeded)
+
+    def __init__(
+        self, lan, modelsize=None, cache_dir=None, model_dir=None, logfile=sys.stderr
+    ):
+        self.logfile = logfile
+
+        self.transcribe_kargs = {}
+        if lan == "auto":
+            self.original_language = None
+        else:
+            self.original_language = lan
+
+        self.model = self.load_model(modelsize, cache_dir, model_dir)
+
+    def load_model(self, modelsize, cache_dir):
+        raise NotImplemented("must be implemented in the child class")
+
+    def transcribe(self, audio, init_prompt=""):
+        raise NotImplemented("must be implemented in the child class")
+
+    def use_vad(self):
+        raise NotImplemented("must be implemented in the child class")
+
+
+class WhisperTimestampedASR(ASRBase):
+    """Uses whisper_timestamped library as the backend. Initially, we tested the code on this backend. It worked, but slower than faster-whisper.
+    On the other hand, the installation for GPU could be easier.
+    """
+
+    sep = " "
+
+    def load_model(self, modelsize=None, cache_dir=None, model_dir=None):
+        import whisper
+        import whisper_timestamped
+        from whisper_timestamped import transcribe_timestamped
+
+        self.transcribe_timestamped = transcribe_timestamped
+        if model_dir is not None:
+            logger.debug("ignoring model_dir, not implemented")
+        return whisper.load_model(modelsize, download_root=cache_dir)
+
+    def transcribe(self, audio, init_prompt=""):
+        result = self.transcribe_timestamped(
+            self.model,
+            audio,
+            language=self.original_language,
+            initial_prompt=init_prompt,
+            verbose=None,
+            condition_on_previous_text=True,
+            **self.transcribe_kargs,
+        )
+        return result
+
+    def ts_words(self, r):
+        # return: transcribe result object to [(beg,end,"word1"), ...]
+        o = []
+        for s in r["segments"]:
+            for w in s["words"]:
+                t = (w["start"], w["end"], w["text"])
+                o.append(t)
+        return o
+
+    def segments_end_ts(self, res):
+        return [s["end"] for s in res["segments"]]
+
+    def use_vad(self):
+        self.transcribe_kargs["vad"] = True
+
+    def set_translate_task(self):
+        self.transcribe_kargs["task"] = "translate"
+
+
+class FasterWhisperASR(ASRBase):
+    """Uses faster-whisper library as the backend. Works much faster, appx 4-times (in offline mode). For GPU, it requires installation with a specific CUDNN version."""
+
+    sep = ""
+
+    def load_model(self, modelsize=None, cache_dir=None, model_dir=None):
+        from faster_whisper import WhisperModel
+
+        #        logging.getLogger("faster_whisper").setLevel(logger.level)
+        if model_dir is not None:
+            logger.debug(
+                f"Loading whisper model from model_dir {model_dir}. modelsize and cache_dir parameters are not used."
+            )
+            model_size_or_path = model_dir
+        elif modelsize is not None:
+            model_size_or_path = modelsize
+        else:
+            raise ValueError("modelsize or model_dir parameter must be set")
+
+        # this worked fast and reliably on NVIDIA L40
+        model = WhisperModel(
+            model_size_or_path,
+            device="cuda",
+            compute_type="float16",
+            download_root=cache_dir,
+        )
+
+        # or run on GPU with INT8
+        # tested: the transcripts were different, probably worse than with FP16, and it was slightly (appx 20%) slower
+        # model = WhisperModel(model_size, device="cuda", compute_type="int8_float16")
+
+        # or run on CPU with INT8
+        # tested: works, but slow, appx 10-times than cuda FP16
+        #        model = WhisperModel(modelsize, device="cpu", compute_type="int8") #, download_root="faster-disk-cache-dir/")
+        return model
+
+    def transcribe(self, audio, init_prompt=""):
+
+        # tested: beam_size=5 is faster and better than 1 (on one 200 second document from En ESIC, min chunk 0.01)
+        segments, info = self.model.transcribe(
+            audio,
+            language=self.original_language,
+            initial_prompt=init_prompt,
+            beam_size=5,
+            word_timestamps=True,
+            condition_on_previous_text=True,
+            **self.transcribe_kargs,
+        )
+        # print(info)  # info contains language detection result
+
+        return list(segments)
+
+    def ts_words(self, segments):
+        o = []
+        for segment in segments:
+            for word in segment.words:
+                if segment.no_speech_prob > 0.9:
+                    continue
+                # not stripping the spaces -- should not be merged with them!
+                w = word.word
+                t = (word.start, word.end, w)
+                o.append(t)
+        return o
+
+    def segments_end_ts(self, res):
+        return [s.end for s in res]
+
+    def use_vad(self):
+        self.transcribe_kargs["vad_filter"] = True
+
+    def set_translate_task(self):
+        self.transcribe_kargs["task"] = "translate"
+
+
+class MLXWhisper(ASRBase):
+    """
+    Uses MPX Whisper library as the backend, optimized for Apple Silicon.
+    Models available: https://huggingface.co/collections/mlx-community/whisper-663256f9964fbb1177db93dc
+    Significantly faster than faster-whisper (without CUDA) on Apple M1.
+    """
+
+    sep = "" # In my experience in french it should also be no space.
+
+    def load_model(self, modelsize=None, cache_dir=None, model_dir=None):
+        """
+        Loads the MLX-compatible Whisper model.
+
+        Args:
+            modelsize (str, optional): The size or name of the Whisper model to load.
+                If provided, it will be translated to an MLX-compatible model path using the `translate_model_name` method.
+                Example: "large-v3-turbo" -> "mlx-community/whisper-large-v3-turbo".
+            cache_dir (str, optional): Path to the directory for caching models.
+                **Note**: This is not supported by MLX Whisper and will be ignored.
+            model_dir (str, optional): Direct path to a custom model directory.
+                If specified, it overrides the `modelsize` parameter.
+        """
+        from mlx_whisper.transcribe import ModelHolder, transcribe
+        import mlx.core as mx
+
+        if model_dir is not None:
+            logger.debug(
+                f"Loading whisper model from model_dir {model_dir}. modelsize parameter is not used."
+            )
+            model_size_or_path = model_dir
+        elif modelsize is not None:
+            model_size_or_path = self.translate_model_name(modelsize)
+            logger.debug(
+                f"Loading whisper model {modelsize}. You use mlx whisper, so {model_size_or_path} will be used."
+            )
+
+        self.model_size_or_path = model_size_or_path
+        
+        # In mlx_whisper.transcribe, dtype is defined as:
+        # dtype = mx.float16 if decode_options.get("fp16", True) else mx.float32
+        # Since we do not use decode_options in self.transcribe, we will set dtype to mx.float16
+        dtype = mx.float16 
+        ModelHolder.get_model(model_size_or_path, dtype)
+        return transcribe
+
+    def translate_model_name(self, model_name):
+        """
+        Translates a given model name to its corresponding MLX-compatible model path.
+
+        Args:
+            model_name (str): The name of the model to translate.
+
+        Returns:
+            str: The MLX-compatible model path.
+        """
+        # Dictionary mapping model names to MLX-compatible paths
+        model_mapping = {
+            "tiny.en": "mlx-community/whisper-tiny.en-mlx",
+            "tiny": "mlx-community/whisper-tiny-mlx",
+            "base.en": "mlx-community/whisper-base.en-mlx",
+            "base": "mlx-community/whisper-base-mlx",
+            "small.en": "mlx-community/whisper-small.en-mlx",
+            "small": "mlx-community/whisper-small-mlx",
+            "medium.en": "mlx-community/whisper-medium.en-mlx",
+            "medium": "mlx-community/whisper-medium-mlx",
+            "large-v1": "mlx-community/whisper-large-v1-mlx",
+            "large-v2": "mlx-community/whisper-large-v2-mlx",
+            "large-v3": "mlx-community/whisper-large-v3-mlx",
+            "large-v3-turbo": "mlx-community/whisper-large-v3-turbo",
+            "large": "mlx-community/whisper-large-mlx",
+        }
+
+        # Retrieve the corresponding MLX model path
+        mlx_model_path = model_mapping.get(model_name)
+
+        if mlx_model_path:
+            return mlx_model_path
+        else:
+            raise ValueError(
+                f"Model name '{model_name}' is not recognized or not supported."
+            )
+
+    def transcribe(self, audio, init_prompt=""):
+        if self.transcribe_kargs:
+            logger.warning("Transcribe kwargs (vad, task) are not compatible with MLX Whisper and will be ignored.")
+        segments = self.model(
+            audio,
+            language=self.original_language,
+            initial_prompt=init_prompt,
+            word_timestamps=True,
+            condition_on_previous_text=True,
+            path_or_hf_repo=self.model_size_or_path,
+        )
+        return segments.get("segments", [])
+
+    def ts_words(self, segments):
+        """
+        Extract timestamped words from transcription segments and skips words with high no-speech probability.
+        """
+        return [
+            (word["start"], word["end"], word["word"])
+            for segment in segments
+            for word in segment.get("words", [])
+            if segment.get("no_speech_prob", 0) <= 0.9
+        ]
+
+    def segments_end_ts(self, res):
+        return [s["end"] for s in res]
+
+    def use_vad(self):
+        self.transcribe_kargs["vad_filter"] = True
+
+    def set_translate_task(self):
+        self.transcribe_kargs["task"] = "translate"
+
+
+class OpenaiApiASR(ASRBase):
+    """Uses OpenAI's Whisper API for audio transcription."""
+
+    def __init__(self, lan=None, temperature=0, logfile=sys.stderr):
+        self.logfile = logfile
+
+        self.modelname = "whisper-1"
+        self.original_language = (
+            None if lan == "auto" else lan
+        )  # ISO-639-1 language code
+        self.response_format = "verbose_json"
+        self.temperature = temperature
+
+        self.load_model()
+
+        self.use_vad_opt = False
+
+        # reset the task in set_translate_task
+        self.task = "transcribe"
+
+    def load_model(self, *args, **kwargs):
+        from openai import OpenAI
+
+        self.client = OpenAI()
+
+        self.transcribed_seconds = (
+            0  # for logging how many seconds were processed by API, to know the cost
+        )
+
+    def ts_words(self, segments):
+        no_speech_segments = []
+        if self.use_vad_opt:
+            for segment in segments.segments:
+                # TODO: threshold can be set from outside
+                if segment["no_speech_prob"] > 0.8:
+                    no_speech_segments.append(
+                        (segment.get("start"), segment.get("end"))
+                    )
+
+        o = []
+        for word in segments.words:
+            start = word.start
+            end = word.end
+            if any(s[0] <= start <= s[1] for s in no_speech_segments):
+                # print("Skipping word", word.get("word"), "because it's in a no-speech segment")
+                continue
+            o.append((start, end, word.word))
+        return o
+
+    def segments_end_ts(self, res):
+        return [s.end for s in res.words]
+
+    def transcribe(self, audio_data, prompt=None, *args, **kwargs):
+        # Write the audio data to a buffer
+        buffer = io.BytesIO()
+        buffer.name = "temp.wav"
+        sf.write(buffer, audio_data, samplerate=16000, format="WAV", subtype="PCM_16")
+        buffer.seek(0)  # Reset buffer's position to the beginning
+
+        self.transcribed_seconds += math.ceil(
+            len(audio_data) / 16000
+        )  # it rounds up to the whole seconds
+
+        params = {
+            "model": self.modelname,
+            "file": buffer,
+            "response_format": self.response_format,
+            "temperature": self.temperature,
+            "timestamp_granularities": ["word", "segment"],
+        }
+        if self.task != "translate" and self.original_language:
+            params["language"] = self.original_language
+        if prompt:
+            params["prompt"] = prompt
+
+        if self.task == "translate":
+            proc = self.client.audio.translations
+        else:
+            proc = self.client.audio.transcriptions
+
+        # Process transcription/translation
+        transcript = proc.create(**params)
+        logger.debug(
+            f"OpenAI API processed accumulated {self.transcribed_seconds} seconds"
+        )
+
+        return transcript
+
+    def use_vad(self):
+        self.use_vad_opt = True
+
+    def set_translate_task(self):
+        self.task = "translate"

src/whisper_streaming/online_asr.py

@@ -0,0 +1,513 @@
+import sys
+import numpy as np
+import logging
+
+logger = logging.getLogger(__name__)
+
+class HypothesisBuffer:
+
+    def __init__(self, logfile=sys.stderr):
+        self.commited_in_buffer = []
+        self.buffer = []
+        self.new = []
+
+        self.last_commited_time = 0
+        self.last_commited_word = None
+
+        self.logfile = logfile
+
+    def insert(self, new, offset):
+        """
+        compare self.commited_in_buffer and new. It inserts only the words in new that extend the commited_in_buffer, it means they are roughly behind last_commited_time and new in content
+        The new tail is added to self.new
+        """
+
+        new = [(a + offset, b + offset, t) for a, b, t in new]
+        self.new = [(a, b, t) for a, b, t in new if a > self.last_commited_time - 0.1]
+
+        if len(self.new) >= 1:
+            a, b, t = self.new[0]
+            if abs(a - self.last_commited_time) < 1:
+                if self.commited_in_buffer:
+                    # it's going to search for 1, 2, ..., 5 consecutive words (n-grams) that are identical in commited and new. If they are, they're dropped.
+                    cn = len(self.commited_in_buffer)
+                    nn = len(self.new)
+                    for i in range(1, min(min(cn, nn), 5) + 1):  # 5 is the maximum
+                        c = " ".join(
+                            [self.commited_in_buffer[-j][2] for j in range(1, i + 1)][
+                                ::-1
+                            ]
+                        )
+                        tail = " ".join(self.new[j - 1][2] for j in range(1, i + 1))
+                        if c == tail:
+                            words = []
+                            for j in range(i):
+                                words.append(repr(self.new.pop(0)))
+                            words_msg = " ".join(words)
+                            logger.debug(f"removing last {i} words: {words_msg}")
+                            break
+
+    def flush(self):
+        # returns commited chunk = the longest common prefix of 2 last inserts.
+
+        commit = []
+        while self.new:
+            na, nb, nt = self.new[0]
+
+            if len(self.buffer) == 0:
+                break
+
+            if nt == self.buffer[0][2]:
+                commit.append((na, nb, nt))
+                self.last_commited_word = nt
+                self.last_commited_time = nb
+                self.buffer.pop(0)
+                self.new.pop(0)
+            else:
+                break
+        self.buffer = self.new
+        self.new = []
+        self.commited_in_buffer.extend(commit)
+        return commit
+
+    def pop_commited(self, time):
+        "Remove (from the beginning) of commited_in_buffer all the words that are finished before `time`"
+        while self.commited_in_buffer and self.commited_in_buffer[0][1] <= time:
+            self.commited_in_buffer.pop(0)
+
+    def complete(self):
+        return self.buffer
+
+
+
+
+
+class OnlineASRProcessor:
+
+    SAMPLING_RATE = 16000
+
+    def __init__(
+        self,
+        asr,
+        tokenize_method=None,
+        buffer_trimming=("segment", 15),
+        logfile=sys.stderr,
+    ):
+        """
+        Initialize OnlineASRProcessor.
+
+        Args:
+            asr: WhisperASR object
+            tokenize_method: Sentence tokenizer function for the target language.
+            Must be a function that takes a list of text as input like MosesSentenceSplitter.
+            Can be None if using "segment" buffer trimming option.
+            buffer_trimming: Tuple of (option, seconds) where:
+            - option: Either "sentence" or "segment"
+            - seconds: Number of seconds threshold for buffer trimming
+            Default is ("segment", 15)
+            logfile: File to store logs
+
+        """
+        self.asr = asr
+        self.tokenize = tokenize_method
+        self.logfile = logfile
+
+        self.init()
+
+        self.buffer_trimming_way, self.buffer_trimming_sec = buffer_trimming
+
+        if self.buffer_trimming_way not in ["sentence", "segment"]:
+            raise ValueError("buffer_trimming must be either 'sentence' or 'segment'")
+        if self.buffer_trimming_sec <= 0:
+            raise ValueError("buffer_trimming_sec must be positive")
+        elif self.buffer_trimming_sec > 30:
+            logger.warning(
+                f"buffer_trimming_sec is set to {self.buffer_trimming_sec}, which is very long. It may cause OOM."
+            )
+
+    def init(self, offset=None):
+        """run this when starting or restarting processing"""
+        self.audio_buffer = np.array([], dtype=np.float32)
+        self.transcript_buffer = HypothesisBuffer(logfile=self.logfile)
+        self.buffer_time_offset = 0
+        if offset is not None:
+            self.buffer_time_offset = offset
+        self.transcript_buffer.last_commited_time = self.buffer_time_offset
+        self.final_transcript = []
+        self.commited_not_final = []
+ 
+
+    def insert_audio_chunk(self, audio):
+        self.audio_buffer = np.append(self.audio_buffer, audio)
+
+    def prompt(self):
+        """Returns a tuple: (prompt, context), where "prompt" is a 200-character suffix of commited text that is inside of the scrolled away part of audio buffer.
+        "context" is the commited text that is inside the audio buffer. It is transcribed again and skipped. It is returned only for debugging and logging reasons.
+
+        
+        """        
+        
+        if len(self.final_transcript) == 0:
+            prompt=""
+
+        if len(self.final_transcript) == 1:
+            prompt = self.final_transcript[0][2][-200:]
+        
+        else:
+            prompt = self.concatenate_tsw(self.final_transcript)[2][-200:]
+        # TODO: this is not ideal as we concatenate each time the whole transcript
+
+        # k = max(0, len(self.final_transcript) - 1)
+        # while k > 1 and self.final_transcript[k - 1][1] > self.buffer_time_offset:
+        #     k -= 1
+
+        # p = self.final_transcript[:k]
+
+        
+        # p = [t for _, _, t in p]
+        # prompt = []
+        # l = 0
+        # while p and l < 200:  # 200 characters prompt size
+        #     x = p.pop(-1)
+        #     l += len(x) + 1
+        #     prompt.append(x)
+
+        non_prompt =  self.concatenate_tsw(self.commited_not_final)[2]
+
+        logger.debug(f"PROMPT(previous): {prompt[:20]}…{prompt[-20:]} (length={len(prompt)}chars)")
+        logger.debug(f"CONTEXT: {non_prompt}")
+
+        return prompt, non_prompt
+        
+
+    def process_iter(self):
+        """Runs on the current audio buffer.
+        Returns: a tuple (beg_timestamp, end_timestamp, "text"), or (None, None, "").
+        The non-emty text is confirmed (committed) partial transcript.
+        """
+
+        prompt, non_prompt = self.prompt()
+
+        logger.debug(
+            f"transcribing {len(self.audio_buffer)/self.SAMPLING_RATE:2.2f} seconds from {self.buffer_time_offset:2.2f}"
+        )
+
+        ## Transcribe and format the result to [(beg,end,"word1"), ...]
+        res = self.asr.transcribe(self.audio_buffer, init_prompt=prompt)
+        tsw = self.asr.ts_words(res)
+
+
+        # insert into HypothesisBuffer, and get back the commited words
+        self.transcript_buffer.insert(tsw, self.buffer_time_offset)
+        commited_tsw = self.transcript_buffer.flush()
+        
+        if len(commited_tsw) == 0:
+            return (None, None, "")
+
+
+        self.commited_not_final.extend(commited_tsw)
+
+
+        # Define `completed` and `the_rest` based on the buffer_trimming_way
+        # completed will be returned at the end of the function.
+        # completed is a transcribed text with (beg,end,"sentence ...") format.
+
+
+        completed = []
+        if self.buffer_trimming_way == "sentence":
+            
+            sentences = self.words_to_sentences(self.commited_not_final)
+
+
+
+            if len(sentences) < 2:
+                logger.debug(f"[Sentence-segmentation] no full sentence segmented, do not commit anything.")
+                
+                
+
+            
+            else:
+                identified_sentence= "\n    - ".join([f"{s[0]*1000:.0f}-{s[1]*1000:.0f} {s[2]}" for s in sentences])
+                logger.debug(f"[Sentence-segmentation] identified sentences:\n    - {identified_sentence}")
+
+                # assume last sentence is incomplete, which is not always true
+
+                # we will continue with audio processing at this timestamp
+                chunk_at = sentences[-2][1]
+
+                self.chunk_at(chunk_at)
+                # TODO: here paragraph breaks can be added
+                self.commited_not_final = sentences[-1:]
+
+                completed= sentences[:-1]
+
+            
+        
+
+
+            # break audio buffer anyway if it is too long
+
+        if len(self.audio_buffer) / self.SAMPLING_RATE > self.buffer_trimming_sec :
+                    
+            if self.buffer_trimming_way == "sentence":
+                logger.warning(f"Chunck segment after {self.buffer_trimming_sec} seconds!"
+                                " Even if no sentence was found!"
+                            )
+                    
+                    
+
+                
+            completed = self.chunk_completed_segment() 
+                
+
+            
+
+        
+
+        if len(completed) == 0:      
+            return (None, None, "")
+        else:
+            self.final_transcript.extend(completed) # add whole time stamped sentences / or words to commited list
+        
+
+            completed_text_segment= self.concatenate_tsw(completed)
+            
+            the_rest = self.concatenate_tsw(self.transcript_buffer.complete())
+            commited_but_not_final = self.concatenate_tsw(self.commited_not_final)
+            logger.debug(f"\n    COMPLETE NOW: {completed_text_segment[2]}\n"
+                         f"    COMMITTED (but not Final): {commited_but_not_final[2]}\n"
+                         f"    INCOMPLETE: {the_rest[2]}"
+                         )
+
+
+            return completed_text_segment
+
+
+    def chunk_completed_segment(self) -> list:
+
+        
+        ts_words = self.commited_not_final
+
+        if len(ts_words) <= 1:
+            logger.debug(f"--- not enough segments to chunk (<=1 words)")
+            return []
+        else:
+
+            ends = [w[1] for w in ts_words]
+
+            t = ts_words[-1][1] # start of the last word
+            e = ends[-2] 
+            while len(ends) > 2 and e > t:
+                ends.pop(-1)
+                e = ends[-2] 
+
+            if e <= t:
+                
+                self.chunk_at(e)
+
+                n_commited_words = len(ends)-1
+
+                words_to_commit = ts_words[:n_commited_words]
+                self.final_transcript.extend(words_to_commit)
+                self.commited_not_final = ts_words[n_commited_words:]
+
+                return words_to_commit
+
+
+
+            else:
+                logger.debug(f"--- last segment not within commited area")
+                return []
+
+
+    def chunk_at(self, time):
+        """trims the hypothesis and audio buffer at "time" """
+        logger.debug(f"chunking at {time:2.2f}s")
+
+        logger.debug(
+            f"len of audio buffer before chunking is: {len(self.audio_buffer)/self.SAMPLING_RATE:2.2f}s"
+            )
+
+
+        self.transcript_buffer.pop_commited(time)
+        cut_seconds = time - self.buffer_time_offset
+        self.audio_buffer = self.audio_buffer[int(cut_seconds * self.SAMPLING_RATE) :]
+        self.buffer_time_offset = time
+
+        logger.debug(
+            f"len of audio buffer is now: {len(self.audio_buffer)/self.SAMPLING_RATE:2.2f}s"
+            )
+
+    def words_to_sentences(self, words):
+        """Uses self.tokenize for sentence segmentation of words.
+        Returns: [(beg,end,"sentence 1"),...]
+        """
+
+
+        cwords = [w for w in words]
+        t = self.asr.sep.join(o[2] for o in cwords)
+        logger.debug(f"[Sentence-segmentation] Raw Text: {t}")
+
+        s = self.tokenize([t])
+        out = []
+        while s:
+            beg = None
+            end = None
+            sent = s.pop(0).strip()
+            fsent = sent
+            while cwords:
+                b, e, w = cwords.pop(0)
+                w = w.strip()
+                if beg is None and sent.startswith(w):
+                    beg = b
+                if end is None and sent == w:
+                    end = e
+                if beg is not None and end is not None:
+                    out.append((beg, end, fsent))
+                    break
+                sent = sent[len(w) :].strip()
+        
+        return out
+
+    def finish(self):
+        """Flush the incomplete text when the whole processing ends.
+        Returns: the same format as self.process_iter()
+        """
+        o = self.transcript_buffer.complete()
+        f = self.concatenate_tsw(o)
+        if f[1] is not None:
+            logger.debug(f"last, noncommited: {f[0]*1000:.0f}-{f[1]*1000:.0f}: {f[2]}")
+        self.buffer_time_offset += len(self.audio_buffer) / 16000
+        return f
+
+    def concatenate_tsw(
+        self,
+        tsw,
+        sep=None,
+        offset=0,
+    ):
+        # concatenates the timestamped words or sentences into one sequence that is flushed in one line
+        # sents: [(beg1, end1, "sentence1"), ...] or [] if empty
+        # return: (beg1,end-of-last-sentence,"concatenation of sentences") or (None, None, "") if empty
+        if sep is None:
+            sep = self.asr.sep
+
+        
+
+        t = sep.join(s[2] for s in tsw)
+        if len(tsw) == 0:
+            b = None
+            e = None
+        else:
+            b = offset + tsw[0][0]
+            e = offset + tsw[-1][1]
+        return (b, e, t)
+
+
+class VACOnlineASRProcessor(OnlineASRProcessor):
+    """Wraps OnlineASRProcessor with VAC (Voice Activity Controller).
+
+    It works the same way as OnlineASRProcessor: it receives chunks of audio (e.g. 0.04 seconds),
+    it runs VAD and continuously detects whether there is speech or not.
+    When it detects end of speech (non-voice for 500ms), it makes OnlineASRProcessor to end the utterance immediately.
+    """
+
+# TODO: VACOnlineASRProcessor does not break after chunch length is reached, this can lead to overflow!
+
+    def __init__(self, online_chunk_size, *a, **kw):
+        self.online_chunk_size = online_chunk_size
+
+        self.online = OnlineASRProcessor(*a, **kw)
+
+        # VAC:
+        import torch
+
+        model, _ = torch.hub.load(repo_or_dir="snakers4/silero-vad", model="silero_vad")
+        from src.whisper_streaming.silero_vad_iterator import FixedVADIterator
+
+        self.vac = FixedVADIterator(
+            model
+        )  # we use the default options there: 500ms silence, 100ms padding, etc.
+
+        self.logfile = self.online.logfile
+        self.init()
+
+    def init(self):
+        self.online.init()
+        self.vac.reset_states()
+        self.current_online_chunk_buffer_size = 0
+
+        self.is_currently_final = False
+
+        self.status = None  # or "voice" or "nonvoice"
+        self.audio_buffer = np.array([], dtype=np.float32)
+        self.buffer_offset = 0  # in frames
+
+    def clear_buffer(self):
+        self.buffer_offset += len(self.audio_buffer)
+        self.audio_buffer = np.array([], dtype=np.float32)
+
+    def insert_audio_chunk(self, audio):
+        res = self.vac(audio)
+        self.audio_buffer = np.append(self.audio_buffer, audio)
+
+        if res is not None:
+            frame = list(res.values())[0] - self.buffer_offset
+            if "start" in res and "end" not in res:
+                self.status = "voice"
+                send_audio = self.audio_buffer[frame:]
+                self.online.init(
+                    offset=(frame + self.buffer_offset) / self.SAMPLING_RATE
+                )
+                self.online.insert_audio_chunk(send_audio)
+                self.current_online_chunk_buffer_size += len(send_audio)
+                self.clear_buffer()
+            elif "end" in res and "start" not in res:
+                self.status = "nonvoice"
+                send_audio = self.audio_buffer[:frame]
+                self.online.insert_audio_chunk(send_audio)
+                self.current_online_chunk_buffer_size += len(send_audio)
+                self.is_currently_final = True
+                self.clear_buffer()
+            else:
+                beg = res["start"] - self.buffer_offset
+                end = res["end"] - self.buffer_offset
+                self.status = "nonvoice"
+                send_audio = self.audio_buffer[beg:end]
+                self.online.init(offset=(beg + self.buffer_offset) / self.SAMPLING_RATE)
+                self.online.insert_audio_chunk(send_audio)
+                self.current_online_chunk_buffer_size += len(send_audio)
+                self.is_currently_final = True
+                self.clear_buffer()
+        else:
+            if self.status == "voice":
+                self.online.insert_audio_chunk(self.audio_buffer)
+                self.current_online_chunk_buffer_size += len(self.audio_buffer)
+                self.clear_buffer()
+            else:
+                # We keep 1 second because VAD may later find start of voice in it.
+                # But we trim it to prevent OOM.
+                self.buffer_offset += max(
+                    0, len(self.audio_buffer) - self.SAMPLING_RATE
+                )
+                self.audio_buffer = self.audio_buffer[-self.SAMPLING_RATE :]
+
+    def process_iter(self):
+        if self.is_currently_final:
+            return self.finish()
+        elif (
+            self.current_online_chunk_buffer_size
+            > self.SAMPLING_RATE * self.online_chunk_size
+        ):
+            self.current_online_chunk_buffer_size = 0
+            ret = self.online.process_iter()
+            return ret
+        else:
+            logger.debug("no online update, only VAD")
+            return (None, None, "")
+
+    def finish(self):
+        ret = self.online.finish()
+        self.current_online_chunk_buffer_size = 0
+        self.is_currently_final = False
+        return ret

src/whisper_streaming/silero_vad_iterator.py

@@ -0,0 +1,163 @@
+import torch
+
+# This is copied from silero-vad's vad_utils.py:
+# https://github.com/snakers4/silero-vad/blob/f6b1294cb27590fb2452899df98fb234dfef1134/utils_vad.py#L340
+# (except changed defaults)
+
+# Their licence is MIT, same as ours: https://github.com/snakers4/silero-vad/blob/f6b1294cb27590fb2452899df98fb234dfef1134/LICENSE
+
+
+class VADIterator:
+    def __init__(
+        self,
+        model,
+        threshold: float = 0.5,
+        sampling_rate: int = 16000,
+        min_silence_duration_ms: int = 500,  # makes sense on one recording that I checked
+        speech_pad_ms: int = 100,  # same
+    ):
+        """
+        Class for stream imitation
+
+        Parameters
+        ----------
+        model: preloaded .jit silero VAD model
+
+        threshold: float (default - 0.5)
+            Speech threshold. Silero VAD outputs speech probabilities for each audio chunk, probabilities ABOVE this value are considered as SPEECH.
+            It is better to tune this parameter for each dataset separately, but "lazy" 0.5 is pretty good for most datasets.
+
+        sampling_rate: int (default - 16000)
+            Currently silero VAD models support 8000 and 16000 sample rates
+
+        min_silence_duration_ms: int (default - 100 milliseconds)
+            In the end of each speech chunk wait for min_silence_duration_ms before separating it
+
+        speech_pad_ms: int (default - 30 milliseconds)
+            Final speech chunks are padded by speech_pad_ms each side
+        """
+
+        self.model = model
+        self.threshold = threshold
+        self.sampling_rate = sampling_rate
+
+        if sampling_rate not in [8000, 16000]:
+            raise ValueError(
+                "VADIterator does not support sampling rates other than [8000, 16000]"
+            )
+
+        self.min_silence_samples = sampling_rate * min_silence_duration_ms / 1000
+        self.speech_pad_samples = sampling_rate * speech_pad_ms / 1000
+        self.reset_states()
+
+    def reset_states(self):
+
+        self.model.reset_states()
+        self.triggered = False
+        self.temp_end = 0
+        self.current_sample = 0
+
+    def __call__(self, x, return_seconds=False):
+        """
+        x: torch.Tensor
+            audio chunk (see examples in repo)
+
+        return_seconds: bool (default - False)
+            whether return timestamps in seconds (default - samples)
+        """
+
+        if not torch.is_tensor(x):
+            try:
+                x = torch.Tensor(x)
+            except:
+                raise TypeError("Audio cannot be casted to tensor. Cast it manually")
+
+        window_size_samples = len(x[0]) if x.dim() == 2 else len(x)
+        self.current_sample += window_size_samples
+
+        speech_prob = self.model(x, self.sampling_rate).item()
+
+        if (speech_prob >= self.threshold) and self.temp_end:
+            self.temp_end = 0
+
+        if (speech_prob >= self.threshold) and not self.triggered:
+            self.triggered = True
+            speech_start = self.current_sample - self.speech_pad_samples
+            return {
+                "start": (
+                    int(speech_start)
+                    if not return_seconds
+                    else round(speech_start / self.sampling_rate, 1)
+                )
+            }
+
+        if (speech_prob < self.threshold - 0.15) and self.triggered:
+            if not self.temp_end:
+                self.temp_end = self.current_sample
+            if self.current_sample - self.temp_end < self.min_silence_samples:
+                return None
+            else:
+                speech_end = self.temp_end + self.speech_pad_samples
+                self.temp_end = 0
+                self.triggered = False
+                return {
+                    "end": (
+                        int(speech_end)
+                        if not return_seconds
+                        else round(speech_end / self.sampling_rate, 1)
+                    )
+                }
+
+        return None
+
+
+#######################
+# because Silero now requires exactly 512-sized audio chunks
+
+import numpy as np
+
+
+class FixedVADIterator(VADIterator):
+    """It fixes VADIterator by allowing to process any audio length, not only exactly 512 frames at once.
+    If audio to be processed at once is long and multiple voiced segments detected,
+    then __call__ returns the start of the first segment, and end (or middle, which means no end) of the last segment.
+    """
+
+    def reset_states(self):
+        super().reset_states()
+        self.buffer = np.array([], dtype=np.float32)
+
+    def __call__(self, x, return_seconds=False):
+        self.buffer = np.append(self.buffer, x)
+        ret = None
+        while len(self.buffer) >= 512:
+            r = super().__call__(self.buffer[:512], return_seconds=return_seconds)
+            self.buffer = self.buffer[512:]
+            if ret is None:
+                ret = r
+            elif r is not None:
+                if "end" in r:
+                    ret["end"] = r["end"]  # the latter end
+                if "start" in r and "end" in ret:  # there is an earlier start.
+                    # Remove end, merging this segment with the previous one.
+                    del ret["end"]
+        return ret if ret != {} else None
+
+
+if __name__ == "__main__":
+    # test/demonstrate the need for FixedVADIterator:
+
+    import torch
+
+    model, _ = torch.hub.load(repo_or_dir="snakers4/silero-vad", model="silero_vad")
+    vac = FixedVADIterator(model)
+    #   vac = VADIterator(model)  # the second case crashes with this
+
+    # this works: for both
+    audio_buffer = np.array([0] * (512), dtype=np.float32)
+    vac(audio_buffer)
+
+    # this crashes on the non FixedVADIterator with
+    # ops.prim.RaiseException("Input audio chunk is too short", "builtins.ValueError")
+    audio_buffer = np.array([0] * (512 - 1), dtype=np.float32)
+    vac(audio_buffer)

src/whisper_streaming/whisper_online.py

@@ -0,0 +1,235 @@
+#!/usr/bin/env python3
+import sys
+import numpy as np
+import librosa
+from functools import lru_cache
+import time
+import logging
+from .backends import FasterWhisperASR, MLXWhisper, WhisperTimestampedASR, OpenaiApiASR
+from .online_asr import OnlineASRProcessor, VACOnlineASRProcessor
+
+logger = logging.getLogger(__name__)
+
+
+
+WHISPER_LANG_CODES = "af,am,ar,as,az,ba,be,bg,bn,bo,br,bs,ca,cs,cy,da,de,el,en,es,et,eu,fa,fi,fo,fr,gl,gu,ha,haw,he,hi,hr,ht,hu,hy,id,is,it,ja,jw,ka,kk,km,kn,ko,la,lb,ln,lo,lt,lv,mg,mi,mk,ml,mn,mr,ms,mt,my,ne,nl,nn,no,oc,pa,pl,ps,pt,ro,ru,sa,sd,si,sk,sl,sn,so,sq,sr,su,sv,sw,ta,te,tg,th,tk,tl,tr,tt,uk,ur,uz,vi,yi,yo,zh".split(
+    ","
+)
+
+
+def create_tokenizer(lan):
+    """returns an object that has split function that works like the one of MosesTokenizer"""
+
+    assert (
+        lan in WHISPER_LANG_CODES
+    ), "language must be Whisper's supported lang code: " + " ".join(WHISPER_LANG_CODES)
+
+    if lan == "uk":
+        import tokenize_uk
+
+        class UkrainianTokenizer:
+            def split(self, text):
+                return tokenize_uk.tokenize_sents(text)
+
+        return UkrainianTokenizer()
+
+    # supported by fast-mosestokenizer
+    if (
+        lan
+        in "as bn ca cs de el en es et fi fr ga gu hi hu is it kn lt lv ml mni mr nl or pa pl pt ro ru sk sl sv ta te yue zh".split()
+    ):
+        from mosestokenizer import MosesSentenceSplitter        
+
+        return MosesSentenceSplitter(lan)
+
+    # the following languages are in Whisper, but not in wtpsplit:
+    if (
+        lan
+        in "as ba bo br bs fo haw hr ht jw lb ln lo mi nn oc sa sd sn so su sw tk tl tt".split()
+    ):
+        logger.debug(
+            f"{lan} code is not supported by wtpsplit. Going to use None lang_code option."
+        )
+        lan = None
+
+    from wtpsplit import WtP
+
+    # downloads the model from huggingface on the first use
+    wtp = WtP("wtp-canine-s-12l-no-adapters")
+
+    class WtPtok:
+        def split(self, sent):
+            return wtp.split(sent, lang_code=lan)
+
+    return WtPtok()
+
+
+def add_shared_args(parser):
+    """shared args for simulation (this entry point) and server
+    parser: argparse.ArgumentParser object
+    """
+    parser.add_argument(
+        "--min-chunk-size",
+        type=float,
+        default=1.0,
+        help="Minimum audio chunk size in seconds. It waits up to this time to do processing. If the processing takes shorter time, it waits, otherwise it processes the whole segment that was received by this time.",
+    )
+    parser.add_argument(
+        "--model",
+        type=str,
+        # default="large-v3-turbo",
+        # choices="tiny.en,tiny,base.en,base,small.en,small,medium.en,medium,large-v1,large-v2,large-v3,large,large-v3-turbo".split(
+        #     ","
+        # ),
+        help="Name size of the Whisper model to use (default: large-v2). The model is automatically downloaded from the model hub if not present in model cache dir.",
+    )
+    parser.add_argument(
+        "--model_cache_dir",
+        type=str,
+        default=None,
+        help="Overriding the default model cache dir where models downloaded from the hub are saved",
+    )
+    parser.add_argument(
+        "--model_dir",
+        type=str,
+        default=None,
+        help="Dir where Whisper model.bin and other files are saved. This option overrides --model and --model_cache_dir parameter.",
+    )
+    parser.add_argument(
+        "--lan",
+        "--language",
+        type=str,
+        default="auto",
+        help="Source language code, e.g. en,de,cs, or 'auto' for language detection.",
+    )
+    parser.add_argument(
+        "--task",
+        type=str,
+        default="transcribe",
+        choices=["transcribe", "translate"],
+        help="Transcribe or translate.",
+    )
+    parser.add_argument(
+        "--backend",
+        type=str,
+        default="faster-whisper",
+        choices=["faster-whisper", "whisper_timestamped", "mlx-whisper", "openai-api"],
+        help="Load only this backend for Whisper processing.",
+    )
+    parser.add_argument(
+        "--vac",
+        action="store_true",
+        default=False,
+        help="Use VAC = voice activity controller. Recommended. Requires torch.",
+    )
+    parser.add_argument(
+        "--vac-chunk-size", type=float, default=0.04, help="VAC sample size in seconds."
+    )
+    parser.add_argument(
+        "--vad",
+        action="store_true",
+        default=False,
+        help="Use VAD = voice activity detection, with the default parameters.",
+    )
+    parser.add_argument(
+        "--buffer_trimming",
+        type=str,
+        default="segment",
+        choices=["sentence", "segment"],
+        help='Buffer trimming strategy -- trim completed sentences marked with punctuation mark and detected by sentence segmenter, or the completed segments returned by Whisper. Sentence segmenter must be installed for "sentence" option.',
+    )
+    parser.add_argument(
+        "--buffer_trimming_sec",
+        type=float,
+        default=15,
+        help="Buffer trimming length threshold in seconds. If buffer length is longer, trimming sentence/segment is triggered.",
+    )
+    parser.add_argument(
+        "-l",
+        "--log-level",
+        dest="log_level",
+        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+        help="Set the log level",
+        default="DEBUG",
+    )
+
+def backend_factory(args):
+    backend = args.backend
+    if backend == "openai-api":
+        logger.debug("Using OpenAI API.")
+        asr = OpenaiApiASR(lan=args.lan)
+    else:
+        if backend == "faster-whisper":
+            asr_cls = FasterWhisperASR
+        elif backend == "mlx-whisper":
+            asr_cls = MLXWhisper
+        else:
+            asr_cls = WhisperTimestampedASR
+
+        # Only for FasterWhisperASR and WhisperTimestampedASR
+        size = args.model
+        t = time.time()
+        logger.info(f"Loading Whisper {size} model for {args.lan}...")
+        asr = asr_cls(
+            modelsize=size,
+            lan=args.lan,
+            cache_dir=args.model_cache_dir,
+            model_dir=args.model_dir,
+        )
+        e = time.time()
+        logger.info(f"done. It took {round(e-t,2)} seconds.")
+
+    # Apply common configurations
+    if getattr(args, "vad", False):  # Checks if VAD argument is present and True
+        logger.info("Setting VAD filter")
+        asr.use_vad()
+
+    language = args.lan
+    if args.task == "translate":
+        asr.set_translate_task()
+        tgt_language = "en"  # Whisper translates into English
+    else:
+        tgt_language = language  # Whisper transcribes in this language
+
+    # Create the tokenizer
+    if args.buffer_trimming == "sentence":
+
+        tokenizer = create_tokenizer(tgt_language)
+    else:
+        tokenizer = None
+    return asr, tokenizer
+
+def online_factory(args, asr, tokenizer, logfile=sys.stderr):
+    if args.vac:
+        online = VACOnlineASRProcessor(
+            args.min_chunk_size,
+            asr,
+            tokenizer,
+            logfile=logfile,
+            buffer_trimming=(args.buffer_trimming, args.buffer_trimming_sec),
+        )
+    else:
+        online = OnlineASRProcessor(
+            asr,
+            tokenizer,
+            logfile=logfile,
+            buffer_trimming=(args.buffer_trimming, args.buffer_trimming_sec),
+        )
+    return online
+  
+def asr_factory(args, logfile=sys.stderr):
+    """
+    Creates and configures an ASR and ASR Online instance based on the specified backend and arguments.
+    """
+    asr, tokenizer = backend_factory(args)
+    online = online_factory(args, asr, tokenizer, logfile=logfile)
+    return asr, online
+
+def set_logging(args, logger, others=[]):
+    logging.basicConfig(format="%(levelname)s\t%(message)s")  # format='%(name)s
+    logger.setLevel(args.log_level)
+
+    for other in others:
+        logging.getLogger(other).setLevel(args.log_level)
+
+

whisper_fastapi_online_server.py

@@ -0,0 +1,391 @@
+import io
+import requests
+import argparse
+import asyncio
+import numpy as np
+import ffmpeg
+from time import time
+
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi.responses import HTMLResponse
+from fastapi.middleware.cors import CORSMiddleware
+
+from src.whisper_streaming.whisper_online import backend_factory, online_factory, add_shared_args
+
+
+import logging
+import logging.config
+from transformers import pipeline
+
+MODEL_NAME = 'Helsinki-NLP/opus-tatoeba-en-ja'
+TRANSLATOR = pipeline('translation', model=MODEL_NAME, device='cuda')
+TRANSLATOR('Warming up!')
+
+API_KEY = '3c2b8b0f-4fa9-4eb7-b67d-7cae25546051:fx' # 自身の API キーを指定
+
+SOURCE_LANG = 'EN'
+TARGET_LANG = 'JA'
+
+def translator_wrapper(source_text, mode='deepl'):
+    if mode == 'deepl':
+        params = {
+                    'auth_key' : API_KEY,
+                    'text' : source_text,
+                    'source_lang' : SOURCE_LANG, # 翻訳対象の言語
+                    "target_lang": TARGET_LANG  # 翻訳後の言語
+                }
+
+        # リクエストを投げる
+        try:
+            request = requests.post("https://api-free.deepl.com/v2/translate", data=params, timeout=5) # URIは有償版, 無償版で異なるため要注意
+            result = request.json()['translations'][0]['text']
+        except requests.exceptions.Timeout:
+            result = "(timed out)"
+        return result
+
+    elif mode == 'marianmt':
+        return TRANSLATOR(source_text)[0]['translation_text']
+
+    elif mode == 'google':
+        import  requests
+
+        # https://www.eyoucms.com/news/ziliao/other/29445.html
+        language_type = ""
+        target = 'ja-jp'
+        url = "https://translation.googleapis.com/language/translate/v2"
+        data = {
+            'key':"AIzaSyCX0-Wdxl_rgvcZzklNjnqJ1W9YiKjcHUs", #  認証の設定:APIキー
+            'source': language_type,
+            'target': target,
+            'q': source_text,
+            'format': "text"
+        }
+        #headers = {'X-HTTP-Method-Override': 'GET'}
+        #response = requests.post(url, data=data, headers=headers)
+        response = requests.post(url, data)
+        # print(response.json())
+        print(response)
+        res = response.json()
+        print(res["data"]["translations"][0]["translatedText"])
+        result = res["data"]["translations"][0]["translatedText"]
+        print(result)
+        return result
+
+
+def setup_logging():
+    logging_config = {
+        'version': 1,
+        'disable_existing_loggers': False,
+        'formatters': {
+            'standard': {
+                'format': '%(asctime)s %(levelname)s [%(name)s]: %(message)s',
+            },
+        },
+        'handlers': {
+            'console': {
+                'level': 'INFO',
+                'class': 'logging.StreamHandler',
+                'formatter': 'standard',
+            },
+        },
+        'root': {
+            'handlers': ['console'],
+            'level': 'DEBUG',
+        },
+        'loggers': {
+            'uvicorn': {
+                'handlers': ['console'],
+                'level': 'INFO',
+                'propagate': False,
+            },
+            'uvicorn.error': {
+                'level': 'INFO',
+            },
+            'uvicorn.access': {
+                'level': 'INFO',
+            },
+            'src.whisper_streaming.online_asr': {  # Add your specific module here
+                'handlers': ['console'],
+                'level': 'DEBUG',
+                'propagate': False,
+            },
+            'src.whisper_streaming.whisper_streaming': {  # Add your specific module here
+                'handlers': ['console'],
+                'level': 'DEBUG',
+                'propagate': False,
+            },
+        },
+    }
+
+    logging.config.dictConfig(logging_config)
+
+setup_logging()
+logger = logging.getLogger(__name__)
+
+
+
+
+
+
+app = FastAPI()
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+parser = argparse.ArgumentParser(description="Whisper FastAPI Online Server")
+parser.add_argument(
+    "--host",
+    type=str,
+    default="localhost",
+    help="The host address to bind the server to.",
+)
+parser.add_argument(
+    "--port", type=int, default=8000, help="The port number to bind the server to."
+)
+parser.add_argument(
+    "--warmup-file",
+    type=str,
+    dest="warmup_file",
+    help="The path to a speech audio wav file to warm up Whisper so that the very first chunk processing is fast. It can be e.g. https://github.com/ggerganov/whisper.cpp/raw/master/samples/jfk.wav .",
+)
+
+parser.add_argument(
+    "--diarization",
+    type=bool,
+    default=False,
+    help="Whether to enable speaker diarization.",
+)
+
+
+add_shared_args(parser)
+args = parser.parse_args()
+# args.model = 'medium'
+
+asr, tokenizer = backend_factory(args)
+
+if args.diarization:
+    from src.diarization.diarization_online import DiartDiarization
+
+
+# Load demo HTML for the root endpoint
+with open("src/web/live_transcription.html", "r", encoding="utf-8") as f:
+    html = f.read()
+
+
+@app.get("/")
+async def get():
+    return HTMLResponse(html)
+
+
+SAMPLE_RATE = 16000
+CHANNELS = 1
+SAMPLES_PER_SEC = SAMPLE_RATE * int(args.min_chunk_size)
+BYTES_PER_SAMPLE = 2  # s16le = 2 bytes per sample
+BYTES_PER_SEC = SAMPLES_PER_SEC * BYTES_PER_SAMPLE
+
+
+async def start_ffmpeg_decoder():
+    """
+    Start an FFmpeg process in async streaming mode that reads WebM from stdin
+    and outputs raw s16le PCM on stdout. Returns the process object.
+    """
+    process = (
+        ffmpeg.input("pipe:0", format="webm")
+        .output(
+            "pipe:1",
+            format="s16le",
+            acodec="pcm_s16le",
+            ac=CHANNELS,
+            ar=str(SAMPLE_RATE),
+        )
+        .run_async(pipe_stdin=True, pipe_stdout=True, pipe_stderr=True)
+    )
+    return process
+
+
+
+@app.websocket("/asr")
+async def websocket_endpoint(websocket: WebSocket):
+    await websocket.accept()
+    print("WebSocket connection opened.")
+
+    ffmpeg_process = await start_ffmpeg_decoder()
+    pcm_buffer = bytearray()
+    print("Loading online.")
+    online = online_factory(args, asr, tokenizer)
+    print("Online loaded.")
+
+    if args.diarization:
+        diarization = DiartDiarization(SAMPLE_RATE)
+
+    # Continuously read decoded PCM from ffmpeg stdout in a background task
+    async def ffmpeg_stdout_reader():
+        nonlocal pcm_buffer
+        loop = asyncio.get_event_loop()
+        full_transcription = ""
+        beg = time()
+        
+        chunk_history = []  # Will store dicts: {beg, end, text, speaker}
+
+        buffers = [{'speaker': '0', 'text': '', 'translation': None}]
+        buffer_line = ''
+        
+        while True:
+            print('in while')
+            try:
+                print('try in while')
+                elapsed_time = int(time() - beg)
+                beg = time()
+                print('before await loop.run_in_executor()')
+                chunk = await loop.run_in_executor(None, ffmpeg_process.stdout.read, 32000 * elapsed_time)
+
+                print('before if not chunk')
+                if not chunk:  # The first chunk will be almost empty, FFmpeg is still starting up
+                    chunk = await loop.run_in_executor(None, ffmpeg_process.stdout.read, 4096)
+                    if not chunk:  # FFmpeg might have closed
+                        print("FFmpeg stdout closed.")
+                        break
+
+                pcm_buffer.extend(chunk)
+
+                print('before if len(pcm_buffer)')
+                if len(pcm_buffer) >= BYTES_PER_SEC:
+                    print('in if len(pcm_buffer)')
+                    # Convert int16 -> float32
+                    pcm_array = (np.frombuffer(pcm_buffer, dtype=np.int16).astype(np.float32) / 32768.0)
+                    pcm_buffer = bytearray()  # Initialize the PCM buffer
+                    online.insert_audio_chunk(pcm_array)
+                    beg_trans, end_trans, trans = online.process_iter()
+                    
+                    if trans:
+                        chunk_history.append({
+                        "beg": beg_trans,
+                        "end": end_trans,
+                        "text": trans,
+                        "speaker": "0"
+                        })
+                    full_transcription += trans
+                    
+                    # ----------------
+                    # Process buffer
+                    # ----------------
+                    if args.vac:
+                        # We need to access the underlying online object to get the buffer
+                        buffer = online.online.concatenate_tsw(online.online.transcript_buffer.buffer)[2]
+                    else:
+                        buffer = online.concatenate_tsw(online.transcript_buffer.buffer)[2]
+
+                    if buffer in full_transcription:  # With VAC, the buffer is not updated until the next chunk is processed
+                        buffer = ""
+
+                    buffer_line += buffer
+                                        
+                    punctuations = (',', '.', '?', '!', 'and', 'or', 'but', 'however')
+                    if any(punctuation in buffer_line for punctuation in punctuations):
+                        last_punctuation_index = max((buffer_line.rfind(p) + len(p) + 1) for p in punctuations if p in buffer_line)
+                        extracted_text = buffer_line[:last_punctuation_index]
+                        buffer_line = buffer_line[last_punctuation_index:]
+                        buffers.append({'speaker': '0', 'text': extracted_text, 'translation': None})
+
+                    # Translation loop
+                    print('buffers for loop')
+                    for i, buffer in enumerate(buffers):
+                        print(i, buffer)
+                        if buffer['translation'] is not None:
+                            continue
+                        if buffer['text'] == '':
+                            continue
+
+                        transcription = buffer['text']
+                        buffers[i]['translation'] = translator_wrapper(transcription, mode='google')
+                        buffers[i]['text'] += ('|' + buffers[i]['translation'])
+
+                    # ----------------
+                    # Process lines
+                    # ----------------
+                    print('Process lines')
+                    lines = [{"speaker": "0", "text": ""}]
+                    
+                    if args.diarization:
+                        await diarization.diarize(pcm_array)
+                        # diarization.assign_speakers_to_chunks(chunk_history)
+                        chunk_history = diarization.assign_speakers_to_chunks(chunk_history)
+
+                    for ch in chunk_history:
+                        if args.diarization and ch["speaker"] and ch["speaker"][-1] != lines[-1]["speaker"]:
+                            lines.append({"speaker": ch["speaker"], "text": ch['text']})
+
+                        else:
+                            lines.append({"speaker": ch["speaker"], "text": ch['text']})
+
+                    for i, line in enumerate(lines):
+                        if line['text'].strip() == '':
+                            continue
+                        # translation = translator(line['text'])[0]['translation_text']
+                        # translation = translation.replace(' ', '')
+                        # lines[i]['text'] = line['text'] + translation
+                        lines[i]['text'] = line['text']
+
+                    # translation = translator(buffer)[0]['translation_text']
+                    # translation = translation.replace(' ', '')
+                    # buffer += translation
+
+                    print('Before making response')
+                    response = {"lines": buffers, "buffer": ''}
+                    await websocket.send_json(response)
+                    
+            except Exception as e:
+                print(f"Exception in ffmpeg_stdout_reader: {e}")
+                break
+
+        print("Exiting ffmpeg_stdout_reader...")
+
+    stdout_reader_task = asyncio.create_task(ffmpeg_stdout_reader())
+
+    try:
+        while True:
+            # Receive incoming WebM audio chunks from the client
+            message = await websocket.receive_bytes()
+            # Pass them to ffmpeg via stdin
+            ffmpeg_process.stdin.write(message)
+            ffmpeg_process.stdin.flush()
+
+    except WebSocketDisconnect:
+        print("WebSocket connection closed.")
+    except Exception as e:
+        print(f"Error in websocket loop: {e}")
+    finally:
+        # Clean up ffmpeg and the reader task
+        try:
+            ffmpeg_process.stdin.close()
+        except:
+            pass
+        stdout_reader_task.cancel()
+
+        try:
+            ffmpeg_process.stdout.close()
+        except:
+            pass
+
+        ffmpeg_process.wait()
+        del online
+        
+        if args.diarization:
+            # Stop Diart
+            diarization.close()
+
+
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(
+        "whisper_fastapi_online_server:app", host=args.host, port=args.port, reload=True,
+        log_level="info"
+    )