ka9q-python 3.22.0__py3-none-any.whl → 3.26.0__py3-none-any.whl

ka9q/__init__.py

@@ -119,7 +119,11 @@ from .slot_clock import SlotClock, Slot, SlotClockDesyncError, rtp_diff
 from .spectrum_stream import SpectrumStream
 from .status_listener import StatusListener, StatusListenerStats
 
+from .recovery_ladder import RecoveryAction, RecoveryLadder  # noqa: E402
+
 __all__ = [
+    "RecoveryAction",
+    "RecoveryLadder",
     # Control
     'RadiodControl',
     'allocate_ssrc',

ka9q/compat.py

@@ -12,4 +12,4 @@ Usage:
     print(f"Compatible with ka9q-radio at {KA9Q_RADIO_COMMIT}")
 """
 
-KA9Q_RADIO_COMMIT: str = "cedec349f7b4212078de3e007d142b4c64d36546"
+KA9Q_RADIO_COMMIT: str = "401992cdecaa7f85b093bff053f074453c99bdf5"

ka9q/control.py

@@ -65,6 +65,32 @@ class Metrics:
 
 
 # SSRC allocation function - compatible with signal-recorder
+# Preset -> demodulator, mirroring the `demod =` line of each preset in
+# ka9q-radio's share/presets.conf.  LINEAR is the default because radio.h
+# defines it as "everything else"; defaulting to FM (as this once did) puts
+# an FM demodulator behind sam/ame/dsb/cwu/cwl/wspr/nam/amsq as well as wfm.
+_FM_PRESETS = frozenset({"fm", "nfm", "pm", "npm"})
+_WFM_PRESETS = frozenset({"wfm"})
+_SPECTRUM_PRESETS = frozenset({"spectrum"})
+
+
+def demod_type_for_preset(preset: str) -> int:
+    """Return the DEMOD_TYPE that matches a radiod preset name.
+
+    radiod sets the demodulator from the preset, but clients that also send
+    DEMOD_TYPE override it -- so the value has to agree with the preset or
+    the channel runs a demodulator the caller never asked for.
+    """
+    name = (preset or "").strip().lower()
+    if name in _WFM_PRESETS:
+        return DemodType.WFM_DEMOD
+    if name in _FM_PRESETS:
+        return DemodType.FM_DEMOD
+    if name in _SPECTRUM_PRESETS:
+        return DemodType.SPECT_DEMOD
+    return DemodType.LINEAR_DEMOD
+
+
 def allocate_ssrc(
     frequency_hz: float,
     preset: str = "iq",
@@ -764,6 +790,19 @@ def decode_status_dict(buffer: bytes) -> dict:
             status['rf_agc'] = decode_int(data, optlen)
         elif type_val == StatusType.PRESET:
             status['preset'] = decode_string(data, optlen)
+        # ⛔ The two fields that say how to READ the samples.  status.py has
+        # always decoded them; this decoder -- the one discovery.py builds
+        # ChannelInfo from -- did not, so every consumer holding a
+        # ChannelInfo had to fall back to the preset STRING to decide
+        # complex-versus-real.  Phil Karn, 2026-09-21: "the individual
+        # parameters [are] definitive, with a preset just being a convenient
+        # shorthand"; a preset can be tweaked out of truth (PRESET USB then
+        # filters -3000,-50 yields LSB) and, from the nopreset branch on,
+        # may not arrive at all.
+        elif type_val == StatusType.DEMOD_TYPE:
+            status['demod_type'] = decode_int(data, optlen)
+        elif type_val == StatusType.OUTPUT_CHANNELS:
+            status['output_channels'] = decode_int(data, optlen)
         elif type_val == StatusType.LOW_EDGE:
             status['low_edge'] = decode_float(data, optlen)
         elif type_val == StatusType.HIGH_EDGE:
@@ -799,6 +838,21 @@ def decode_status_dict(buffer: bytes) -> dict:
                 else:
                     _TTL_ZERO_WARNED.add(ssrc)
                     logger.warning(msg)
+        elif type_val == StatusType.FILTER_DROPS:
+            # radiod's count of output blocks this channel's demod thread
+            # lapped.  Since ka9q-radio 55d9048d each lapped block is
+            # counted here AND emitted as a block of zeros, so the sample
+            # timeline stays intact and the loss shows up in the data --
+            # which makes this counter cross-checkable against
+            # ``PacketResequencer``'s zero-block detection rather than
+            # something a client has to take on trust.
+            #
+            # ``decode_status_packet`` has decoded it into
+            # ``ChannelStatus.filter_drops`` all along; this lightweight
+            # decoder -- the one ``StatusListener`` runs on every
+            # broadcast -- silently skipped it, so the per-channel drop
+            # count was invisible to every long-running client.
+            status['filter_drops'] = decode_int(data, optlen)
         elif type_val == StatusType.LIFETIME:
             status['lifetime'] = decode_int(data, optlen)
         elif type_val == StatusType.DESCRIPTION:
@@ -841,6 +895,14 @@ def _encoding_name(value: Optional[int]) -> str:
     return f"UNKNOWN({value})"
 
 
+#: Bounds on `RadiodControl._drain_status_socket`. Comfortably above a full
+#: receive buffer's worth of status packets (~26k for a 5 MB queue), while
+#: guaranteeing the drain terminates even if the group refills as fast as it
+#: is read -- or if the socket is a test double that never raises.
+_DRAIN_MAX_PACKETS = 50000
+_DRAIN_MAX_SEC = 0.25
+
+
 class RadiodControl:
     """
     Control interface for radiod
@@ -1475,8 +1537,13 @@ class RadiodControl:
         encode_string(cmdbuffer, StatusType.PRESET, preset)
         logger.info(f"Setting preset for SSRC {ssrc} to {preset}")
         
-        # DEMOD_TYPE: 0=linear (IQ/USB/LSB/etc), 1=FM
-        demod_type = 0 if preset.lower() in ['iq', 'usb', 'lsb', 'cw', 'am'] else 1
+        # DEMOD_TYPE must agree with what the preset just selected, because
+        # radiod applies whichever arrives last and this one follows PRESET
+        # in the same packet.  Getting it wrong silently substitutes a
+        # different demodulator: asking for "wfm" and sending FM_DEMOD gets
+        # the narrowband FM demod running behind a +/-110 kHz filter, which
+        # produces no output at all and reports snr=-inf forever.
+        demod_type = demod_type_for_preset(preset)
         encode_int(cmdbuffer, StatusType.DEMOD_TYPE, demod_type)
         logger.info(f"Setting DEMOD_TYPE for SSRC {ssrc} to {demod_type}")
         
@@ -1629,7 +1696,8 @@ class RadiodControl:
         return True
 
     def poll_channel(self, ssrc: int, expected_freq: Optional[float] = None,
-                     timeout: float = 2.0, frequency_tolerance: float = 1.0):
+                     timeout: float = 2.0, frequency_tolerance: float = 1.0,
+                     allow_idle: bool = False):
         """Targeted status poll for a single channel — O(1), not O(channels).
 
         Sends a poll naming exactly this ``ssrc`` and returns the ChannelInfo
@@ -1646,6 +1714,23 @@ class RadiodControl:
         status appears or the timeout elapses.  With no ``expected_freq`` an
         obviously-empty reply (frequency 0) is rejected.
 
+        **The 0 Hz blind spot (issue #6).**  That empty reply is byte-for-byte
+        what radiod also sends for a channel it *holds* at 0 Hz: one being
+        reaped after :meth:`remove_channel` (radiod tunes it to 0 Hz and lets
+        its lifetime run out), one parked at 0 Hz, or -- on builds that create
+        channels dynamically -- one this very poll just minted.  So with the
+        default ``allow_idle=False`` a purging SSRC is indistinguishable from a
+        free one: both return ``None``.  Re-creating such an SSRC hands back
+        the dying channel, which answers status and never emits RTP.
+
+        Pass ``allow_idle=True`` to receive that reply instead: the returned
+        ``ChannelInfo`` has ``frequency == 0.0`` and proves that radiod
+        currently answers for this SSRC at 0 Hz -- i.e. the SSRC is **not**
+        free to reuse right now.  It does *not* tell you why (reaping vs
+        parked vs freshly minted), and ``None`` then means only "no reply".
+        ``expected_freq`` always wins: a 0 Hz reply never matches a non-zero
+        expectation, whatever ``allow_idle`` says.
+
         This is the establishment/verify probe: after ``create_channel`` sends
         the create, one ``poll_channel(ssrc, expected_freq=f)`` confirms radiod
         accepted it and yields the *granted* encoding + RTP_TIMESNAP/GPS_TIME
@@ -1708,8 +1793,9 @@ class RadiodControl:
                 if expected_freq is not None:
                     if abs(freq - expected_freq) > frequency_tolerance:
                         continue   # empty or stale reply — keep waiting
-                elif not freq:
+                elif not freq and not allow_idle:
                     continue       # radiod's "no such channel" empty status
+                                   # -- or a channel held at 0 Hz; see #6
                 dest = status.get("destination", {})
                 mcast = dest.get("address", "") if isinstance(dest, dict) else ""
                 port = dest.get("port", 0) if isinstance(dest, dict) else 0
@@ -1990,8 +2076,14 @@ class RadiodControl:
         # configs); the returned ChannelInfo carries the granted value, which
         # consumers use authoritatively.  A rate/preset divergence is logged
         # but not fatal — the channel exists at the requested frequency.
-        if (channel.sample_rate != sample_rate
-                or channel.preset.lower() != preset.lower()):
+        # 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
+        # nobody sent cannot disagree with the one we asked for.  Warning on
+        # that would fire on every single ensure_channel call and bury the
+        # real rate divergences underneath it.
+        granted_preset = (getattr(channel, 'preset', None) or "").lower()
+        preset_diverged = bool(granted_preset) and granted_preset != preset.lower()
+        if channel.sample_rate != sample_rate or preset_diverged:
             logger.warning(
                 "ensure_channel: SSRC %s granted rate=%s preset=%s "
                 "(requested rate=%s preset=%s)",
@@ -2033,6 +2125,13 @@ class RadiodControl:
             - Always call this when your application is done with a channel
             - Especially important for long-running applications that create temporary channels
             - The channel may still appear in discovery for a brief time after calling this
+            - Removal is asynchronous: radiod tunes the channel to 0 Hz and only
+              reaps it when its lifetime runs out (build/config dependent; ~20 s
+              observed).  Until then a poll for this SSRC gets a 0 Hz reply that
+              :meth:`poll_channel` drops by default, so the SSRC *looks* free
+              while re-creating it would hand back the dying channel.  Use
+              ``poll_channel(ssrc, allow_idle=True)`` to see that state
+              (issue #6).
         """
         _validate_ssrc(ssrc)
         
@@ -2162,31 +2261,81 @@ class RadiodControl:
         
         return status_sock
     
+    @staticmethod
+    def _drain_status_socket(sock) -> int:
+        """Discard whatever is already queued. Returns how many were dropped.
+
+        The cached poll socket is joined to radiod's status group but read
+        ONLY during a poll, so between polls the kernel queues the entire
+        continuous status broadcast into it. Left alone it reaches the
+        receive-buffer ceiling and stays there: on B4, wspr-recorder's copy
+        sat permanently full and had discarded 1,254,234 packets, ~24/s.
+
+        Two costs, and the second is the one that matters. The socket pins
+        its whole buffer in kernel memory; and every poll then has to
+        recvfrom() and decode its way through thousands of stale packets
+        before reaching the reply it wants, inside a 2 s timeout. Draining
+        first makes a poll read only post-command traffic, which is what a
+        request/response exchange on a shared multicast group requires
+        anyway.
+
+        Correctness does not depend on this -- `poll_status` matches on
+        `command_tag` and would reject stale packets regardless -- but
+        latency and the drop counter do.
+
+        Bounded on purpose. An unbounded "read until it raises" loop becomes
+        the stall it exists to prevent: on a busy group the socket can be
+        refilled as fast as it is emptied, and the drain never returns. The
+        caps below are far above a full buffer's worth (a 5 MB queue of
+        ~200-byte status packets is ~26k) yet still terminate. This was not
+        theoretical -- the first version hung the tune() test suite outright,
+        because a mocked socket never raises.
+        """
+        n = 0
+        deadline = time.monotonic() + _DRAIN_MAX_SEC
+        sock.setblocking(False)
+        try:
+            for _ in range(_DRAIN_MAX_PACKETS):
+                try:
+                    sock.recv(65536)
+                    n += 1
+                except (BlockingIOError, InterruptedError):
+                    break
+                except OSError:
+                    break
+                if not n % 256 and time.monotonic() > deadline:
+                    logger.warning(
+                        "status drain hit its %.2fs budget after %d packets; "
+                        "the group is busier than the drain can empty",
+                        _DRAIN_MAX_SEC, n)
+                    break
+            else:
+                logger.warning(
+                    "status drain hit its %d-packet cap; some stale status "
+                    "remains queued", _DRAIN_MAX_PACKETS)
+        finally:
+            sock.setblocking(True)
+            sock.settimeout(0.1)
+        if n:
+            logger.debug("drained %d stale status packet(s) before poll", n)
+        return n
+
     def _get_or_create_status_listener(self):
+        """Removed: the cached status socket leaked.
+
+        It stayed joined to radiod's status group and unread between polls,
+        so the kernel queued the continuous status broadcast into it until
+        the receive buffer capped and every further packet was discarded --
+        1,254,234 of them on B4, ~24/s, with the queue permanently full.
+        Draining at poll time did not help, because in steady state nothing
+        polls. Each exchange now creates and closes its own socket via
+        `_setup_status_listener`; `close()` still tolerates the old
+        attribute so existing callers are unaffected.
         """
-        Get cached status listener socket or create new one if needed.
-        
-        This method implements socket reuse to avoid creating/destroying sockets
-        on every tune() call, which saves 20-30ms per operation and prevents
-        socket exhaustion.
-        
-        Returns:
-            Cached or newly created status listener socket
-        """
-        import threading
-        
-        # Lazy initialization of lock (avoid threading overhead if never used)
-        if self._status_sock_lock is None:
-            self._status_sock_lock = threading.Lock()
-        
-        with self._status_sock_lock:
-            if self._status_sock is None:
-                logger.debug("Creating cached status listener socket")
-                self._status_sock = self._setup_status_listener()
-            else:
-                logger.debug("Reusing cached status listener socket")
-            return self._status_sock
-    
+        raise NotImplementedError(
+            "the cached status socket was removed (it leaked); call "
+            "_setup_status_listener() per exchange and close it")
+
     def tune(self, ssrc: int, frequency_hz: Optional[float] = None,
              preset: Optional[str] = None, sample_rate: Optional[int] = None,
              low_edge: Optional[float] = None, high_edge: Optional[float] = None,
@@ -2326,9 +2475,16 @@ class RadiodControl:
 
         encode_eol(cmdbuffer)
         
-        # Get cached status listener (or create if first use)
-        # Socket is reused across tune() calls to avoid creation/destruction overhead
-        status_sock = self._get_or_create_status_listener()
+        # One socket per exchange (see poll_status for why caching it leaked).
+        # The old comment claimed reuse avoided creation overhead; the cost it
+        # actually avoided was ~1 ms of setup per tune, against a socket that
+        # stayed joined to the status group for the process lifetime and
+        # queued the whole broadcast into a buffer nobody read.
+        status_sock = self._setup_status_listener()
+        # Same request/response contract as poll_status: only packets that
+        # arrive after the tune command can be its reply, and wading through
+        # a full buffer's worth of stale ones eats the timeout.
+        self._drain_status_socket(status_sock)
         
         try:
             start_time = time.time()
@@ -2385,9 +2541,10 @@ class RadiodControl:
             raise TimeoutError(f"No status response received for SSRC {ssrc} within {timeout}s")
         
         finally:
-            # NOTE: Do NOT close status_sock here - it's cached for reuse
-            # Socket will be closed in close() method
-            pass
+            try:
+                status_sock.close()
+            except OSError:
+                pass
     
     def _decode_status_response(self, buffer: bytes) -> dict:
         """
@@ -3318,30 +3475,44 @@ class RadiodControl:
         encode_int(cmdbuffer, StatusType.OUTPUT_SSRC, ssrc)
         encode_eol(cmdbuffer)
 
-        status_sock = self._get_or_create_status_listener()
-        start = _time.time()
-        last_send = 0.0
-        retry = 0.1
-        while _time.time() - start < timeout:
-            now = _time.time()
-            if now - last_send >= retry:
-                self.send_command(cmdbuffer)
-                last_send = now
-                retry = min(retry * 2, 1.0)
-            remaining = timeout - (now - start)
-            ready = select.select([status_sock], [], [], min(retry, remaining, 0.5))
-            if not ready[0]:
-                continue
+        # One socket per exchange, closed on the way out. Caching it for
+        # the process lifetime left it joined to the status group and
+        # unread between polls, so the kernel queued radiod's continuous
+        # broadcast into it until the buffer capped: on B4 that socket sat
+        # permanently full having discarded 1.25M packets. Draining at poll
+        # time cannot fix that, because in steady state nothing polls.
+        status_sock = self._setup_status_listener()
+        try:
+            # Only traffic that arrives AFTER the command can be its reply.
+            self._drain_status_socket(status_sock)
+            start = _time.time()
+            last_send = 0.0
+            retry = 0.1
+            while _time.time() - start < timeout:
+                now = _time.time()
+                if now - last_send >= retry:
+                    self.send_command(cmdbuffer)
+                    last_send = now
+                    retry = min(retry * 2, 1.0)
+                remaining = timeout - (now - start)
+                ready = select.select([status_sock], [], [], min(retry, remaining, 0.5))
+                if not ready[0]:
+                    continue
+                try:
+                    buf, _addr = status_sock.recvfrom(8192)
+                except socket.timeout:
+                    continue
+                st = decode_status_packet(buf)
+                if st is None:
+                    continue
+                if st.ssrc == ssrc and st.command_tag == command_tag:
+                    return st
+            raise TimeoutError(f"No status response received for SSRC {ssrc} within {timeout}s")
+        finally:
             try:
-                buf, _addr = status_sock.recvfrom(8192)
-            except socket.timeout:
-                continue
-            st = decode_status_packet(buf)
-            if st is None:
-                continue
-            if st.ssrc == ssrc and st.command_tag == command_tag:
-                return st
-        raise TimeoutError(f"No status response received for SSRC {ssrc} within {timeout}s")
+                status_sock.close()
+            except OSError:
+                pass
 
     def listen_status(self, callback, duration: Optional[float] = None,
                       ssrcs: Optional[set] = None):
@@ -3356,28 +3527,38 @@ class RadiodControl:
         import time as _time
         from .status import decode_status_packet
 
-        status_sock = self._get_or_create_status_listener()
-        start = _time.time()
-        while True:
-            if duration is not None and _time.time() - start >= duration:
-                return
-            remaining = None if duration is None else max(0.0, duration - (_time.time() - start))
-            ready = select.select([status_sock], [], [], 0.5 if remaining is None else min(0.5, remaining))
-            if not ready[0]:
-                continue
-            try:
-                buf, _addr = status_sock.recvfrom(8192)
-            except socket.timeout:
-                continue
-            st = decode_status_packet(buf)
-            if st is None or st.ssrc is None:
-                continue
-            if ssrcs is not None and st.ssrc not in ssrcs:
-                continue
+        # Passive listener: its own socket for the life of the call, then
+        # closed. Unlike the request/response paths this one is read
+        # continuously, so it never accumulates -- but it must not share a
+        # cached socket that outlives the call either.
+        status_sock = self._setup_status_listener()
+        try:
+            start = _time.time()
+            while True:
+                if duration is not None and _time.time() - start >= duration:
+                    return
+                remaining = None if duration is None else max(0.0, duration - (_time.time() - start))
+                ready = select.select([status_sock], [], [], 0.5 if remaining is None else min(0.5, remaining))
+                if not ready[0]:
+                    continue
+                try:
+                    buf, _addr = status_sock.recvfrom(8192)
+                except socket.timeout:
+                    continue
+                st = decode_status_packet(buf)
+                if st is None or st.ssrc is None:
+                    continue
+                if ssrcs is not None and st.ssrc not in ssrcs:
+                    continue
+                try:
+                    callback(st)
+                except Exception as exc:
+                    logger.warning(f"listen_status callback raised: {exc}")
+        finally:
             try:
-                callback(st)
-            except Exception as exc:
-                logger.warning(f"listen_status callback raised: {exc}")
+                status_sock.close()
+            except OSError:
+                pass
 
     # ── Continuous STATUS listener (v3.16.0+) ──────────────────────
 

ka9q/discovery.py

@@ -82,6 +82,31 @@ class ChannelInfo:
     # per-band abs-divergence check remains the backstop for real sustained drift.
     anchor_step_threshold_sec: float = 0.75  # |move| beyond this ⇒ a step (configurable)
 
+    # radiod's cumulative count of output blocks this channel's demod thread
+    # lapped (FILTER_DROPS).  Appended last so the addition is purely
+    # additive — no existing positional construction shifts.
+    #
+    # CUMULATIVE since the radiod process started, so consumers must
+    # DIFFERENCE it; a level on its own says nothing about current loss.
+    # ``None`` until a STATUS broadcast carrying the tag has been seen —
+    # absent and "zero drops" are different claims and must not be
+    # conflated.
+    filter_drops: Optional[int] = None
+
+    # ⛔ APPENDED, deliberately.  These belong logically beside `preset`, but
+    # inserting them there would shift the position of every field after it
+    # and break any client constructing a ChannelInfo positionally.  The
+    # contract test caught exactly that.  Logical grouping is not worth a
+    # silent argument shift in five downstream repos.
+    #
+    # The parameter vector radiod treats as definitive: demod_type and
+    # output_channels together say whether the payload carries complex or
+    # real samples.  The preset string above is a convenience label that a
+    # later per-parameter tweak can leave stale, and which radiod may stop
+    # echoing entirely.  None when the status packet did not carry them.
+    demod_type: Optional[int] = None
+    output_channels: Optional[int] = None
+
     def __post_init__(self):
         # Seed the atomic-pair snapshot from the constructor args if both
         # were provided.  Lets ``get_anchor`` return the construction-time
@@ -324,7 +349,9 @@ def discover_channels_native(status_address: str, listen_duration: float = 2.0,
                 port=port,
                 gps_time=status.get('gps_time'),
                 rtp_timesnap=status.get('rtp_timesnap'),
-                encoding=status.get('encoding', 0)
+                encoding=status.get('encoding', 0),
+                demod_type=status.get('demod_type'),
+                output_channels=status.get('output_channels'),
             )
             
             # Store or update channel info

ka9q/managed_stream.py

@@ -133,6 +133,7 @@ class ManagedStream:
         samples_per_packet: int = 320,
         resequence_buffer_size: int = 64,
         deliver_interval_packets: int = 10,
+        raw_payloads: bool = False,
     ):
         """
         Initialize ManagedStream.
@@ -154,6 +155,10 @@ class ManagedStream:
             max_restore_attempts: Max restore attempts, 0=unlimited (default: 0)
             samples_per_packet: Expected samples per RTP packet
             resequence_buffer_size: Packets to buffer for resequencing
+            raw_payloads: Deliver undecoded RTP payloads (List[bytes], one per
+                packet) instead of samples — required for the framed encodings
+                OPUS/OPUS_VOIP/AX25, which have no raw-sample representation.
+                See :class:`ka9q.stream.RadiodStream` for the full contract.
             deliver_interval_packets: Deliver to callback every N packets
         """
         self._control = control
@@ -179,6 +184,7 @@ class ManagedStream:
         self._samples_per_packet = samples_per_packet
         self._resequence_buffer_size = resequence_buffer_size
         self._deliver_interval_packets = deliver_interval_packets
+        self._raw_payloads = raw_payloads
         
         # State
         self._state = StreamState.STOPPED
@@ -305,6 +311,7 @@ class ManagedStream:
             samples_per_packet=self._samples_per_packet,
             resequence_buffer_size=self._resequence_buffer_size,
             deliver_interval_packets=self._deliver_interval_packets,
+            raw_payloads=self._raw_payloads,
         )
         self._stream.start()
         

ka9q/multi_stream.py

@@ -52,7 +52,7 @@ import numpy as np
 
 from .discovery import ChannelInfo
 from .resequencer import PacketResequencer, RTPPacket
-from .rtp_recorder import RTPHeader, parse_rtp_header, rtp_to_wallclock
+from .rtp_recorder import RTPHeader, parse_rtp_header, rtp_to_utc
 from .stream import ENCODING_SAMPLE_BYTES, SampleCallback, parse_rtp_samples
 from .stream_quality import GapEvent, GapSource, StreamQuality
 
@@ -512,7 +512,7 @@ class MultiStream:
                 continue
 
             # Wallclock
-            wallclock = rtp_to_wallclock(header.timestamp, slot.channel_info)
+            wallclock = rtp_to_utc(header.timestamp, slot.channel_info)
 
             # Resequencer
             packet = RTPPacket(
@@ -524,11 +524,17 @@ class MultiStream:
             )
             output, gaps = slot.resequencer.process_packet(packet)
 
+            # Harvest gaps unconditionally.  A radiod zero-block marker
+            # can be reported for a packet that produced no output yet
+            # (arrived out of order and is still buffered); collecting
+            # only inside the branch below discarded it, and the stall
+            # went silent one layer further up.
+            slot.gap_buffer.extend(gaps)
+
             if output is not None and len(output) > 0:
                 if not slot.sample_buffer:
                     slot.pending_rtp_start = slot.resequencer.last_chunk_rtp_start
                 slot.sample_buffer.append(output)
-                slot.gap_buffer.extend(gaps)
                 slot.packets_since_delivery += 1
 
                 if slot.packets_since_delivery >= slot.deliver_interval:
@@ -617,6 +623,27 @@ class MultiStream:
 
     # ── delivery ──
 
+    @staticmethod
+    def _account_delivery(slot: _ChannelSlot, combined, gaps) -> None:
+        """Book one delivered batch against the completeness counters.
+
+        `completeness_pct` computes
+        `(delivered - gaps_filled) / expected`, but MultiStream only ever
+        set `delivered`.  With `expected` left at 0 the property took its
+        early return and reported a hardcoded 100.0 no matter what was
+        lost — on every recorder built on MultiStream, which is all the
+        multiplexing ones.  AC0G-B4 2026-08-15 logged 42 gaps totalling
+        93,600 samples in 25 minutes while completeness read 100.0%.
+
+        Gap fills keep the sample count whole, so `expected` tracks
+        `delivered` and the loss is carried by `gaps_filled`.
+        """
+        n = len(combined)
+        slot.quality.total_samples_delivered += n
+        slot.quality.total_samples_expected += n
+        slot.quality.total_gaps_filled += sum(
+            g.duration_samples for g in gaps)
+
     def _deliver(self, slot: _ChannelSlot) -> None:
         if not slot.sample_buffer or slot.on_samples is None:
             slot.sample_buffer.clear()
@@ -628,7 +655,7 @@ class MultiStream:
         combined = np.concatenate(slot.sample_buffer)
         n = len(combined)
 
-        slot.quality.total_samples_delivered += n
+        self._account_delivery(slot, combined, slot.gap_buffer)
         slot.quality.batch_samples_delivered = n
         slot.quality.batch_gaps = list(slot.gap_buffer)
         slot.quality.sample_rate = slot.sample_rate

ka9q/recovery_ladder.py

@@ -0,0 +1,139 @@
+"""Escalating recovery from a radiod restart.
+
+``MultiStream`` restores a slot whose stream merely stopped.  It cannot
+help when radiod itself went away and came back, because the channel the
+slot refers to no longer exists: radiod recreates SSRCs at Template
+defaults with TTL=0 after a brief outage, the per-channel verify times
+out, and the slot stays stale forever while the client goes on looking
+healthy.
+
+Recovering from that needs a second tier -- re-issue the channel
+requests -- and a third when even that fails -- tear the source down and
+reconnect.  wspr-recorder worked this out and kept it in its own
+repository.  The cost of that showed on AC0G-B4 on 2026-08-30: after a
+radiod outage, wspr re-provisioned 17 stale channels and recovered on
+its own, while meteor-scatter, which has only the tier-1 callback, sat
+dead for twenty-two hours until a human noticed.  psk-recorder has the
+same gap.  One client in three solved it, and the other two failed
+silently.
+
+The POLICY belongs here, because recovering from a radiod restart is a
+property of the clients<->radiod interface and that interface is what
+this package is.  The MECHANISMS stay with the client: what it means to
+re-provision depends on that client's own configuration, which this
+package should not know.  So the ladder decides *what* should happen and
+the caller decides *how*.
+
+Typical use, from whatever loop the client already runs::
+
+    ladder = RecoveryLadder()
+    ...
+    action = ladder.observe(healthy=(active == expected))
+    if action is RecoveryAction.REPROVISION:
+        rm.reprovision_stale()
+    elif action is RecoveryAction.FULL_RESET:
+        rm.full_reset()
+    elif action is RecoveryAction.RESTART_SELF:
+        log.critical("in-process repair exhausted after %d attempts; "
+                     "exiting for systemd to replace us",
+                     ladder.consecutive_degraded)
+        raise SystemExit(1)          # Restart=always does the rest
+
+One ladder per source.  A client with two radiods keeps two, so a fault
+on one never escalates the other.
+"""
+from __future__ import annotations
+
+import enum
+
+__all__ = ["RecoveryAction", "RecoveryLadder"]
+
+
+class RecoveryAction(enum.Enum):
+    """What the ladder asks the caller to do about this observation."""
+
+    NONE = "none"
+    REPROVISION = "reprovision"
+    FULL_RESET = "full_reset"
+    #: In-process remedies are exhausted; the PROCESS must be replaced.
+    #:
+    #: ⛔ OPT-IN (`restart_after=None` by default).  An action a caller does
+    #: not handle falls through its if/elif chain and does NOTHING, which is
+    #: silent inaction — the exact failure this ladder exists to prevent.  So
+    #: a caller asks for this rung only once it can act on it.
+    RESTART_SELF = "restart_self"
+
+
+class RecoveryLadder:
+    """Consecutive-degraded counter with two escalation thresholds.
+
+    The counter clears the instant a source returns to full health, so a
+    single bad check followed by recovery never ratchets a later,
+    unrelated incident toward a full reset.
+    """
+
+    DEFAULT_REPROVISION_AFTER = 1
+    DEFAULT_FULL_RESET_AFTER = 3
+
+    def __init__(
+        self,
+        reprovision_after: int = DEFAULT_REPROVISION_AFTER,
+        full_reset_after: int = DEFAULT_FULL_RESET_AFTER,
+        restart_after: int | None = None,
+    ) -> None:
+        if full_reset_after < reprovision_after:
+            raise ValueError(
+                f"full_reset_after ({full_reset_after}) must not precede "
+                f"reprovision_after ({reprovision_after}): a ladder whose "
+                f"top rung comes first is not a ladder"
+            )
+        if restart_after is not None and restart_after < full_reset_after:
+            raise ValueError(
+                f"restart_after ({restart_after}) must not precede "
+                f"full_reset_after ({full_reset_after}): replacing the "
+                f"process is the LAST resort, not an earlier one"
+            )
+        self.reprovision_after = int(reprovision_after)
+        self.full_reset_after = int(full_reset_after)
+        self.restart_after = (None if restart_after is None
+                              else int(restart_after))
+        self.consecutive_degraded = 0
+        #: Totals since construction, so an operator can tell a station
+        #: that is quietly self-healing from one that is merely quiet.
+        self.reprovisions = 0
+        self.full_resets = 0
+        self.restarts_requested = 0
+
+    @property
+    def escalating(self) -> bool:
+        """True while a fault is open (at least one degraded check)."""
+        return self.consecutive_degraded > 0
+
+    def observe(self, healthy: bool) -> RecoveryAction:
+        """Record one health check and return the action it calls for."""
+        if healthy:
+            self.consecutive_degraded = 0
+            return RecoveryAction.NONE
+
+        self.consecutive_degraded += 1
+        n = self.consecutive_degraded
+        if self.restart_after is not None and n >= self.restart_after:
+            # Checked before FULL_RESET because it is the higher rung: once
+            # in-process repair has demonstrably failed this many times,
+            # repeating it is the behaviour we are fixing.
+            self.restarts_requested += 1
+            return RecoveryAction.RESTART_SELF
+        if n >= self.full_reset_after:
+            # Stays here rather than giving up.  A client that cannot
+            # recover must keep trying: going quiet is the exact failure
+            # this ladder exists to prevent.
+            self.full_resets += 1
+            return RecoveryAction.FULL_RESET
+        if n >= self.reprovision_after:
+            self.reprovisions += 1
+            return RecoveryAction.REPROVISION
+        return RecoveryAction.NONE
+
+    def reset(self) -> None:
+        """Forget the current fault (not the totals)."""
+        self.consecutive_degraded = 0

ka9q/resequencer.py

@@ -157,11 +157,47 @@ class PacketResequencer:
             self.stats.packets_duplicate += 1
             return None, []
         
+        # radiod zero-fills a dropped output block, so this packet may
+        # carry synthetic samples with a perfectly contiguous timestamp.
+        # Detect it here, before the resequencer -- which by definition
+        # cannot see it, there being no timestamp gap to find.
+        zero_gap = self._detect_zero_block(packet)
+
         # Add to buffer
         self._add_to_buffer(packet)
         
         # Try to output packets in sequence order
-        return self._try_output()
+        samples, gaps = self._try_output()
+        if zero_gap is not None:
+            gaps = list(gaps) + [zero_gap]
+        return samples, gaps
+
+    def _detect_zero_block(self, packet: RTPPacket) -> Optional[GapEvent]:
+        """A packet of nothing but exact zeros is radiod's drop marker.
+
+        Cheap on the hot path: real samples almost always have a
+        non-zero first element, so the full scan is only reached for
+        packets that are already suspect.
+        """
+        samples = packet.samples
+        if samples is None or len(samples) == 0:
+            return None
+        if samples[0] != 0 or samples.any():
+            return None
+        n = len(samples)
+        self.stats.samples_filled += n
+        logger.warning(
+            f"radiod block drop: {n} zero samples "
+            f"({n / self.sample_rate * 1000:.1f} ms) at seq={packet.sequence} "
+            f"-- synthetic, not received signal"
+        )
+        return GapEvent(
+            source=GapSource.RADIOD_BLOCK_DROP,
+            position_samples=self.cumulative_samples,
+            duration_samples=n,
+            timestamp_utc=datetime.now(timezone.utc).isoformat(),
+            packets_affected=1,
+        )
     
     def _initialize(self, packet: RTPPacket):
         """Initialize sequencer with first packet"""

ka9q/rtp_recorder.py

@@ -16,6 +16,7 @@ import socket
 import struct
 import logging
 import time
+import warnings
 from enum import Enum
 from typing import Optional, Callable, NamedTuple, Dict, Any
 from dataclasses import dataclass
@@ -242,9 +243,24 @@ def rtp_to_utc(
     return wall_time_ns / BILLION
 
 
-# Deprecated alias — kept so existing callers keep working.  Prefer
-# ``rtp_to_utc`` (the reference is RTP/GPS, not the host wall clock).
-rtp_to_wallclock = rtp_to_utc
+def rtp_to_wallclock(
+    rtp_timestamp: int,
+    channel: ChannelInfo,
+    wallclock_hint_sec: Optional[float] = None,
+) -> Optional[float]:
+    """Deprecated alias for :func:`rtp_to_utc` (renamed 2026-06-27).
+
+    Identical signature and behavior.  Emits ``DeprecationWarning`` on
+    every call (audit finding F16) — the in-tree sigmond clients migrated
+    2026-08; this is the visible signal for any remaining callers.
+    """
+    warnings.warn(
+        "ka9q rtp_to_wallclock() is deprecated; use rtp_to_utc() "
+        "(same signature and behavior, renamed 2026-06-27)",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return rtp_to_utc(rtp_timestamp, channel, wallclock_hint_sec)
 
 
 class RTPRecorder:
@@ -479,7 +495,7 @@ class RTPRecorder:
                 payload = data[header_len:]
                 
                 # Compute wall-clock time
-                wallclock = rtp_to_wallclock(header.timestamp, self.channel)
+                wallclock = rtp_to_utc(header.timestamp, self.channel)
                 
                 # Call packet callback
                 if self.on_packet:

ka9q/status_listener.py

@@ -475,6 +475,15 @@ class StatusListener:
         if enc is not None:
             ci.encoding = enc
 
+        # Cumulative per-channel output block drops.  Refreshed here so a
+        # long-running client can watch radiod's own loss counter without
+        # opening a second status socket -- differencing it across two
+        # reads is the honest measurement; the level alone is meaningless
+        # because it accumulates from radiod start.
+        drops = status.get("filter_drops")
+        if drops is not None:
+            ci.filter_drops = drops
+
         self.stats.updates_applied += 1
 
         for cb in per_ssrc_callbacks:

ka9q/stream.py

@@ -36,9 +36,11 @@ import numpy as np
 from datetime import datetime, timezone
 from typing import Optional, Callable, List
 
+from .types import DemodType
+
 from ._multicast import join_multicast_all_interfaces
 from .discovery import ChannelInfo
-from .rtp_recorder import RTPHeader, parse_rtp_header, rtp_to_wallclock
+from .rtp_recorder import RTPHeader, parse_rtp_header, rtp_to_utc
 from .resequencer import PacketResequencer, RTPPacket
 from .stream_quality import GapSource, GapEvent, StreamQuality
 from .types import Encoding
@@ -181,6 +183,46 @@ def _decode_to_float32(payload: bytes, encoding: int, *, is_iq: bool = False) ->
     return np.frombuffer(payload, dtype='<f4').astype(np.float32, copy=False)
 
 
+def _derive_is_iq(demod_type, output_channels, preset) -> bool:
+    """Does this channel's payload carry complex samples?
+
+    Decided from the parameter vector radiod treats as definitive, and only
+    from the preset label when the vector is absent.
+
+    Phil Karn, 2026-09-21: "the individual parameters [are] definitive, with
+    a preset just being a convenient shorthand for loading a specific
+    predefined set of them into the channel."  A preset can be tweaked out of
+    truth -- send PRESET USB, retune the filters to -3000,-50, and you have
+    the lower sideband while the label still reads "usb" -- and from the
+    nopreset branch onward radiod may not echo it at all.  Reading the label
+    then yields 'unknown', flips this flag false, and every complex stream is
+    parsed as audio at half the samples per packet, with nothing raised and
+    nothing logged.
+
+    ⛔ Two output channels does NOT mean complex on its own.  ka9q-radio
+    docs/table.csv: OUTPUT_CHANNELS is "1 or 2 in Linear and WFM, 1 in FM",
+    so a WFM channel with two of them is carrying stereo AUDIO.  Only under
+    the linear demodulator do two channels mean I and Q.
+    """
+    if demod_type is not None:
+        if demod_type in (int(DemodType.SPECT_DEMOD),
+                          int(DemodType.SPECT2_DEMOD)):
+            # Unchanged from the preset-based behaviour.  Whether spectrum
+            # framing truly matches IQ is a separate question; do not answer
+            # it silently while fixing something else.
+            return True
+        if demod_type == int(DemodType.LINEAR_DEMOD):
+            if output_channels is not None:
+                return output_channels == 2
+            # Linear with no channel count: fall through to the label rather
+            # than guess, since linear covers both IQ and every real mode.
+        else:
+            return False   # FM, WFM -- never complex, whatever the count
+
+    label = (preset or "").lower()
+    return label in ('iq', 'spectrum')
+
+
 class OpusDecoder:
     """Optional Opus → float32 decoder for radiod OPUS / OPUS_VOIP streams.
 
@@ -263,6 +305,7 @@ class RadiodStream:
         samples_per_packet: int = 320,
         resequence_buffer_size: int = 64,
         deliver_interval_packets: int = 10,
+        raw_payloads: bool = False,
     ):
         """
         Initialize RadiodStream.
@@ -273,11 +316,31 @@ class RadiodStream:
             samples_per_packet: Expected samples per RTP packet (320 @ 16kHz)
             resequence_buffer_size: Packets to buffer for resequencing (64 = ~2s)
             deliver_interval_packets: Deliver to callback every N packets (batching)
+            raw_payloads: Deliver undecoded RTP payloads instead of samples.
+                ``on_samples`` then receives a ``List[bytes]`` — one entry per
+                RTP packet, in arrival order — rather than an ``np.ndarray``.
+
+                This is the transport mode for the *framed* encodings that
+                ``parse_rtp_samples()`` deliberately does not decode: OPUS,
+                OPUS_VOIP and AX25.  Without it those payloads are dropped
+                (``_parse_samples`` returns None) and the callback never fires.
+
+                Use it when the consumer wants the codec frames themselves —
+                forwarding Opus to a browser's WebCodecs decoder, or writing
+                an Ogg/AX25 file — rather than PCM.  To get PCM from an Opus
+                channel instead, decode the frames with :class:`OpusDecoder`.
+
+                The resequencer is bypassed: a codec frame is opaque, so it
+                can be neither concatenated nor zero-filled, and gap
+                concealment belongs to the decoder (Opus has built-in PLC).
+                Loss/reorder therefore surface to the consumer, which for a
+                sequenced transport like TCP/WebSocket is exactly right.
         """
         self.channel = channel
         self.on_samples = on_samples
         self.samples_per_packet = samples_per_packet
         self.deliver_interval_packets = deliver_interval_packets
+        self.raw_payloads = raw_payloads
         
         # Resequencer
         self.resequencer = PacketResequencer(
@@ -289,7 +352,8 @@ class RadiodStream:
         # Quality tracking
         self.quality = StreamQuality()
         
-        # Sample accumulator for batched delivery
+        # Sample accumulator for batched delivery.  In raw_payloads mode the
+        # entries are `bytes` (one RTP payload each) instead of arrays.
         self._sample_buffer: List[np.ndarray] = []
         self._gap_buffer: List[GapEvent] = []
         self._pending_rtp_start = None
@@ -305,10 +369,14 @@ class RadiodStream:
         self._max_reconnect_backoff = 60.0  # Max backoff
         self._consecutive_errors = 0
         
-        # Detect payload format from channel preset
+        # Detect payload format from the channel's PARAMETERS, not its label.
         # IQ mode: complex64 (interleaved float32 I/Q)
         # Audio modes: float32 (mono or stereo)
-        self._is_iq = channel.preset.lower() in ('iq', 'spectrum')
+        self._is_iq = _derive_is_iq(
+            getattr(channel, 'demod_type', None),
+            getattr(channel, 'output_channels', None),
+            getattr(channel, 'preset', None),
+        )
         
         # Payload samples differ from RTP timestamp increment in IQ mode
         # IQ: 160 complex samples per packet, but timestamp advances by 320
@@ -359,12 +427,17 @@ class RadiodStream:
             self._thread.join(timeout=5.0)
             self._thread = None
         
-        # Flush resequencer
-        final_samples, final_gaps = self.resequencer.flush()
-        if len(final_samples) > 0 or final_gaps:
-            self._sample_buffer.append(final_samples)
-            self._gap_buffer.extend(final_gaps)
+        # Flush resequencer.  In raw_payloads mode it never ran, and its
+        # ndarray output must not be mixed into a buffer of codec frames —
+        # just deliver whatever frames are still pending.
+        if self.raw_payloads:
             self._deliver_samples()
+        else:
+            final_samples, final_gaps = self.resequencer.flush()
+            if len(final_samples) > 0 or final_gaps:
+                self._sample_buffer.append(final_samples)
+                self._gap_buffer.extend(final_gaps)
+                self._deliver_samples()
         
         logger.info(
             f"RadiodStream stopped. Completeness: {self.quality.completeness_pct:.1f}%, "
@@ -581,13 +654,28 @@ class RadiodStream:
             self._record_empty_payload(header)
             return
         
+        # Raw-payload mode: the payload is an opaque codec frame.  Buffer it
+        # verbatim and skip both the sample parser and the resequencer, which
+        # can only operate on numeric samples.
+        if self.raw_payloads:
+            self._sample_buffer.append(payload)
+            self._packets_since_delivery += 1
+            if self._packets_since_delivery >= self.deliver_interval_packets:
+                self._deliver_samples()
+            wallclock = rtp_to_utc(header.timestamp, self.channel)
+            if wallclock:
+                self.quality.last_packet_utc = datetime.fromtimestamp(
+                    wallclock, tz=timezone.utc
+                ).isoformat()
+            return
+        
         # Parse samples from payload
         samples = self._parse_samples(payload)
         if samples is None:
             return
         
         # Get wallclock time
-        wallclock = rtp_to_wallclock(header.timestamp, self.channel)
+        wallclock = rtp_to_utc(header.timestamp, self.channel)
         
         # Create packet for resequencer
         packet = RTPPacket(
@@ -649,28 +737,40 @@ class RadiodStream:
         if not self._sample_buffer:
             return
         
-        # Combine samples
-        samples = np.concatenate(self._sample_buffer)
+        # Combine samples.  Opaque codec frames stay a list of bytes — they
+        # have no numeric representation to concatenate — and their "sample"
+        # count is a frame count.
+        if self.raw_payloads:
+            samples = list(self._sample_buffer)
+            n_units = len(samples)
+        else:
+            samples = np.concatenate(self._sample_buffer)
+            n_units = len(samples)
         gaps = list(self._gap_buffer)
         
         # Update quality for this batch
         batch_start = self.quality.total_samples_delivered
         self.quality.batch_start_sample = batch_start
         self.quality.delivered_rtp_start = self._pending_rtp_start
-        self.quality.batch_samples_delivered = len(samples)
+        self.quality.batch_samples_delivered = n_units
         self.quality.batch_gaps = gaps
-        self.quality.total_samples_delivered += len(samples)
+        self.quality.total_samples_delivered += n_units
         
-        # Update expected samples (based on actual payload samples per packet)
-        self.quality.total_samples_expected = (
-            self.quality.rtp_packets_received * self._payload_samples_per_packet
-        )
-        
-        # Update RTP loss stats from resequencer
-        reseq_stats = self.resequencer.get_stats()
-        self.quality.rtp_packets_lost = reseq_stats.get('gaps_detected', 0)
-        self.quality.rtp_packets_resequenced = reseq_stats.get('packets_resequenced', 0)
-        self.quality.rtp_packets_duplicate = reseq_stats.get('packets_duplicate', 0)
+        if self.raw_payloads:
+            # One delivered unit per RTP packet, so "expected" is the packet
+            # count.  Resequencer stats stay zero: it never ran.
+            self.quality.total_samples_expected = self.quality.rtp_packets_received
+        else:
+            # Update expected samples (based on actual payload samples per packet)
+            self.quality.total_samples_expected = (
+                self.quality.rtp_packets_received * self._payload_samples_per_packet
+            )
+            
+            # Update RTP loss stats from resequencer
+            reseq_stats = self.resequencer.get_stats()
+            self.quality.rtp_packets_lost = reseq_stats.get('gaps_detected', 0)
+            self.quality.rtp_packets_resequenced = reseq_stats.get('packets_resequenced', 0)
+            self.quality.rtp_packets_duplicate = reseq_stats.get('packets_duplicate', 0)
         
         # Clear buffers
         self._sample_buffer = []

ka9q/stream_quality.py

@@ -32,6 +32,19 @@ class GapSource(Enum):
     
     RESEQUENCE_TIMEOUT = "resequence_timeout"
     """Packet arrived after resequence window expired"""
+
+    RADIOD_BLOCK_DROP = "radiod_block_drop"
+    """radiod dropped a filter output block and emitted zeros in its place.
+
+    Since ka9q-radio 55d9048d (2026.08.15-1-trixie1) a lapped output
+    block is counted and zero-filled rather than skipped, which keeps
+    sample counts honest but leaves RTP timestamps CONTIGUOUS -- so no
+    timestamp gap exists for the resequencer to find.  The zeros
+    themselves are the signal: a solid block of exact IEEE-754 zeros
+    across every sample does not occur in real RF, where ~144 dB of
+    instantaneous float dynamic range means noise always occupies the
+    low bits.  Distinct from NETWORK_LOSS: the packets DID arrive, and
+    the samples they carry are synthetic rather than missing."""
     
     EMPTY_PAYLOAD = "empty_payload"
     """RTP packet received but payload was empty/zeros"""

ka9q/types.py

@@ -2,7 +2,7 @@
 ka9q-radio protocol types and constants
 
 Auto-generated by scripts/sync_types.py from ka9q-radio C headers.
-Validated against ka9q-radio commit: cedec349f7b4
+Validated against ka9q-radio commit: 401992cdecaa
 
 DO NOT EDIT MANUALLY — run: python scripts/sync_types.py --apply
 """
@@ -158,9 +158,9 @@ class Encoding:
     F16 = F16LE
 
 
-# Demodulator types — auto-generated from ka9q-radio/src/radio.h
+# Demodulator types — auto-generated from ka9q-radio (see ENUM_SEARCH_PATHS)
 class DemodType:
-    """Demodulator types — values must match ka9q-radio/src/radio.h enum demod_type"""
+    """Demodulator types — values must match ka9q-radio enum demod_type (status.h since 2026-09-19)"""
 
     INVALID_DEMOD = -1  # used as sentinel
     LINEAR_DEMOD = 0  # Linear demodulation, i.e., everything else: SSB, CW, DSB, CAM, IQ
@@ -176,6 +176,7 @@ class DemodType:
 class WindowType:
     """FFT window types — values must match ka9q-radio/src/window.h enum window_type"""
 
+    INVALID_WINDOW = -1
     KAISER_WINDOW = 0
     RECT_WINDOW = 1  # essentially kaiser with beta = 0
     BLACKMAN_WINDOW = 2

{ka9q_python-3.22.0.dist-info → ka9q_python-3.26.0.dist-info}/METADATA

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

ka9q_python-3.26.0.dist-info/RECORD

@@ -0,0 +1,30 @@
+ka9q/__init__.py,sha256=P2glBiqPlHhJO7YN8TAMMg9SBtBcwtql_AF5MZxOBE0,5483
+ka9q/_multicast.py,sha256=U6pCiH1ruy3i5yv7B_rRhkakokwnetu1Nd3009nAI5w,3343
+ka9q/addressing.py,sha256=GaHLeTwRpsmJawRAROoj-AqALcVkqO6Jq4_th9u7fjE,2681
+ka9q/cli.py,sha256=nfU4hqScqjJtuWBBraPxUb-37cvjY_qtZkNIxr9GzRU,15040
+ka9q/compat.py,sha256=uiU-wkQ1p88fcfPYRdqU1QxHiunmQPIhM5CXkW_5GMs,436
+ka9q/control.py,sha256=twKMbLjXmkAp2P2Pi51QKCj1W8zrv4wE-4RYSSeL7Zk,156426
+ka9q/discovery.py,sha256=-jGcDczuwEQmmJRogc2hR22PUKT2qxWkPgy_ffd9Cdk,28615
+ka9q/exceptions.py,sha256=_P8rok_tTmRMu-lLRhS95kv8FRK5PEY80_6jIux2mWM,474
+ka9q/managed_stream.py,sha256=gHvGcQgJF5FCOzVp7V6vcIp75NLGnOHgClGR24i9_No,18842
+ka9q/monitor.py,sha256=jw4UqoPpmKhX_xImQ31AvOmET6rsetCoefd7UBB9Tpo,5262
+ka9q/multi_stream.py,sha256=0ztgMVPRh0bZTFbsCTdeejWe3SRJYaF8Pha67MV98t0,31774
+ka9q/pps_calibrator.py,sha256=yaVEzr1zmXXbPNwnISGoqMq2HcuUWmVLLqYCfjj8avk,11656
+ka9q/recovery_ladder.py,sha256=033U8r3E-ncS_hubKMcQHv5SZAot0gX5pQS5srA9y5M,5877
+ka9q/resequencer.py,sha256=m_OWattFpqIugSqWr6aadsmUeoJIPkfINKfPi6gp_sg,17300
+ka9q/rtp_recorder.py,sha256=-YpG9mleoGjEd5voPSxnGcdVsFvyxSgOJ8f7ZaXGcT0,23210
+ka9q/slot_clock.py,sha256=9OuE1qMHJ5YBHfNPtQSguj_KHgkU9iAXfhOLEk-1B78,13468
+ka9q/spectrum_stream.py,sha256=utMhpH8hkkwOSD1WpKb4r0YHm3isDF0TvYMq-jJJFwY,11458
+ka9q/status.py,sha256=Tep1FW4bgg80v0qn18Biulg6g0S1F2LmbrDXVu2HXSg,28224
+ka9q/status_listener.py,sha256=20l9aHii263myYlO8mmSgI_tUcchUwLwgh69Dx-1UQY,20045
+ka9q/stream.py,sha256=s1Xl4Njia9DwXxsSF2XSon1plFjJoDXXXCGeLZdF734,33111
+ka9q/stream_quality.py,sha256=YrKa07PzDi4xeF5tubwpDvSTs5eHu0G7mOa12iIINrs,8222
+ka9q/tui.py,sha256=ryL5CxfYkVzXhsCy1hw9GP3ya8hDbZTccfkc_uJtrDQ,27182
+ka9q/types.py,sha256=woWL_ShotZnYUYsR4RBL2wu13S1MTkkJC9_-9IVh14g,7514
+ka9q/utils.py,sha256=fFR_sYIpeDyPaFlXzN6jCiGhYlssvrMMVx4z6vyhqcc,7107
+ka9q_python-3.26.0.dist-info/licenses/LICENSE,sha256=mjz-l5TVsO9j7Jqt1gfLvTWtZK_HL9sZRRpsHaq4Qv8,1074
+ka9q_python-3.26.0.dist-info/METADATA,sha256=6Bj7pdfXVJebxW24J-3bInOyKsh32qjMzz16_hirSq0,14637
+ka9q_python-3.26.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+ka9q_python-3.26.0.dist-info/entry_points.txt,sha256=Wt5Q4OMUKHaf4KdsZXWsjSBpbHVuTtt3pypVIHi7eRk,39
+ka9q_python-3.26.0.dist-info/top_level.txt,sha256=FUTLZDtQpJGenGPPlN34E5QpQi_oaiLB6LuzgHblBNE,5
+ka9q_python-3.26.0.dist-info/RECORD,,

ka9q_python-3.22.0.dist-info/RECORD

@@ -1,29 +0,0 @@
-ka9q/__init__.py,sha256=VNGzyyvs0Lz9MG34Kts04BrOvzZS9G7Z4R2La3XNPlE,5364
-ka9q/_multicast.py,sha256=U6pCiH1ruy3i5yv7B_rRhkakokwnetu1Nd3009nAI5w,3343
-ka9q/addressing.py,sha256=GaHLeTwRpsmJawRAROoj-AqALcVkqO6Jq4_th9u7fjE,2681
-ka9q/cli.py,sha256=nfU4hqScqjJtuWBBraPxUb-37cvjY_qtZkNIxr9GzRU,15040
-ka9q/compat.py,sha256=YimJ1SzJOf7_TiJccun_aq_CgJ0Xtnexq_XsXY5ZHoQ,436
-ka9q/control.py,sha256=fVvLMzSx3Tl6ZdfCal257TzCl5fGInwkwJ8BCpmlFu4,146362
-ka9q/discovery.py,sha256=JjA-zKqHmib8W6KOMpCMX30IFoWrWiDj1ckbkzR-jqA,27131
-ka9q/exceptions.py,sha256=_P8rok_tTmRMu-lLRhS95kv8FRK5PEY80_6jIux2mWM,474
-ka9q/managed_stream.py,sha256=I3P7C74ssDKebfCzU4hD4HbnfYbJOeC39c-VaZqLlSU,18404
-ka9q/monitor.py,sha256=jw4UqoPpmKhX_xImQ31AvOmET6rsetCoefd7UBB9Tpo,5262
-ka9q/multi_stream.py,sha256=ConVJBgi_snqzG_VpbNh6dmaNJhQWb4GiRtmX3S-EK8,30449
-ka9q/pps_calibrator.py,sha256=yaVEzr1zmXXbPNwnISGoqMq2HcuUWmVLLqYCfjj8avk,11656
-ka9q/resequencer.py,sha256=EgYAj_s0sWr8gS2EG-8Rz5Jw7HYla82sPytQKqwrses,15797
-ka9q/rtp_recorder.py,sha256=UBxurokkU9pECK2sfWw9I4iy7KquDxpkWb9XW3cm2zE,22667
-ka9q/slot_clock.py,sha256=9OuE1qMHJ5YBHfNPtQSguj_KHgkU9iAXfhOLEk-1B78,13468
-ka9q/spectrum_stream.py,sha256=utMhpH8hkkwOSD1WpKb4r0YHm3isDF0TvYMq-jJJFwY,11458
-ka9q/status.py,sha256=Tep1FW4bgg80v0qn18Biulg6g0S1F2LmbrDXVu2HXSg,28224
-ka9q/status_listener.py,sha256=oJ_aGhgDKea_j1-rbZFBBFFnw4FQW3CpCESYOrFev_0,19590
-ka9q/stream.py,sha256=VnFQSjVD_WLobH8O9nl1vqqiaWzJdpP-XQc7vy5Ji4w,27905
-ka9q/stream_quality.py,sha256=cuI_wnAuh3Dh5wpkI3ujXgbbh7xobdEgtYuZM1cKnOY,7482
-ka9q/tui.py,sha256=ryL5CxfYkVzXhsCy1hw9GP3ya8hDbZTccfkc_uJtrDQ,27182
-ka9q/types.py,sha256=E4y9wtLABNloL63y6aNsjvOpj_kdrUPiRKjAQcXzacQ,7462
-ka9q/utils.py,sha256=fFR_sYIpeDyPaFlXzN6jCiGhYlssvrMMVx4z6vyhqcc,7107
-ka9q_python-3.22.0.dist-info/licenses/LICENSE,sha256=mjz-l5TVsO9j7Jqt1gfLvTWtZK_HL9sZRRpsHaq4Qv8,1074
-ka9q_python-3.22.0.dist-info/METADATA,sha256=hmTXtuhSSr2KJR1alVBE8M19QVLwi3unHJToVN5FnXU,14637
-ka9q_python-3.22.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-ka9q_python-3.22.0.dist-info/entry_points.txt,sha256=Wt5Q4OMUKHaf4KdsZXWsjSBpbHVuTtt3pypVIHi7eRk,39
-ka9q_python-3.22.0.dist-info/top_level.txt,sha256=FUTLZDtQpJGenGPPlN34E5QpQi_oaiLB6LuzgHblBNE,5
-ka9q_python-3.22.0.dist-info/RECORD,,