rigplane 2.7.2__tar.gz → 2.7.3__tar.gz

{rigplane-2.7.2 → rigplane-2.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rigplane
-Version: 2.7.2
+Version: 2.7.3
 Summary: Multi-vendor radio control library and Web UI with native providers and planned Hamlib-backed CAT coverage
 Project-URL: Homepage, https://rigplane.dev/
 Project-URL: Documentation, https://rigplane.dev/

{rigplane-2.7.2 → rigplane-2.7.3}/docs/CHANGELOG.md

@@ -11,6 +11,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.7.3] — 2026-05-31
+
+### Fixed
+
+- Windows FT8 TX delivered no audio (Po=0 W): the callback/`blocksize=0` TX
+  capture emitted 960-byte (10 ms) frames while the PCM TX validator requires
+  1920-byte (20 ms) frames; capture now re-chunks the continuous callback stream
+  into fixed 20 ms frames (keeps the ~50 Hz comb fix; lossless) (MOR-256, #1699,
+  17492be6)
+
+### Changed
+
+- Build (packaging): build the web UI during packaging so source/git installs
+  bundle the SPA (#1698, 55a0f81f)
+
 ## [2.7.2] — 2026-05-30
 
 ### Fixed
@@ -1543,7 +1558,8 @@ These deprecation closures were announced in v0.19 and dropped on schedule.
 - Transport layer, authentication, CI-V commands, meters, PTT, keep-alive.
 - Clean-room Icom LAN UDP protocol implementation.
 
-[Unreleased]: https://github.com/rigplane/rigplane-core/compare/v2.7.2...HEAD
+[Unreleased]: https://github.com/rigplane/rigplane-core/compare/v2.7.3...HEAD
+[2.7.3]: https://github.com/rigplane/rigplane-core/compare/v2.7.2...v2.7.3
 [2.7.2]: https://github.com/rigplane/rigplane-core/compare/v2.7.1...v2.7.2
 [2.7.1]: https://github.com/rigplane/rigplane-core/compare/v2.7.0...v2.7.1
 [2.7.0]: https://github.com/rigplane/rigplane-core/compare/v2.6.0...v2.7.0

rigplane-2.7.3/hatch_build.py

@@ -0,0 +1,68 @@
+"""Hatchling build hook that bundles the Svelte web UI into the package.
+
+The frontend lives in ``frontend/`` and its build output (``frontend/dist``)
+is gitignored. At runtime the SPA is served from ``src/rigplane/web/static``,
+so the package must ship the built assets at that location.
+
+This hook makes every build target (wheel *and* sdist) self-contained:
+
+* If ``frontend/dist/index.html`` is missing and a ``frontend/`` source tree is
+  present, it builds the SPA with ``npm`` (``npm ci``/``npm install`` then
+  ``npm run build``). If ``npm`` is unavailable and no prebuilt dist exists, it
+  raises a clear ``RuntimeError`` so the failure is actionable.
+* If ``frontend/dist/index.html`` already exists, the npm build is skipped — the
+  hook is idempotent, so the PyPI publish flow (which prebuilds the frontend)
+  does not rebuild it.
+* The built ``frontend/dist`` is force-included at ``src/rigplane/web/static``
+  for whichever target is building, centralizing the mapping in one place.
+
+Without this, ``pip install git+https://...`` (a direct wheel build) would not
+bundle the SPA and the desktop UI would 404.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any
+
+from hatchling.builders.hooks.plugin.interface import BuildHookInterface
+
+# Runtime location the installed package serves the SPA from. Must not change.
+_RUNTIME_STATIC = "src/rigplane/web/static"
+
+
+class FrontendBuildHook(BuildHookInterface):  # type: ignore[type-arg]
+    """Build the web UI (if needed) and bundle it into the package."""
+
+    def initialize(self, version: str, build_data: dict[str, Any]) -> None:
+        root = Path(self.root)
+        frontend_dir = root / "frontend"
+        dist_index = frontend_dir / "dist" / "index.html"
+
+        if not dist_index.exists() and frontend_dir.is_dir():
+            self._build_frontend(frontend_dir)
+
+        # Inject the force-include so the SPA lands at the runtime location for
+        # whichever target (wheel or sdist) is building.
+        force_include = build_data.setdefault("force_include", {})
+        force_include["frontend/dist"] = _RUNTIME_STATIC
+
+    def _build_frontend(self, frontend_dir: Path) -> None:
+        npm = shutil.which("npm")
+        if npm is None:
+            raise RuntimeError(
+                "Building rigplane from source requires Node.js/npm to build "
+                "the web UI (frontend/dist is not present and could not be "
+                "built). Install Node.js/npm, or build a wheel/sdist on a "
+                "machine that has them (the resulting artifact is "
+                "self-contained and needs no Node.js to install)."
+            )
+
+        lockfile = frontend_dir / "package-lock.json"
+        install_cmd = [npm, "ci"] if lockfile.exists() else [npm, "install"]
+
+        self.app.display_info("Building rigplane web UI (npm)...")
+        subprocess.run(install_cmd, cwd=frontend_dir, check=True)
+        subprocess.run([npm, "run", "build"], cwd=frontend_dir, check=True)

{rigplane-2.7.2 → rigplane-2.7.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "rigplane"
-version = "2.7.2"
+version = "2.7.3"
 description = "Multi-vendor radio control library and Web UI with native providers and planned Hamlib-backed CAT coverage"
 readme = "README.md"
 license = "MIT"
@@ -74,12 +74,22 @@ dev = [
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/rigplane", "src/icom_lan"]
+# The web UI is placed at src/rigplane/web/static exclusively via the custom
+# build hook's force-include (see hatch_build.py). When building a wheel from an
+# sdist (uv build's default sdist->wheel chain), the sdist has already
+# materialized src/rigplane/web/static on disk; exclude it from normal project
+# file selection so the force-include is the single source and the tree is not
+# bundled twice.
+exclude = ["src/rigplane/web/static"]
 
 [tool.hatch.build.targets.wheel.force-include]
 "rigs" = "rigplane/rigs"
 
-[tool.hatch.build.targets.sdist.force-include]
-"frontend/dist" = "src/rigplane/web/static"
+# Builds the Svelte web UI during packaging (if not prebuilt) and force-includes
+# the result at src/rigplane/web/static for BOTH wheel and sdist targets, so
+# source/git installs are self-contained. See hatch_build.py.
+[tool.hatch.build.hooks.custom]
+path = "hatch_build.py"
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"

{rigplane-2.7.2 → rigplane-2.7.3}/src/rigplane/audio/backend.py

@@ -10,7 +10,6 @@ opening RX/TX audio streams, plus two concrete implementations:
 
 from __future__ import annotations
 
-import asyncio
 import logging
 import math
 import threading
@@ -228,7 +227,35 @@ def _ensure_portaudio_deps() -> tuple[Any, Any]:
 
 
 class _PortAudioRxStream:
-    """RxStream backed by a sounddevice InputStream."""
+    """RxStream backed by a callback-driven sounddevice InputStream.
+
+    Capture is clocked by PortAudio's own audio thread via an ``InputStream``
+    callback, mirroring the callback design of :class:`_PortAudioTxStream`.
+    This replaces the previous fixed-``blocksize=960`` blocking-read loop
+    (``stream.read(960)`` on a worker thread), whose 20 ms read straddled the
+    WASAPI shared-mode engine period (~10 ms) and dropped/duplicated a sample
+    run once per block, producing a ~50 Hz spectral comb on captured TX audio
+    on Windows. The stream is opened with ``blocksize=0`` (engine-native
+    period), mirroring a known-clean ``sd.rec`` capture. The earlier WDM-KS
+    capture face rejected ``blocksize=0`` (PortAudioError -9999), but companion
+    device selection now forces the WASAPI host-API face, on which
+    ``blocksize=0`` opens cleanly.
+
+    The PortAudio callback runs on the audio thread and must not block. It
+    copies the captured PCM (s16le) out of the engine-native, variable-size
+    block and *re-chunks* it into fixed ``frame_ms``-sized frames before
+    handing them to the consumer *callback*. The downstream PCM-TX contract
+    requires fixed-size frames (e.g. 20 ms = 960 samples = 1920 bytes s16le
+    mono @ 48 kHz); a managed core validator rejects any frame whose byte
+    length differs. Re-chunking a *continuous* callback stream is lossless and
+    introduces no scheduling seam (the ~50 Hz comb came from the old
+    blocking-read inter-read gap, not from re-chunking), so this preserves the
+    fixed-frame contract without re-introducing the comb. Sub-frame remainders
+    are buffered across callbacks; a trailing partial frame at stop is dropped.
+    The consumer contract (see :class:`RxStream`) is that the callback is cheap
+    and thread-safe to invoke from the audio thread; the companion bridge
+    marshals onto its event loop via ``call_soon_threadsafe``.
+    """
 
     def __init__(
         self,
@@ -237,24 +264,40 @@ class _PortAudioRxStream:
         sample_rate: int,
         channels: int,
         blocksize: int,
+        frame_ms: int,
     ) -> None:
         self._sd = sd
         self._device_index = device_index
         self._sample_rate = sample_rate
         self._channels = channels
+        # Capture is callback-driven with blocksize=0 (engine-native period),
+        # mirroring a clean sd.rec. blocksize=0 was previously rejected by the
+        # WDM-KS capture face (PortAudioError -9999), but companion device
+        # selection now forces the WASAPI face, on which blocksize=0 opens.
         self._blocksize = blocksize
+        # Fixed delivered-frame size: frame_ms worth of audio frames, each
+        # ``channels`` interleaved s16le samples (2 bytes/sample). The PortAudio
+        # stream stays blocksize=0; only the size handed to ``cb`` is fixed.
+        frame_samples = (sample_rate * frame_ms) // 1000
+        self._frame_bytes = max(1, frame_samples * channels * 2)
         self._stream: Any = None
-        self._task: asyncio.Task[None] | None = None
+        self._running = False
         self._callback: Callable[[bytes], None] | None = None
+        # Sub-frame remainder carried between audio-thread callbacks. The audio
+        # thread is the only writer, so no lock is needed.
+        self._accumulator = bytearray()
 
     @property
     def running(self) -> bool:
-        return self._task is not None and not self._task.done()
+        return self._running
 
     async def start(self, callback: Callable[[bytes], None]) -> None:
         if self.running:
             raise RuntimeError("RX stream already running.")
         self._callback = callback
+        self._accumulator = bytearray()
+        # blocksize=0 (engine-native period) mirrors a clean sd.rec on the
+        # WASAPI face. latency="low" matches the (clean) output stream.
         self._stream = self._sd.InputStream(
             samplerate=self._sample_rate,
             channels=self._channels,
@@ -262,17 +305,19 @@ class _PortAudioRxStream:
             device=self._device_index,
             blocksize=self._blocksize,
             latency="low",
+            callback=self._input_callback,
         )
         self._stream.start()
-        self._task = asyncio.create_task(self._loop(), name="portaudio-rx")
+        self._running = True
 
     async def stop(self) -> None:
         stream = self._stream
-        task = self._task
         self._stream = None
-        self._task = None
+        self._running = False
         self._callback = None
-        # Close stream FIRST — unblocks executor thread stuck in stream.read()
+        # Drop any sub-frame remainder: an incomplete trailing frame cannot
+        # satisfy the fixed-size contract and is discarded at teardown.
+        self._accumulator = bytearray()
         if stream is not None:
             try:
                 stream.stop()
@@ -282,30 +327,44 @@ class _PortAudioRxStream:
                 stream.close()
             except Exception:
                 logger.debug("portaudio-rx: stream close failed", exc_info=True)
-        # Now cancel the task (thread is already unblocked)
-        if task is not None and not task.done():
-            task.cancel()
-            try:
-                await task
-            except asyncio.CancelledError:
-                pass
 
-    async def _loop(self) -> None:
-        stream = self._stream
+    def _input_callback(
+        self,
+        indata: Any,
+        _frames: int,
+        _time_info: Any,
+        _status: Any,
+    ) -> None:
+        # Runs on PortAudio's audio thread: keep it non-blocking. Copy the
+        # captured PCM (s16le) out of the (reused, variable-size) input buffer,
+        # append it to the running accumulator, then slice off whole fixed-size
+        # frames and deliver each to the consumer. Re-chunking a continuous
+        # callback stream is lossless (every sample reaches the consumer in
+        # order) and adds no scheduling seam, so it keeps the fixed-frame
+        # contract without re-introducing the comb. The consumer is
+        # contractually cheap/thread-safe.
+        cb = self._callback
+        if cb is None:
+            return
         try:
-            while True:
-                data, _overflowed = await asyncio.to_thread(
-                    stream.read, self._blocksize
-                )
-                cb = self._callback
-                if cb is None:
-                    continue
-                pcm = bytes(data.tobytes()) if hasattr(data, "tobytes") else bytes(data)
-                cb(pcm)
-        except asyncio.CancelledError:
-            pass
+            pcm = (
+                bytes(indata.tobytes()) if hasattr(indata, "tobytes") else bytes(indata)
+            )
+        except Exception:
+            logger.warning("portaudio-rx: capture copy failed", exc_info=True)
+            return
+        if not pcm:
+            return
+        acc = self._accumulator
+        acc.extend(pcm)
+        frame_bytes = self._frame_bytes
+        try:
+            while len(acc) >= frame_bytes:
+                frame = bytes(acc[:frame_bytes])
+                del acc[:frame_bytes]
+                cb(frame)
         except Exception:
-            logger.warning("portaudio-rx: loop failed", exc_info=True)
+            logger.warning("portaudio-rx: consumer callback failed", exc_info=True)
 
 
 class _PortAudioTxStream:
@@ -795,13 +854,19 @@ class PortAudioBackend:
         frame_ms: int = 20,
     ) -> RxStream:
         sd, _ = self._ensure_deps()
-        blocksize = (sample_rate * frame_ms) // 1000
+        # blocksize=0 lets PortAudio use the engine-native period, mirroring a
+        # clean ``sd.rec`` capture. This is safe now that companion device
+        # selection forces the WASAPI host-API face (the WDM-KS face that
+        # rejected blocksize=0 with PortAudioError -9999 is no longer chosen).
+        # The PortAudio capture period stays engine-native; frame_ms only sizes
+        # the fixed frames re-chunked out to the consumer callback.
         return _PortAudioRxStream(
             sd,
             device_index=int(device),
             sample_rate=sample_rate,
             channels=channels,
-            blocksize=blocksize,
+            blocksize=0,
+            frame_ms=frame_ms,
         )
 
     def open_tx(

{rigplane-2.7.2 → rigplane-2.7.3}/tests/test_audio_backend.py

@@ -368,6 +368,199 @@ class TestPortAudioBackendDeps:
         stream = backend.open_rx(AudioDeviceId(0))
         assert isinstance(stream, RxStream)
 
+    @pytest.mark.asyncio()
+    async def test_open_rx_opens_callback_driven_blocksize_zero(self) -> None:
+        """Capture must be callback-driven with blocksize=0 (engine-native).
+
+        Regression guard against the ~50 Hz TX "comb": the old implementation
+        read on a fixed-``blocksize=960`` blocking loop (``stream.read(960)`` in
+        ``asyncio.to_thread``), which straddled the WASAPI shared-mode engine
+        period and dropped/duplicated a sample run once per 20 ms block. The
+        stream must now register a ``callback=`` rather than reading, and open
+        with ``blocksize=0`` (engine-native period), mirroring a clean
+        ``sd.rec``. Companion device selection forces the WASAPI face on which
+        ``blocksize=0`` opens (the WDM-KS face that rejected ``blocksize=0`` with
+        PortAudioError -9999 is no longer chosen).
+        """
+        created: list[dict[str, object]] = []
+
+        class FakeSd:
+            class InputStream:
+                def __init__(self, **kw: object) -> None:
+                    created.append(kw)
+                    self.started = False
+                    self.stopped = False
+                    self.closed = False
+
+                def start(self) -> None:
+                    self.started = True
+
+                def stop(self) -> None:
+                    self.stopped = True
+
+                def close(self) -> None:
+                    self.closed = True
+
+                def read(self, _frames: int) -> object:  # pragma: no cover
+                    raise AssertionError("capture must not use blocking read()")
+
+        backend = PortAudioBackend(dependency_loader=lambda: (FakeSd(), object()))
+        # frame_ms is advisory only now: the capture period is engine-native.
+        stream = backend.open_rx(
+            AudioDeviceId(0), sample_rate=48_000, channels=1, frame_ms=20
+        )
+        assert isinstance(stream, RxStream)
+
+        await stream.start(lambda _pcm: None)
+        assert stream.running
+
+        assert len(created) == 1
+        kwargs = created[0]
+        assert kwargs["blocksize"] == 0
+        assert callable(kwargs["callback"])
+        assert kwargs["samplerate"] == 48_000
+        assert kwargs["channels"] == 1
+        assert kwargs["dtype"] == "int16"
+        # device is passed as the integer index, unchanged.
+        assert kwargs["device"] == 0
+
+        await stream.stop()
+        assert not stream.running
+
+    @pytest.mark.asyncio()
+    async def test_open_rx_callback_emits_fixed_frame_ms_frames_lossless(self) -> None:
+        """Re-chunk invariant: variable-size device blocks are losslessly
+        accumulated and re-emitted to the consumer as FIXED frame_ms-sized
+        frames (the downstream PCM-TX validator rejects any other size).
+
+        The PortAudio callback delivers engine-native blocks whose frame count
+        varies (480, 480, 200, 760, 480, ...). The capture path must accumulate
+        them and hand the consumer only whole frame_ms frames (960 samples =
+        1920 bytes s16le mono @ 48 kHz / 20 ms), with every sample delivered in
+        order, byte-for-byte equal to the input concatenation truncated to a
+        whole number of frames. No loss/dup/reorder. The re-chunk is of a
+        continuous callback stream, so it adds no scheduling seam (the ~50 Hz
+        comb came from the old blocking read's inter-read gap, not re-chunking).
+        """
+
+        class FakeIndata:
+            def __init__(self, payload: bytes) -> None:
+                self._payload = payload
+
+            def tobytes(self) -> bytes:
+                return self._payload
+
+        captured_cb: dict[str, object] = {}
+
+        class FakeSd:
+            class InputStream:
+                def __init__(self, **kw: object) -> None:
+                    captured_cb["cb"] = kw["callback"]
+
+                def start(self) -> None:
+                    pass
+
+                def stop(self) -> None:
+                    pass
+
+                def close(self) -> None:
+                    pass
+
+        backend = PortAudioBackend(dependency_loader=lambda: (FakeSd(), object()))
+        stream = backend.open_rx(
+            AudioDeviceId(0), sample_rate=48_000, channels=1, frame_ms=20
+        )
+
+        received: list[bytes] = []
+        await stream.start(received.append)
+
+        cb = captured_cb["cb"]
+        assert callable(cb)
+
+        # A reference s16le mono stream split into VARIABLE-size device blocks
+        # (480, 480, 200, 760, 480 samples = 2400). The sequence crosses frame
+        # boundaries mid-block so re-chunking is genuinely exercised.
+        import struct
+
+        frame_samples = 960
+        frame_bytes = frame_samples * 2  # 1920 bytes (s16le mono)
+        # 2880 samples = exactly 3 whole frames once the final block lands.
+        total_samples = 2880
+        reference = b"".join(struct.pack("<h", v % 32768) for v in range(total_samples))
+        block_splits = (480, 480, 200, 760, 480)  # samples; sums to 2400
+        offset = 0
+        for n_frames in block_splits:
+            chunk = reference[offset : offset + n_frames * 2]
+            offset += n_frames * 2
+            cb(FakeIndata(chunk), n_frames, None, None)  # type: ignore[operator]
+
+        # 2400 buffered samples -> two whole 960-sample frames emerge; the
+        # trailing 480-sample remainder stays buffered (not yet a whole frame).
+        assert len(received) == 2
+        for frame in received:
+            assert len(frame) == frame_bytes  # 1920 bytes / 20 ms each
+        assert b"".join(received) == reference[: 2 * frame_bytes]  # in order, no dup
+
+        # A final 480-sample block completes the third frame, draining the
+        # remainder. All 2880 samples now delivered as 3 fixed frames.
+        cb(FakeIndata(reference[offset:]), 480, None, None)  # type: ignore[operator]
+        assert len(received) == 3
+        assert all(len(f) == frame_bytes for f in received)
+        assert b"".join(received) == reference  # every sample, in order
+
+        await stream.stop()
+        # After stop the consumer is detached and the accumulator is cleared: a
+        # late callback is a no-op (the audio thread may fire once during
+        # teardown).
+        cb(FakeIndata(b"\xff" * frame_bytes), 960, None, None)  # type: ignore[operator]
+        assert len(received) == 3
+
+    @pytest.mark.asyncio()
+    async def test_open_rx_callback_honors_frame_ms(self) -> None:
+        """frame_ms sizes the emitted frame: 10 ms -> 480 samples -> 960 bytes."""
+
+        class FakeIndata:
+            def __init__(self, payload: bytes) -> None:
+                self._payload = payload
+
+            def tobytes(self) -> bytes:
+                return self._payload
+
+        captured_cb: dict[str, object] = {}
+
+        class FakeSd:
+            class InputStream:
+                def __init__(self, **kw: object) -> None:
+                    captured_cb["cb"] = kw["callback"]
+
+                def start(self) -> None:
+                    pass
+
+                def stop(self) -> None:
+                    pass
+
+                def close(self) -> None:
+                    pass
+
+        backend = PortAudioBackend(dependency_loader=lambda: (FakeSd(), object()))
+        stream = backend.open_rx(
+            AudioDeviceId(0), sample_rate=48_000, channels=1, frame_ms=10
+        )
+
+        received: list[bytes] = []
+        await stream.start(received.append)
+        cb = captured_cb["cb"]
+
+        # 1000 samples in one block -> two 480-sample (960-byte) frames, 40 left.
+        block = b"\x01\x02" * 1000
+        cb(FakeIndata(block), 1000, None, None)  # type: ignore[operator]
+
+        assert len(received) == 2
+        for frame in received:
+            assert len(frame) == 480 * 2  # 960 bytes / 10 ms each
+
+        await stream.stop()
+
     def test_open_tx_returns_tx_stream(self) -> None:
         class FakeSd:
             class OutputStream: