lobes-cli 0.84.3__tar.gz → 0.85.0__tar.gz

{lobes_cli-0.84.3 → lobes_cli-0.85.0}/CHANGELOG.md

@@ -4,6 +4,17 @@ All notable changes to this project are documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project
 adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.85.0] - 2026-10-09
+
+### Added
+
+- Hebrew STT (`listen_server_whisper.py`) accepts any ffmpeg-decodable upload — m4a, mp3, ogg/opus, webm, flac, non-16-bit WAV — instead of refusing everything but 16-bit PCM WAV with `invalid_wav`; an undecodable upload is a 400 `invalid_audio`.
+- Hebrew STT chunks uploads longer than the 30 s Whisper window at the quietest point near each window end and joins the pieces, instead of refusing them; `STT_MAX_AUDIO_SECONDS` (default 600) caps the total.
+
+### Changed
+
+- Hebrew STT decodes up to 440 new tokens per window (was 128), so a full 30 s window of dense speech is not truncated.
+
 ## [0.84.3] - 2026-10-07
 
 ### Changed

{lobes_cli-0.84.3 → lobes_cli-0.85.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lobes-cli
-Version: 0.84.3
+Version: 0.85.0
 Summary: lobes — run, assess, and switch the local vLLM model.
 Project-URL: Homepage, https://github.com/agentculture/lobes-cli
 Project-URL: Issues, https://github.com/agentculture/lobes-cli/issues

{lobes_cli-0.84.3 → lobes_cli-0.85.0}/docs/hebrew-realtime.md

@@ -42,6 +42,26 @@ Evidence: `docs/evidence/2026-09-hebrew-*.txt` (seven files) and
 - **An NVFP4A16 export of Gemma 4 12B damaged Hebrew** where bf16 and Google's
   QAT checkpoint did not. Check Hebrew output before promoting a quantization.
 
+### Batch transcription: formats and long clips
+
+`POST /v1/audio/transcriptions` takes any format the image's ffmpeg decodes —
+m4a/aac, mp3, ogg/opus, webm, flac, and WAV at any bit depth — not only 16-bit
+PCM WAV. A 16-bit RIFF/WAVE upload (the realtime bridge's own turn audio) is
+still read directly and never touches ffmpeg; anything else is transcoded to
+16 kHz mono PCM16 first, and an undecodable upload is a 400 `invalid_audio`.
+
+An upload longer than Whisper's 30 s window is **chunked**, not refused: each
+cut goes at the quietest 20 ms frame in the last 5 s of its window, every
+window passes the `STT_MIN_AVG_LOGPROB` gate on its own, and the non-empty
+pieces are joined with a space. `STT_MAX_AUDIO_SECONDS` (default 600) caps the
+total; past it the reply is a 413 `clip_too_long`. The upload byte cap
+(`STT_MAX_UPLOAD_BYTES`, 16 MiB) still applies first, so ten minutes of
+uncompressed 16 kHz WAV (~19 MB) needs it raised; a compressed voice note does
+not. MEASURED on the DGX Spark, 2026-10-09, with synthetic BlueTTS speech: an
+80 s m4a was transcribed in 3 windows in 3.9 s with every sentence intact at
+the seams; mp3, ogg/opus, webm, 24-bit WAV and m4a single sentences each came
+back verbatim. A real microphone recording is still UNVALIDATED (#108).
+
 ## Latency: what was built, and what it bought
 
 Measured live, a human on a reSpeaker XVF3800, from the moment the server

{lobes_cli-0.84.3 → lobes_cli-0.85.0}/lobes/templates/fleet/listen_server_whisper.py

@@ -14,7 +14,8 @@ GiB peak CUDA, ~0.14s per 9.35s clip, transformers 5.12.1 / torch
 from ``Dockerfile.parakeet``.
 
 Endpoints:
-    POST /v1/audio/transcriptions  - Transcribe an uploaded WAV file
+    POST /v1/audio/transcriptions  - Transcribe an uploaded audio file (WAV read
+                                      directly; m4a/mp3/ogg/webm/flac via ffmpeg)
     GET  /v1/health/ready          - Readiness (model loaded + CUDA live +
                                       a warm-up transcription succeeded)
 
@@ -53,14 +54,22 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 SAMPLE_RATE = 16000
-# Whisper's attention window is 30s; clips longer than that are REFUSED (a
-# clear 4xx) rather than chunked-and-joined. Two reasons: (1) chunk-joining
-# introduces boundary artifacts/duplicated words at the seam, and (2) the
-# realtime bridge's own VAD_MAX_TURN_MS defaults to exactly 30000ms
-# (CLAUDE.md's #151 material) — a well-behaved caller never sends a clip
-# longer than this window in the first place, so refusing costs nothing in
-# practice and avoids a whole class of hallucination risk at the seam.
+# Whisper's attention window is 30s. A longer upload (a phone voice note, a
+# recording) is CHUNKED into windows of at most this length and the pieces are
+# joined. Each cut is placed at the quietest frame in the last
+# CHUNK_SEARCH_SECONDS of its window (see plan_chunks), so a seam rarely lands
+# mid-word — the boundary artefacts that made earlier versions refuse instead.
+# The realtime bridge never sends more than one window (its VAD_MAX_TURN_MS
+# defaults to 30000ms), so its turns still take the single-window path.
 MAX_CLIP_SECONDS = 30.0
+CHUNK_SEARCH_SECONDS = 5.0
+CHUNK_FRAME_MS = 20
+# Total-length cap across all chunks (STT_MAX_AUDIO_SECONDS), so one upload
+# cannot hold the GPU for an unbounded number of windows.
+DEFAULT_MAX_AUDIO_SECONDS = 600.0
+# Whisper's decoder holds 448 positions; the language/task prompt takes 4.
+# A full 30s window of dense speech can exceed the old 128-token budget.
+MAX_NEW_TOKENS = 440
 MODEL_NAME = os.environ.get("STT_MODEL", "ivrit-ai/whisper-large-v3-turbo")
 DEFAULT_LANGUAGE = "he"
 
@@ -233,21 +242,37 @@ def linear_resample(samples: Sequence[float], src_rate: int, dst_rate: int) -> l
     return out
 
 
+def parse_max_audio_seconds(raw: str | None) -> float:
+    """``STT_MAX_AUDIO_SECONDS``: a positive number of seconds; empty/unset or
+    an unparseable/non-positive value falls back to the default (a typo must
+    not silently disable the cap)."""
+    if raw is None or not raw.strip():
+        return DEFAULT_MAX_AUDIO_SECONDS
+    try:
+        parsed = float(raw.strip())
+    except ValueError:
+        return DEFAULT_MAX_AUDIO_SECONDS
+    return parsed if parsed > 0 and math.isfinite(parsed) else DEFAULT_MAX_AUDIO_SECONDS
+
+
+MAX_AUDIO_SECONDS = parse_max_audio_seconds(os.environ.get("STT_MAX_AUDIO_SECONDS"))
+
+
 def _clip_too_long_message(duration: float, max_seconds: float) -> str:
     """Shared wording for a refused clip, whichever check found it too long
     (the post-decode sample-count check, or the pre-decode WAV-header peek)."""
     return (
         f"clip too long: {duration:.1f}s exceeds the {max_seconds:.0f}s "
-        "Whisper window (refused, not chunked — see MAX_CLIP_SECONDS)"
+        "total-audio cap (STT_MAX_AUDIO_SECONDS)"
     )
 
 
 def validate_clip_duration(
-    num_samples: int, sample_rate: int, max_seconds: float = MAX_CLIP_SECONDS
+    num_samples: int, sample_rate: int, max_seconds: float = DEFAULT_MAX_AUDIO_SECONDS
 ) -> Optional[str]:
-    """Return an error message iff the clip exceeds *max_seconds*, else
-    ``None``. See the module docstring / ``MAX_CLIP_SECONDS`` comment for why
-    this refuses instead of chunking."""
+    """Return an error message iff the clip exceeds *max_seconds* (the
+    total-audio cap — longer than one Whisper window is chunked, not refused),
+    else ``None``."""
     if sample_rate <= 0:
         return "invalid sample rate"
     duration = num_samples / sample_rate
@@ -316,6 +341,130 @@ def peek_wav_duration_seconds(raw_bytes: bytes) -> Optional[float]:
     return frames / rate
 
 
+def is_riff_wave(raw_bytes: bytes) -> bool:
+    """True when *raw_bytes* carries a RIFF/WAVE header — the only container
+    :func:`decode_wav_pcm16` reads directly."""
+    return len(raw_bytes) >= 12 and raw_bytes[:4] == b"RIFF" and raw_bytes[8:12] == b"WAVE"
+
+
+# Bounded so a pathological upload cannot hold a request thread forever.
+FFMPEG_TIMEOUT_SECONDS = 60
+
+
+def ffmpeg_transcode_command(src: str, dst: str, max_seconds: float) -> list[str]:
+    """The ffmpeg argv that turns any decodable audio (m4a/aac, mp3, ogg/opus,
+    webm, flac, a non-16-bit WAV, ...) into 16 kHz mono PCM16 WAV.
+
+    Input and output are both FILES, not pipes: an m4a whose ``moov`` atom
+    sits at the end (the usual phone voice-note layout) cannot be demuxed from
+    a non-seekable stdin, and a WAV written to a pipe carries a placeholder
+    frame count that :func:`peek_wav_duration_seconds` would misread. ``-t``
+    stops decoding one second past the clip cap, so an over-long upload is
+    still refused as ``clip_too_long`` without decoding all of it."""
+    return [
+        "ffmpeg",
+        "-nostdin",
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-y",
+        "-i",
+        src,
+        "-t",
+        str(max_seconds + 1),
+        "-vn",
+        "-ac",
+        "1",
+        "-ar",
+        str(SAMPLE_RATE),
+        "-c:a",
+        "pcm_s16le",
+        "-f",
+        "wav",
+        dst,
+    ]
+
+
+def transcode_to_wav(
+    raw_bytes: bytes, max_seconds: float = MAX_AUDIO_SECONDS, runner=None
+) -> bytes:
+    """Transcode a non-WAV upload to PCM16 WAV with the image's ffmpeg.
+
+    Raises :class:`ValueError` with ffmpeg's own message when the bytes are
+    not decodable audio. *runner* defaults to :func:`subprocess.run` and is
+    injectable so the offline suite needs no ffmpeg binary."""
+    import subprocess  # nosec B404 - fixed argv, no shell
+    import tempfile
+
+    run = runner or subprocess.run
+    with tempfile.TemporaryDirectory(prefix="stt-") as tmp:
+        src = os.path.join(tmp, "in")
+        dst = os.path.join(tmp, "out.wav")
+        with open(src, "wb") as fh:
+            fh.write(raw_bytes)
+        try:
+            proc = run(
+                ffmpeg_transcode_command(src, dst, max_seconds),
+                capture_output=True,
+                timeout=FFMPEG_TIMEOUT_SECONDS,
+                check=False,
+            )
+        except FileNotFoundError as exc:
+            raise ValueError("audio is not WAV and ffmpeg is not installed") from exc
+        except subprocess.TimeoutExpired as exc:
+            raise ValueError(f"audio decode timed out after {FFMPEG_TIMEOUT_SECONDS}s") from exc
+        if proc.returncode != 0 or not os.path.exists(dst):
+            detail = (proc.stderr or b"").decode("utf-8", "replace").strip().splitlines()
+            reason = detail[-1] if detail else f"ffmpeg exited {proc.returncode}"
+            raise ValueError(f"could not decode audio: {reason}")
+        with open(dst, "rb") as fh:
+            return fh.read()
+
+
+def _frame_energy(samples: Sequence[float], start: int, length: int) -> float:
+    return sum(x * x for x in samples[start : start + length])
+
+
+def plan_chunks(
+    samples: Sequence[float],
+    sample_rate: int,
+    window_seconds: float = MAX_CLIP_SECONDS,
+    search_seconds: float = CHUNK_SEARCH_SECONDS,
+    frame_ms: int = CHUNK_FRAME_MS,
+) -> list[tuple[int, int]]:
+    """Split *samples* into contiguous ``(start, end)`` ranges no longer than
+    *window_seconds*, covering every sample exactly once.
+
+    A clip that fits one window is one range. Otherwise each cut goes at the
+    middle of the lowest-energy *frame_ms* frame in the last *search_seconds*
+    of the window — the likeliest pause — so a word is rarely split."""
+    n = len(samples)
+    window = max(1, int(window_seconds * sample_rate))
+    if n <= window:
+        return [(0, n)]
+    frame = max(1, int(sample_rate * frame_ms / 1000))
+    search = max(frame, min(window, int(search_seconds * sample_rate)))
+    chunks: list[tuple[int, int]] = []
+    start = 0
+    while n - start > window:
+        lo = start + window - search
+        best_at, best_energy = start + window, None
+        for f in range(lo, start + window - frame + 1, frame):
+            energy = _frame_energy(samples, f, frame)
+            if best_energy is None or energy < best_energy:
+                best_at, best_energy = f + frame // 2, energy
+        chunks.append((start, best_at))
+        start = best_at
+    chunks.append((start, n))
+    return chunks
+
+
+def join_chunk_texts(texts: Sequence[str]) -> str:
+    """Join per-chunk transcripts, skipping the empty ones a chunk of silence
+    (or a dropped low-confidence chunk) leaves."""
+    return " ".join(t for t in (x.strip() for x in texts) if t)
+
+
 def build_success_response(text: str) -> dict:
     """Same top-level shape as ``listen_server.py``'s ``return {"text": text}``."""
     return {"text": text}
@@ -446,8 +595,9 @@ if _FASTAPI_AVAILABLE:
         file: UploadFile = File(...),
         language: str = Form(None),
     ):
-        """Transcribe an uploaded WAV file (PCM16 mono/stereo 16kHz — the
-        realtime bridge's own output shape). See the module docstring for the
+        """Transcribe an uploaded audio file. PCM16 WAV (the realtime bridge's
+        own output shape) is read directly; anything else is transcoded to
+        16 kHz mono PCM16 by the image's ffmpeg first. See the module docstring for the
         channel/resample/duration-limit contract."""
         content = await file.read()
 
@@ -457,23 +607,43 @@ if _FASTAPI_AVAILABLE:
                 status_code=413, content=build_error_body(size_error, "upload_too_large")
             )
 
+        if not is_riff_wave(content):
+            # m4a / mp3 / ogg / webm / flac: normalise to PCM16 WAV first.
+            import anyio
+
+            try:
+                content = await anyio.to_thread.run_sync(transcode_to_wav, content)
+            except ValueError as exc:
+                return JSONResponse(
+                    status_code=400, content=build_error_body(str(exc), "invalid_audio")
+                )
+
         header_duration = peek_wav_duration_seconds(content)
-        if header_duration is not None and header_duration > MAX_CLIP_SECONDS:
+        if header_duration is not None and header_duration > MAX_AUDIO_SECONDS:
             return JSONResponse(
                 status_code=413,
                 content=build_error_body(
-                    _clip_too_long_message(header_duration, MAX_CLIP_SECONDS), "clip_too_long"
+                    _clip_too_long_message(header_duration, MAX_AUDIO_SECONDS), "clip_too_long"
                 ),
             )
 
         try:
             samples, sample_rate, channels = decode_wav_pcm16(content)
-        except (ValueError, wave.Error) as exc:
-            return JSONResponse(status_code=400, content=build_error_body(str(exc), "invalid_wav"))
+        except (ValueError, wave.Error):
+            # A RIFF/WAVE the stdlib reader refuses (24-bit, float, ...): ffmpeg reads it.
+            import anyio
+
+            try:
+                content = await anyio.to_thread.run_sync(transcode_to_wav, content)
+                samples, sample_rate, channels = decode_wav_pcm16(content)
+            except (ValueError, wave.Error) as exc:
+                return JSONResponse(
+                    status_code=400, content=build_error_body(str(exc), "invalid_wav")
+                )
 
         samples = first_channel(samples, channels)
 
-        duration_error = validate_clip_duration(len(samples), sample_rate)
+        duration_error = validate_clip_duration(len(samples), sample_rate, MAX_AUDIO_SECONDS)
         if duration_error is not None:
             return JSONResponse(
                 status_code=413, content=build_error_body(duration_error, "clip_too_long")
@@ -496,39 +666,49 @@ if _FASTAPI_AVAILABLE:
         lang = resolve_language(language, os.environ.get("STT_LANGUAGE"), DEFAULT_LANGUAGE)
 
         model, processor = get_model_and_processor()
-        audio = np.array(floats, dtype=np.float32)
-        inputs = processor(audio, sampling_rate=SAMPLE_RATE, return_tensors="pt")
-        input_features = inputs.input_features.to("cuda", dtype=torch.float16)
-        with torch.no_grad():
-            out = model.generate(
-                input_features,
-                language=lang,
-                task="transcribe",
-                max_new_tokens=128,
-                return_dict_in_generate=True,
-                output_scores=True,
-            )
-        n_new = len(out.scores)
-        new_ids = out.sequences[0][-n_new:] if n_new else out.sequences[0][:0]
         eot = processor.tokenizer.convert_tokens_to_ids("<|endoftext|>")
-        token_logprobs = [
-            torch.log_softmax(step[0].float(), dim=-1)[tok].item()
-            for step, tok in zip(out.scores, new_ids)
-            if tok.item() < eot  # text tokens only — specials sit at/after <|endoftext|>
-        ]
-        text = processor.batch_decode(out.sequences, skip_special_tokens=True)[0]
-        # Whisper's decode leaves a leading space (measured live: ' מה מזג ...');
-        # listen_server.py's callers never see one, so strip before filtering.
-        text = filter_non_speech_only(strip_bidi_controls(text).strip())
-        confidence = average_logprob(token_logprobs)
-        if text and is_low_confidence(confidence, MIN_AVG_LOGPROB):
-            logger.info(
-                "dropping low-confidence transcript (avg_logprob %.2f < %.2f): %r",
-                confidence,
-                MIN_AVG_LOGPROB,
-                text,
-            )
-            text = ""
+
+        def transcribe_window(window: Sequence[float]) -> str:
+            audio = np.array(window, dtype=np.float32)
+            inputs = processor(audio, sampling_rate=SAMPLE_RATE, return_tensors="pt")
+            input_features = inputs.input_features.to("cuda", dtype=torch.float16)
+            with torch.no_grad():
+                out = model.generate(
+                    input_features,
+                    language=lang,
+                    task="transcribe",
+                    max_new_tokens=MAX_NEW_TOKENS,
+                    return_dict_in_generate=True,
+                    output_scores=True,
+                )
+            n_new = len(out.scores)
+            new_ids = out.sequences[0][-n_new:] if n_new else out.sequences[0][:0]
+            token_logprobs = [
+                torch.log_softmax(step[0].float(), dim=-1)[tok].item()
+                for step, tok in zip(out.scores, new_ids)
+                if tok.item() < eot  # text tokens only — specials sit at/after <|endoftext|>
+            ]
+            text = processor.batch_decode(out.sequences, skip_special_tokens=True)[0]
+            # Whisper's decode leaves a leading space (measured live: ' מה מזג ...');
+            # listen_server.py's callers never see one, so strip before filtering.
+            text = filter_non_speech_only(strip_bidi_controls(text).strip())
+            confidence = average_logprob(token_logprobs)
+            # Gated per window: one hallucinated silent window is dropped on
+            # its own instead of poisoning (or rescuing) its neighbours.
+            if text and is_low_confidence(confidence, MIN_AVG_LOGPROB):
+                logger.info(
+                    "dropping low-confidence transcript (avg_logprob %.2f < %.2f): %r",
+                    confidence,
+                    MIN_AVG_LOGPROB,
+                    text,
+                )
+                text = ""
+            return text
+
+        chunks = plan_chunks(floats, SAMPLE_RATE)
+        if len(chunks) > 1:
+            logger.info("transcribing %.1fs in %d windows", len(floats) / SAMPLE_RATE, len(chunks))
+        text = join_chunk_texts([transcribe_window(floats[a:b]) for a, b in chunks])
 
         return build_success_response(text)
 

{lobes_cli-0.84.3 → lobes_cli-0.85.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lobes-cli"
-version = "0.84.3"
+version = "0.85.0"
 description = "lobes — run, assess, and switch the local vLLM model."
 readme = "README.md"
 license = "Apache-2.0"

{lobes_cli-0.84.3 → lobes_cli-0.85.0}/tests/test_listen_server_whisper.py

@@ -223,16 +223,21 @@ class TestLinearResample:
 
 class TestValidateClipDuration:
     def test_under_limit_is_ok(self, lsw) -> None:
-        assert lsw.validate_clip_duration(16000 * 29, 16000) is None
+        assert lsw.validate_clip_duration(16000 * 29, 16000, 30) is None
 
     def test_exactly_at_limit_is_ok(self, lsw) -> None:
-        assert lsw.validate_clip_duration(16000 * 30, 16000) is None
+        assert lsw.validate_clip_duration(16000 * 30, 16000, 30) is None
 
     def test_over_limit_is_refused(self, lsw) -> None:
-        msg = lsw.validate_clip_duration(16000 * 31, 16000)
+        msg = lsw.validate_clip_duration(16000 * 31, 16000, 30)
         assert msg is not None
         assert "30" in msg
 
+    def test_longer_than_one_window_is_not_refused_by_default(self, lsw) -> None:
+        # Past one Whisper window is chunked now; only the total cap refuses.
+        assert lsw.validate_clip_duration(16000 * 31, 16000) is None
+        assert lsw.validate_clip_duration(16000 * 601, 16000) is not None
+
     def test_zero_sample_rate_is_refused(self, lsw) -> None:
         assert lsw.validate_clip_duration(100, 0) is not None
 
@@ -405,3 +410,135 @@ class TestConfidenceGate:
         assert lsw.parse_min_avg_logprob("-0,35") == lsw.DEFAULT_MIN_AVG_LOGPROB
         assert lsw.parse_min_avg_logprob(None) == lsw.DEFAULT_MIN_AVG_LOGPROB
         assert lsw.parse_min_avg_logprob("-0.5") == -0.5
+
+
+# --------------------------------------------------------------------------
+# Non-WAV uploads (m4a, mp3, ogg, webm, ...) are transcoded by the image's
+# ffmpeg; a RIFF/WAVE upload never touches it.
+# --------------------------------------------------------------------------
+
+
+class TestIsRiffWave:
+    def test_wav_is_detected(self, lsw) -> None:
+        assert lsw.is_riff_wave(_make_wav_bytes([0, 1, 2]))
+
+    def test_m4a_is_not_wav(self, lsw) -> None:
+        assert not lsw.is_riff_wave(b"\x00\x00\x00\x20ftypM4A \x00\x00\x00\x00")
+
+    def test_short_or_empty_is_not_wav(self, lsw) -> None:
+        assert not lsw.is_riff_wave(b"")
+        assert not lsw.is_riff_wave(b"RIFF")
+
+
+class TestFfmpegTranscodeCommand:
+    def test_targets_16k_mono_pcm16_wav_file(self, lsw) -> None:
+        cmd = lsw.ffmpeg_transcode_command("/t/in", "/t/out.wav", 600)
+        assert cmd[0] == "ffmpeg"
+        assert cmd[cmd.index("-i") + 1] == "/t/in"
+        assert cmd[cmd.index("-ac") + 1] == "1"
+        assert cmd[cmd.index("-ar") + 1] == "16000"
+        assert cmd[cmd.index("-c:a") + 1] == "pcm_s16le"
+        assert cmd[-1] == "/t/out.wav"  # a seekable FILE, never pipe:1
+
+    def test_decode_stops_one_second_past_the_cap(self, lsw) -> None:
+        cmd = lsw.ffmpeg_transcode_command("/t/in", "/t/out.wav", 600)
+        assert float(cmd[cmd.index("-t") + 1]) == pytest.approx(601)
+
+
+class _FakeProc:
+    def __init__(self, returncode: int, stderr: bytes = b"") -> None:
+        self.returncode = returncode
+        self.stderr = stderr
+
+
+class TestTranscodeToWav:
+    def test_success_returns_ffmpegs_output_file(self, lsw) -> None:
+        wav = _make_wav_bytes([5, -5, 7])
+        seen = {}
+
+        def runner(cmd, **kwargs):
+            src, dst = cmd[cmd.index("-i") + 1], cmd[-1]
+            seen["input"] = Path(src).read_bytes()
+            seen["timeout"] = kwargs.get("timeout")
+            Path(dst).write_bytes(wav)
+            return _FakeProc(0)
+
+        assert lsw.transcode_to_wav(b"m4a-bytes", runner=runner) == wav
+        assert seen["input"] == b"m4a-bytes"
+        assert seen["timeout"] == lsw.FFMPEG_TIMEOUT_SECONDS
+
+    def test_ffmpeg_failure_raises_with_its_last_stderr_line(self, lsw) -> None:
+        def runner(cmd, **kwargs):
+            return _FakeProc(1, b"noise\nin: Invalid data found when processing input\n")
+
+        with pytest.raises(ValueError, match="Invalid data found"):
+            lsw.transcode_to_wav(b"garbage", runner=runner)
+
+    def test_missing_ffmpeg_is_a_value_error(self, lsw) -> None:
+        def runner(cmd, **kwargs):
+            raise FileNotFoundError("ffmpeg")
+
+        with pytest.raises(ValueError, match="ffmpeg is not installed"):
+            lsw.transcode_to_wav(b"x", runner=runner)
+
+    def test_zero_exit_without_output_is_a_failure(self, lsw) -> None:
+        with pytest.raises(ValueError, match="could not decode audio"):
+            lsw.transcode_to_wav(b"x", runner=lambda cmd, **kw: _FakeProc(0))
+
+
+class TestParseMaxAudioSeconds:
+    def test_default_when_unset_empty_or_bad(self, lsw) -> None:
+        for raw in (None, "", "  ", "ten", "0", "-5", "inf", "nan"):
+            assert lsw.parse_max_audio_seconds(raw) == lsw.DEFAULT_MAX_AUDIO_SECONDS
+
+    def test_positive_value_is_used(self, lsw) -> None:
+        assert lsw.parse_max_audio_seconds("120") == 120.0
+
+
+# --------------------------------------------------------------------------
+# Chunking: longer than one Whisper window is split at the quietest point
+# near each window's end, never refused.
+# --------------------------------------------------------------------------
+
+
+class TestPlanChunks:
+    RATE = 100  # 100 Hz keeps the fixtures tiny; frame = 2 samples at 20 ms
+
+    def _check_cover(self, chunks, n, window) -> None:
+        assert chunks[0][0] == 0
+        assert chunks[-1][1] == n
+        for (a, b), (c, _) in zip(chunks, chunks[1:]):
+            assert b == c  # contiguous, no overlap, no gap
+        for a, b in chunks:
+            assert 0 < b - a <= window
+
+    def test_one_window_is_one_chunk(self, lsw) -> None:
+        assert lsw.plan_chunks([1.0] * 2000, self.RATE, 30) == [(0, 2000)]
+
+    def test_exactly_one_window_is_one_chunk(self, lsw) -> None:
+        assert lsw.plan_chunks([1.0] * 3000, self.RATE, 30) == [(0, 3000)]
+
+    def test_cut_lands_in_the_pause(self, lsw) -> None:
+        samples = [1.0] * 4500
+        samples[2700:2720] = [0.0] * 20  # a 0.2 s pause 27 s in
+        chunks = lsw.plan_chunks(samples, self.RATE, 30, 5)
+        self._check_cover(chunks, 4500, 3000)
+        assert 2700 <= chunks[0][1] <= 2720
+
+    def test_long_clip_covers_every_sample_within_windows(self, lsw) -> None:
+        samples = [((i * 7919) % 13) / 13.0 for i in range(100 * 200)]  # 200 s
+        chunks = lsw.plan_chunks(samples, self.RATE, 30, 5)
+        self._check_cover(chunks, len(samples), 3000)
+        assert len(chunks) >= 7
+
+    def test_no_pause_still_makes_progress(self, lsw) -> None:
+        chunks = lsw.plan_chunks([1.0] * 9000, self.RATE, 30, 5)
+        self._check_cover(chunks, 9000, 3000)
+
+
+class TestJoinChunkTexts:
+    def test_skips_empty_windows(self, lsw) -> None:
+        assert lsw.join_chunk_texts(["שלום", "", "  ", "עולם "]) == "שלום עולם"
+
+    def test_all_empty_is_empty(self, lsw) -> None:
+        assert lsw.join_chunk_texts(["", ""]) == ""

{lobes_cli-0.84.3 → lobes_cli-0.85.0}/uv.lock

@@ -493,7 +493,7 @@ wheels = [
 
 [[package]]
 name = "lobes-cli"
-version = "0.84.3"
+version = "0.85.0"
 source = { editable = "." }
 
 [package.optional-dependencies]