cecli-dev 1.5.0rc6__tar.gz → 1.5.0rc8__tar.gz

{cecli_dev-1.5.0rc6 → cecli_dev-1.5.0rc8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.5.0rc6
+Version: 1.5.0rc8
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli

{cecli_dev-1.5.0rc6 → cecli_dev-1.5.0rc8}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.5.0rc6'
-__version_tuple__ = version_tuple = (1, 5, 0, 'rc6')
+__version__ = version = '1.5.0rc8'
+__version_tuple__ = version_tuple = (1, 5, 0, 'rc8')
 
-__commit_id__ = commit_id = 'g4e4c6ae63'
+__commit_id__ = commit_id = 'g82e5aa577'

{cecli_dev-1.5.0rc6 → cecli_dev-1.5.0rc8}/cecli/coders/base_coder.py

@@ -4507,18 +4507,15 @@ class Coder(metaclass=UsageMeta):
             completion_tokens = (
                 nested.getter(usage, ["completion_tokens", "output_tokens", "eval_count"], 0) or 0
             )
-            cache_hit_tokens = (
-                nested.getter(
-                    usage,
-                    [
-                        "prompt_cache_hit_tokens",
-                        "cache_read_input_tokens",
-                        "input_tokens_details.cached_tokens",
-                        "prompt_tokens_details.cached_tokens",
-                    ],
-                    0,
-                )
-                or 0
+            cache_hit_tokens = _first_usage_tokens(
+                usage,
+                [
+                    "prompt_cache_hit_tokens",
+                    "cache_read_input_tokens",
+                    "input_tokens_details.cached_tokens",
+                    "prompt_tokens_details.cached_tokens",
+                ],
+                0,
             )
             cache_write_tokens = nested.getter(usage, "cache_creation_input_tokens", 0) or 0
             self.message_cached_tokens += cache_hit_tokens
@@ -4636,18 +4633,15 @@ class Coder(metaclass=UsageMeta):
             completion_tokens = (
                 nested.getter(usage, ["completion_tokens", "output_tokens", "eval_count"], 0) or 0
             )
-            cache_hit_tokens = (
-                nested.getter(
-                    usage,
-                    [
-                        "prompt_cache_hit_tokens",
-                        "cache_read_input_tokens",
-                        "input_tokens_details.cached_tokens",
-                        "prompt_tokens_details.cached_tokens",
-                    ],
-                    0,
-                )
-                or 0
+            cache_hit_tokens = _first_usage_tokens(
+                usage,
+                [
+                    "prompt_cache_hit_tokens",
+                    "cache_read_input_tokens",
+                    "input_tokens_details.cached_tokens",
+                    "prompt_tokens_details.cached_tokens",
+                ],
+                0,
             )
             cache_write_tokens = nested.getter(usage, "cache_creation_input_tokens", 0) or 0
         elif active_model is not None:
@@ -5346,8 +5340,21 @@ def _function_call_to_dict(function_call):
     """Normalize a function call (dict or litellm-shaped Function) to a dict."""
     if isinstance(function_call, dict):
         return function_call
-
     if hasattr(function_call, "to_dict"):
         return function_call.to_dict()
-
     return function_call
+
+
+def _first_usage_tokens(usage: object, paths: list[str], default: int = 0) -> int:
+    """Return the first non-None token count among ``paths``.
+
+    ``nested.getter`` stops at the first attribute that exists even when its value
+    is None. Anthropic/copilot ``Usage`` always declares ``prompt_cache_hit_tokens``
+    (None) and populates ``cache_read_input_tokens``, so looking only at the first
+    field would report zero cache hits despite the server serving the cached prefix.
+    """
+    for path in paths:
+        value = nested.getter(usage, path, None)
+        if value is not None:
+            return value
+    return default

{cecli_dev-1.5.0rc6 → cecli_dev-1.5.0rc8}/cecli/voice.py

@@ -268,9 +268,8 @@ def _run_record_process(
             temp_path = tmp_file.name
 
         try:
-            with sd.InputStream(
-                samplerate=sample_rate, channels=1, callback=callback, device=device_id
-            ):
+            stream = _open_input_stream(callback, sample_rate, device_id)
+            with stream:
                 _status(status_queue, f"\n⬤ recording: {stop_binding or 'Enter'} to stop")
                 _wait_for_stop(stop_queue)
 
@@ -329,7 +328,6 @@ def _record_and_stream(
     """
     import threading
 
-    import sounddevice as sd
     from moonshine_voice.transcriber import LineCompleted, LineStarted, LineTextChanged
 
     transcriber = _build_transcriber(language, status_queue)
@@ -397,9 +395,8 @@ def _record_and_stream(
         feed_thread.start()
 
         try:
-            with sd.InputStream(
-                samplerate=sample_rate, channels=1, callback=callback, device=device_id
-            ):
+            stream = _open_input_stream(callback, sample_rate, device_id)
+            with stream:
                 _status(status_queue, f"\n⬤ recording: {stop_binding or 'Enter'} to stop")
                 _wait_for_stop(stop_queue)
         finally:
@@ -559,6 +556,95 @@ def _status(status_queue, message):
         print(message)
 
 
+def _open_input_stream(callback, sample_rate, device_id=None):
+    """Open and start an input stream, falling back to other input devices.
+
+    Tries the requested/default device first, then other input-capable devices
+    at compatible sample rates, so a WSL/PipeWire setup whose default device
+    cannot be opened (or fails to start, e.g. a ``paTimedOut``) still records.
+    The stream is started here so a start timeout is caught and the next
+    candidate is tried rather than surfacing to the caller after a device is
+    selected. Returns the started ``sounddevice.InputStream``; callers should
+    use it as a context manager (``with stream:``). Raises ``SoundDeviceError``
+    with an actionable message when no device opens or starts.
+    """
+    import sounddevice as sd
+
+    last_error = None
+
+    for dev, rate in _input_device_candidates(sample_rate, device_id):
+        stream = None
+
+        try:
+            stream = sd.InputStream(samplerate=rate, channels=1, callback=callback, device=dev)
+            stream.start()
+        except Exception as exc:
+            last_error = exc
+
+            if stream is not None:
+                try:
+                    stream.close()
+                except Exception:
+                    pass
+
+            continue
+
+        return stream
+
+    raise SoundDeviceError(_input_device_error_message(last_error))
+
+
+def _input_device_candidates(sample_rate, device_id):
+    """Yield (device, sample_rate) candidates for the input stream, best first."""
+    import sounddevice as sd
+
+    for rate in _sample_rates(sample_rate):
+        yield (device_id, rate)
+
+    try:
+        devices = sd.query_devices()
+    except Exception:
+        return
+
+    if not isinstance(devices, list):
+        return
+
+    for dev, entry in enumerate(devices):
+        if not isinstance(entry, dict) or entry.get("max_input_channels", 0) <= 0:
+            continue
+
+        if dev == device_id:
+            continue
+
+        for rate in _sample_rates(entry.get("default_samplerate") or sample_rate):
+            yield (dev, rate)
+
+
+def _sample_rates(sample_rate):
+    """Return sample rates to try for a device, preferred first and deduplicated."""
+    rates = []
+
+    for rate in (sample_rate, 44100, 48000, 16000):
+        if rate and rate not in rates:
+            rates.append(rate)
+
+    return rates
+
+
+def _input_device_error_message(err):
+    """Return an actionable message when no microphone input device can be opened."""
+    reason = f" ({err})" if err else ""
+
+    return (
+        "No microphone input device could be opened"
+        + reason
+        + ". Check that your mic is the default input device (Windows: Settings > "
+        "System > Sound > Input) and that Windows grants WSLg microphone access "
+        "(Settings > Privacy & security > Microphone). In WSL, confirm the mic is "
+        "bridged first, e.g. `PULSE_SERVER=unix:/mnt/wslg/PulseServer parec -d RDPSource --channels=1`."
+    )
+
+
 def _download_model_from_hf(language, status_queue=None):
     """Download the native Moonshine model for ``language`` from Hugging Face.
 

{cecli_dev-1.5.0rc6 → cecli_dev-1.5.0rc8}/cecli/website/docs/usage/voice.md

@@ -22,20 +22,27 @@ If you run cecli from WSL (Windows Subsystem for Linux), `/voice` needs a little
 
 1. **Check the Windows mic.** Verify your microphone is set as the **default input device** (Settings → System → Sound → Input) and that apps may access it (Settings → Privacy & security → Microphone).
 
-2. **Install the ALSA → Pulse plugin and PulseAudio utilities.**
+2. **Install PortAudio and the ALSA → Pulse plugin plus the PulseAudio utilities.**
 
    - Fedora:
 
        ```bash
-       sudo dnf install -y alsa-utils pulseaudio-utils alsa-plugins-pulseaudio
+       sudo dnf install -y portaudio alsa-utils pulseaudio-utils alsa-plugins-pulseaudio
        ```
 
    - Debian / Ubuntu:
 
        ```bash
-       sudo apt install -y alsa-utils pulseaudio-utils libasound2-plugins
+       sudo apt install -y libportaudio2 alsa-utils pulseaudio-utils libasound2-plugins
        ```
 
+
+> **After installing PortAudio**, close and reopen your terminal (or restart WSL) so
+> `sounddevice` picks up the newly installed PortAudio library — a running Python
+> process keeps whichever PortAudio it loaded first. Also make sure Windows grants
+> microphone access to WSLg (Settings → Privacy & security → Microphone →
+> *allow desktop apps* / "Windows Subsystem for Linux").
+
 3. **Route ALSA through PulseAudio.** Create `~/.asoundrc`:
 
    ```bash
@@ -46,7 +53,8 @@ If you run cecli from WSL (Windows Subsystem for Linux), `/voice` needs a little
 
    ```bash
    PULSE_SERVER=unix:/mnt/wslg/PulseServer \
-   parec -d RDPSource --format=s16le --rate=16000 --channels=1 | \
+   parec -d RDPSource --format=s16le --rate=44100 --channels=1 | \
+     head -c 176400 | \
      python3 -c "import sys, numpy as np; a=np.frombuffer(sys.stdin.buffer.read(), np.int16)/32768.0; print('RMS', round(float(np.sqrt(np.mean(a**2))),4))"
    ```
 

{cecli_dev-1.5.0rc6 → cecli_dev-1.5.0rc8}/cecli_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.5.0rc6
+Version: 1.5.0rc8
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli

{cecli_dev-1.5.0rc6 → cecli_dev-1.5.0rc8}/cecli_dev.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "1.5.0rc6",
+  "tag": "1.5.0rc8",
   "distance": 0,
-  "node": "g4e4c6ae63523ecec1774e2a8cad6a0b565ce7983",
+  "node": "g82e5aa577faeb61a2d01a2bd180cceb262bef0f7",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-08"

{cecli_dev-1.5.0rc6 → cecli_dev-1.5.0rc8}/tests/basic/test_voice.py

@@ -427,4 +427,40 @@ def test_wait_for_stop_preserves_cli_readline():
 
     with patch("cecli.voice.sys.stdin") as stdin:
         _wait_for_stop(None)
-        stdin.readline.assert_called_once_with()
+    stdin.readline.assert_called_once_with()
+
+
+def test_open_input_stream_retries_after_start_timeout():
+    """When the default device fails to start, ``_open_input_stream`` falls back."""
+    from cecli.voice import _open_input_stream
+
+    sounddevice = MagicMock()
+    sounddevice.query_devices.return_value = [
+        {"name": "default", "max_input_channels": 1, "default_samplerate": 44100},
+        {"name": "fallback", "max_input_channels": 1, "default_samplerate": 48000},
+    ]
+
+    created = []
+
+    def make_stream(device=None, **kwargs):
+        stream = MagicMock()
+        created.append((device, stream))
+
+        if device == 0:
+            stream.start.side_effect = RuntimeError("Wait timed out")
+
+        return stream
+
+    sounddevice.InputStream.side_effect = make_stream
+
+    with patch.dict("sys.modules", {"sounddevice": sounddevice}):
+        stream = _open_input_stream(lambda *a: None, 16000, device_id=0)
+
+    # The default device was tried first (and its streams released) before the fallback.
+    assert [device for device, _ in created] == [0, 0, 0, 1]
+    assert all(s.close.called for device, s in created if device == 0)
+
+    # The returned stream is the started fallback device, not the failing one.
+    assert stream is created[-1][1]
+    assert created[-1][0] == 1
+    stream.start.assert_called_once_with()