ka9q-python 3.26.1__tar.gz → 3.26.2__tar.gz

{ka9q_python-3.26.1 → ka9q_python-3.26.2}/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 3.26.2 (2026-11-01)
+
+### Fixed
+
+- **`ensure_channel()` now waits for radiod to report the requested
+  encoding.** `create_channel()` sends `OUTPUT_ENCODING` as a separate
+  command after the create, and `ensure_channel()` returned the first status
+  it saw, which could predate that command. A fresh F32 channel then came
+  back labelled S16, and `RadiodStream` decoded 4-byte floats as 2-byte
+  ints: noise-like samples on the 1/32768 grid, rms about 0.58 of full
+  scale, with "completeness 100%". codar-sounder ran this way on AC0G-ND and
+  UACNJ and heard no CODAR all day; with the encoding settled, the same
+  channel showed the Rutgers 13 MHz radars at 32 dB. `ensure_channel()` now
+  re-polls until the reported encoding matches the request, within its
+  `timeout`. If radiod still reports another encoding at the deadline, it
+  logs an error and returns radiod's value, so a stream decodes what is on
+  the wire. Checked live on UACNJ's radiod: a new F32 channel first reported
+  encoding 2 and settled to 4.
+- The comments that blamed radiod for "silently downgrading F32 to S16"
+  (`control.py`, `stream.py`) now name the stale status instead. The bee1
+  2026-05-15 T6/TSL3 incident they cited was very likely the same race.
+
 ## 3.26.1 (2026-10-01)
 
 ### Fixed

{ka9q_python-3.26.1/ka9q_python.egg-info → ka9q_python-3.26.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ka9q-python
-Version: 3.26.1
+Version: 3.26.2
 Summary: Python interface for ka9q-radio control and monitoring
 Author-email: Michael Hauan AC0G <ac0g@hauan.org>
 License: MIT

{ka9q_python-3.26.1 → ka9q_python-3.26.2}/ka9q/control.py

@@ -910,7 +910,11 @@ class RadiodControl:
     Sends TLV-encoded commands to radiod's control socket to create
     and configure channels.
     """
-    
+
+    # ensure_channel(): pause between status polls while waiting for radiod
+    # to report the requested OUTPUT_ENCODING.
+    _ENCODING_SETTLE_POLL_S = 0.1
+
     def __init__(self, status_address: str, max_commands_per_sec: int = 100,
                  interface: Optional[str] = None,
                  client_id: Optional[str] = None):
@@ -2072,9 +2076,40 @@ class RadiodControl:
                 f"Channel SSRC {ssrc} not verified within {timeout}s. "
                 f"Requested: {frequency_hz/1e6:.3f} MHz, {preset}, {sample_rate} Hz"
             )
-        # radiod may grant a different encoding (e.g. F32->S16 for some IQ
-        # configs); the returned ChannelInfo carries the granted value, which
-        # consumers use authoritatively.  A rate/preset divergence is logged
+        # create_channel() sends OUTPUT_ENCODING as a separate command after
+        # the create, so the first status can predate it and report the
+        # preset's encoding.  Streams pick their decoder from
+        # ChannelInfo.encoding; a stale S16 on an F32 stream decodes 4-byte
+        # floats as 2-byte ints — noise-like garbage at "100% completeness".
+        # Keep polling until radiod reports the requested encoding.  If it
+        # still differs at the deadline, return what radiod reports (the
+        # stream must decode what is on the wire) and say so loudly.
+        if encoding != 0 and channel.encoding != encoding:
+            deadline = time.monotonic() + timeout
+            stale = channel.encoding
+            while time.monotonic() < deadline:
+                time.sleep(self._ENCODING_SETTLE_POLL_S)
+                fresh = self.poll_channel(
+                    ssrc, expected_freq=frequency_hz,
+                    timeout=max(0.1, min(1.0, deadline - time.monotonic())),
+                    frequency_tolerance=frequency_tolerance,
+                )
+                if fresh is not None:
+                    channel = fresh
+                    if channel.encoding == encoding:
+                        break
+            if channel.encoding == encoding:
+                logger.info(
+                    "ensure_channel: SSRC %s encoding settled %s -> %s",
+                    ssrc, stale, channel.encoding,
+                )
+            else:
+                logger.error(
+                    "ensure_channel: SSRC %s still reports encoding %s after "
+                    "%.1fs (requested %s); returning radiod's value",
+                    ssrc, channel.encoding, timeout, encoding,
+                )
+        # A rate/preset divergence is logged
         # but not fatal — the channel exists at the requested frequency.
         # An ABSENT preset is not a divergence.  radiod may decline to echo
         # PRESET at all (write-only from the nopreset branch on), and a label

{ka9q_python-3.26.1 → ka9q_python-3.26.2}/ka9q/stream.py

@@ -129,11 +129,12 @@ def parse_rtp_samples(
         if floats is None:
             return None
         if is_iq:
-            # radiod silently downgrades F32 → S16 for some IQ-channel
-            # configurations (high sample rate + wide filter); confirmed on
-            # bee1 2026-05-15 for T6/TSL3 BPSK PPS channel (encoding=4
-            # requested, encoding=2 granted, decoded as F32LE → NaN-poisoned
-            # input, TSL3 dark). Honor the granted encoding above.
+            # Decode with the encoding the channel reports.  A wrong value
+            # here corrupts silently: the bee1 2026-05-15 T6/TSL3 "F32→S16
+            # downgrade" and codar-sounder's 2026-11-01 garbage IQ were both
+            # a stale encoding from ensure_channel (status read before the
+            # separate OUTPUT_ENCODING command landed), not radiod changing
+            # the encoding.  ensure_channel now waits for it to settle.
             if len(floats) % 2 != 0:
                 logger.warning(f"Odd number of samples in IQ payload: {len(floats)}")
                 return None

{ka9q_python-3.26.1 → ka9q_python-3.26.2/ka9q_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ka9q-python
-Version: 3.26.1
+Version: 3.26.2
 Summary: Python interface for ka9q-radio control and monitoring
 Author-email: Michael Hauan AC0G <ac0g@hauan.org>
 License: MIT

{ka9q_python-3.26.1 → ka9q_python-3.26.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ka9q-python"
-version = "3.26.1"
+version = "3.26.2"
 description = "Python interface for ka9q-radio control and monitoring"
 readme = "README.md"
 authors = [

{ka9q_python-3.26.1 → ka9q_python-3.26.2}/tests/test_ensure_channel_encoding.py

@@ -75,5 +75,68 @@ class TestEnsureChannelEncoding(unittest.TestCase):
             _, kwargs = self.control.create_channel.call_args
             self.assertEqual(kwargs['encoding'], Encoding.F32)
 
+
+def _info(ssrc, encoding):
+    return ChannelInfo(ssrc=ssrc, preset="iq", sample_rate=16000,
+                       frequency=14074000.0, snr=0.0,
+                       multicast_address="239.1.1.1", port=5004,
+                       encoding=encoding)
+
+
+class TestEnsureChannelEncodingSettles(unittest.TestCase):
+    """The first status after create can predate OUTPUT_ENCODING.
+
+    Found 2026-11-01: codar-sounder on AC0G-ND and UACNJ got encoding S16
+    back for an F32 channel and decoded 4-byte floats as 2-byte ints for a
+    whole day.  ensure_channel must wait for the requested encoding.
+    """
+
+    SSRC = 12345
+
+    @patch('ka9q.control.RadiodControl._connect')
+    def setUp(self, mock_connect):
+        self.control = RadiodControl("radiod.local")
+        self.control.create_channel = MagicMock()
+        self.control._ENCODING_SETTLE_POLL_S = 0.0
+
+    def _ensure(self, encoding=Encoding.F32, timeout=0.5):
+        with patch('ka9q.control.allocate_ssrc', return_value=self.SSRC):
+            return self.control.ensure_channel(
+                frequency_hz=14.074e6, destination="239.1.1.1",
+                encoding=encoding, timeout=timeout)
+
+    def test_stale_first_status_is_replaced_by_the_settled_one(self):
+        # probe (no channel yet), first verify (stale S16), then F32
+        self.control.poll_channel = MagicMock(side_effect=[
+            None, _info(self.SSRC, Encoding.S16BE),
+            _info(self.SSRC, Encoding.S16BE), _info(self.SSRC, Encoding.F32)])
+        result = self._ensure()
+        self.assertEqual(result.encoding, Encoding.F32)
+        self.assertEqual(self.control.poll_channel.call_count, 4)
+
+    def test_encoding_that_never_settles_returns_radiods_value_and_logs(self):
+        def poll(*a, **kw):
+            return None if poll.n == 0 else _info(self.SSRC, Encoding.S16BE)
+        poll.n = 0
+        def counting(*a, **kw):
+            r = poll(*a, **kw); poll.n += 1; return r
+        self.control.poll_channel = MagicMock(side_effect=counting)
+        with self.assertLogs('ka9q.control', level='ERROR') as logs:
+            result = self._ensure(timeout=0.2)
+        self.assertEqual(result.encoding, Encoding.S16BE)
+        self.assertTrue(any("still reports encoding" in m for m in logs.output))
+
+    def test_matching_first_status_polls_no_more(self):
+        self.control.poll_channel = MagicMock(side_effect=[
+            None, _info(self.SSRC, Encoding.F32)])
+        self.assertEqual(self._ensure().encoding, Encoding.F32)
+        self.assertEqual(self.control.poll_channel.call_count, 2)
+
+    def test_no_encoding_requested_takes_the_first_status(self):
+        self.control.poll_channel = MagicMock(side_effect=[
+            None, _info(self.SSRC, Encoding.S16BE)])
+        self.assertEqual(self._ensure(encoding=0).encoding, Encoding.S16BE)
+        self.assertEqual(self.control.poll_channel.call_count, 2)
+
 if __name__ == '__main__':
     unittest.main()