Revert "fix(transcription): decode audio ourselves so whisper works on PyAV 19"

This reverts commit 717576d. A copy of faster-whisper's decoder is more
code to review and maintain than a temporary pin, and it lacked the
gc.collect() upstream uses against PyAV resampler leaks
(SYSTRAN/faster-whisper#390). Keep the av<19 pin instead: 18.1.0 is the
newest PyAV that works with faster-whisper 1.2.1 (17.1.0 on Python
3.10, which PyAV 18 no longer supports). Remove the pin once a
faster-whisper release includes SYSTRAN/faster-whisper#1495.

Claude-Session: https://claude.ai/code/session_01S1CTNRry7FQw1tK74yFpa3

Author: arnoutvw

pyproject.toml

@@ -41,8 +41,10 @@ proxy = [
 # Required only for the local transcription engine (TELEGRAM_TRANSCRIBE_ENGINE=whisper).
 whisper = [
     "faster-whisper>=1.1.0",
-    # Decoded directly (see transcription._decode_audio), not only via faster-whisper.
-    "av>=11",
+    # faster-whisper 1.2.1 passes av.open(metadata_errors=...), which PyAV 19
+    # removed; 18.1.0 is the newest that works. Drop once a faster-whisper
+    # release includes SYSTRAN/faster-whisper#1495.
+    "av<19",
 ]
 
 [project.urls]

telegram_mcp/transcription.py

@@ -567,42 +567,9 @@ def _load_whisper_model(settings: tuple):
     return model
 
 
-def _decode_audio(data: bytes, sampling_rate: int):
-    """Mono float32 samples at ``sampling_rate``, decoded with PyAV.
-
-    Mirrors faster_whisper.audio.decode_audio, which faster-whisper 1.2.1
-    cannot run on PyAV 19: it passes ``av.open(metadata_errors=...)``, an
-    argument PyAV 19 removed (fix pending upstream in
-    SYSTRAN/faster-whisper#1495). Handing the model an array skips that
-    function entirely, so any PyAV version works. Drop this once a
-    faster-whisper release carries the fix.
-    """
-    import av
-    import numpy as np
-
-    resampler = av.AudioResampler(format="s16", layout="mono", rate=sampling_rate)
-    chunks = []
-    with av.open(io.BytesIO(data), mode="r") as container:
-        frames = container.decode(audio=0)
-        while True:
-            try:
-                frame = next(frames)
-            except StopIteration:
-                break
-            except av.error.InvalidDataError:
-                continue  # a corrupt packet costs one frame, not the recording
-            frame.pts = None  # the resampler rejects non-monotonic timestamps
-            chunks.extend(out.to_ndarray() for out in resampler.resample(frame))
-    chunks.extend(out.to_ndarray() for out in resampler.resample(None))
-    if not chunks:
-        return np.zeros(0, dtype=np.float32)
-    return np.concatenate(chunks, axis=None).astype(np.float32) / 32768.0
-
-
 def _run_whisper(data: bytes, settings: tuple, language: Optional[str]) -> tuple:
     model = _load_whisper_model(settings)
-    audio = _decode_audio(data, model.feature_extractor.sampling_rate)
-    segments, info = model.transcribe(audio, language=language, vad_filter=True)
+    segments, info = model.transcribe(io.BytesIO(data), language=language, vad_filter=True)
     # segments is a lazy generator: the actual decoding happens here, so it
     # must be consumed inside the worker thread.
     text = "".join(segment.text for segment in segments).strip()

tests/test_transcription.py

@@ -980,11 +980,10 @@ class _FakeWhisperModel:
     def __init__(self, name, device=None, compute_type=None, download_root=None):
         self.args = (name, device, compute_type, download_root)
         self.calls = []
-        self.feature_extractor = SimpleNamespace(sampling_rate=16000)
         _FakeWhisperModel.instances.append(self)
 
     def transcribe(self, audio, language=None, vad_filter=False):
-        self.calls.append({"audio": audio, "language": language})
+        self.calls.append({"audio": audio.read(), "language": language})
         segments = (SimpleNamespace(text=t) for t in [" hallo", " wereld "])
         return segments, SimpleNamespace(language="nl")
 
@@ -1000,7 +999,6 @@ def fake_whisper(monkeypatch):
     monkeypatch.setattr(transcription, "whisper_available", lambda: True)
     monkeypatch.setattr(transcription, "_WHISPER_MODELS", {})
     monkeypatch.setattr(transcription, "_WHISPER_SEMAPHORE", None)
-    monkeypatch.setattr(transcription, "_decode_audio", lambda data, rate: ("decoded", data, rate))
     return _FakeWhisperModel
 
 
@@ -1025,9 +1023,7 @@ def _no_http(**kw):
     assert len(fake_whisper.instances) == 1
     model = fake_whisper.instances[0]
     assert model.args == ("large-v3-turbo", "cpu", "int8", None)
-    # The model gets decoded samples, never the raw bytes: faster-whisper's own
-    # decoder breaks on PyAV 19.
-    assert model.calls[0] == {"audio": ("decoded", b"audio", 16000), "language": None}
+    assert model.calls[0] == {"audio": b"audio", "language": None}
 
 
 @pytest.mark.asyncio
@@ -1060,33 +1056,3 @@ def _explode(self, audio, language=None, vad_filter=False):
 
     assert result["status"] == "error"
     assert "bad audio" in result["error"]
-
-
-def test_decode_audio_produces_mono_float32_at_the_requested_rate():
-    """Real PyAV round trip: a 1s 48 kHz stereo Opus-in-Ogg tone, like a
-    Telegram voice note, comes back as ~16000 mono float32 samples."""
-    av = pytest.importorskip("av")
-    np = pytest.importorskip("numpy")
-    import io as _io
-
-    buf = _io.BytesIO()
-    with av.open(buf, "w", format="ogg") as out:
-        stream = out.add_stream("libopus", rate=48000)
-        stream.layout = "stereo"
-        t = np.arange(48000) / 48000
-        tone = (np.sin(2 * np.pi * 440 * t) * 10000).astype(np.int16)
-        frame = av.AudioFrame.from_ndarray(
-            np.stack([tone, tone]).reshape(1, -1), format="s16", layout="stereo"
-        )
-        frame.sample_rate = 48000
-        for packet in stream.encode(frame):
-            out.mux(packet)
-        for packet in stream.encode(None):
-            out.mux(packet)
-
-    audio = transcription._decode_audio(buf.getvalue(), 16000)
-
-    assert audio.dtype == np.float32
-    assert audio.ndim == 1
-    assert abs(len(audio) - 16000) < 800
-    assert 0.1 < float(np.abs(audio).max()) <= 1.0