ka9q-python 3.13.0__tar.gz → 3.14.1__tar.gz

{ka9q_python-3.13.0 → ka9q_python-3.14.1}/CHANGELOG.md

@@ -1,5 +1,84 @@
 # Changelog
 
+## [3.14.1] - 2026-05-14
+
+### Fixed
+
+- **`RadiodStream`: multi-interface multicast join (parity with
+  `MultiStream`).**  Extends Rob Robinett's `e3acb6a` fix from
+  `multi_stream.py` to `stream.py` so the per-stream `RadiodStream`
+  socket also joins on every local IPv4 interface instead of the
+  single one the kernel picks via `INADDR_ANY`.  Without this, a
+  `RadiodStream` consumer of a co-located radiod with `ttl=0` (or any
+  output that arrives on a non-default-route interface) silently
+  received zero packets.  Most visible to clients that use the
+  per-stream API directly (codar-sounder, hf-timestd's legacy T6
+  path) rather than the shared `MultiStream` socket.
+
+### Refactor
+
+- The helper that enumerates IPv4 interfaces and calls
+  `IP_ADD_MEMBERSHIP` on each is factored into a new package-private
+  `ka9q/_multicast.py` module.  Both `multi_stream.py` and `stream.py`
+  now import from it.  Same behaviour, one implementation.
+  `rtp_recorder.RtpRecorder` still uses the single-interface join —
+  separate fix.
+
+### Tests
+
+- 8 new in `tests/test_multicast_helpers.py`: enumerator behaviour,
+  per-interface join failure handling (one interface failing doesn't
+  abort the loop), empty-enumeration safety, both stream classes
+  pulling the helper from the shared module.
+
+## [3.14.0] - 2026-05-13
+
+### Added
+
+- **`RadiodControl(client_id=...)` for per-client deterministic multicast
+  destinations.**  Closes the CONTRACT v0.3 §7 gap where the spec said
+  "ka9q-python derives the multicast destination" but the implementation
+  never did, so every client on a given radiod landed on radiod's
+  config-file default group.  Two clients with no operator action are now
+  guaranteed to use distinct multicast addresses without per-client
+  derivation code.
+  - New `client_id: Optional[str] = None` kwarg on
+    `RadiodControl.__init__`.  When set, `ensure_channel(destination=None)`
+    auto-derives a `239.x.y.z` address via
+    `generate_multicast_ip(client_id, radiod_host=self.status_address)`.
+  - Destination precedence inside `ensure_channel`:
+    `(1) explicit destination=` >
+    `(2) derived from (client_id, status_address)` >
+    `(3) None → radiod's config default`.
+  - Multi-radiod handling falls out of the hash: a `psk-recorder` instance
+    pointing at `bee1-hf-status.local` derives a different address from
+    one pointing at `bee3-hf-status.local`.
+  - Multi-client handling falls out of the hash: `psk-recorder` and
+    `wspr-recorder` on the same radiod derive different addresses.
+  - `MultiStream._attempt_restore` inherits the behavior because it reuses
+    the same `RadiodControl` instance (and thus the same `client_id`).
+    Restoration after a radiod restart re-creates each channel on the
+    same per-client multicast group it was on before.
+  - Because `allocate_ssrc` already hashes `destination` into the SSRC,
+    per-client destinations produce per-client SSRCs — radiod's channel
+    table cleanly separates concurrent clients.
+
+### Backward Compatibility
+
+- Default behavior unchanged: `RadiodControl(status)` without `client_id`
+  preserves pre-3.14 semantics — `destination=None` flows through, radiod
+  uses its config-file default, every channel from that radiod shares one
+  multicast group.  Clients opt in by passing `client_id="<name>"`.
+
+### Tests
+
+- 9 new unit tests in `tests/test_client_id_destination.py` cover:
+  client_id default-None / set / stored; precedence (explicit wins over
+  derived, no client_id → None); uniqueness invariants (same client on
+  two radiods → distinct; two clients on one radiod → distinct;
+  same client + same radiod → repeatable); SSRC divergence per client.
+  134 offline unit tests pass.
+
 ## [3.13.0] - 2026-05-08
 
 ### Added

{ka9q_python-3.13.0/ka9q_python.egg-info → ka9q_python-3.14.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ka9q-python
-Version: 3.13.0
+Version: 3.14.1
 Summary: Python interface for ka9q-radio control and monitoring
 Home-page: https://github.com/mijahauan/ka9q-python
 Author: Michael Hauan AC0G

{ka9q_python-3.13.0 → ka9q_python-3.14.1}/ka9q/__init__.py

@@ -56,7 +56,7 @@ Lower-level usage (explicit control):
         )
         print(f"Created channel with SSRC: {ssrc}")
 """
-__version__ = '3.13.0'
+__version__ = '3.14.1'
 __author__ = 'Michael Hauan AC0G'
 
 from .control import RadiodControl, allocate_ssrc

ka9q_python-3.14.1/ka9q/_multicast.py

@@ -0,0 +1,90 @@
+"""Shared multicast helpers — multi-interface IP_ADD_MEMBERSHIP.
+
+Factored out of ``multi_stream.py`` (Rob Robinett's e3acb6a) so the
+same join-on-every-interface logic can also be used by
+``stream.RadiodStream`` and ``rtp_recorder.RtpRecorder`` without
+duplicating the SIOCGIFADDR enumeration code.
+
+This module is package-private — callers inside ``ka9q`` import the
+two public helpers below; nothing outside the package should rely on
+the symbol names.
+"""
+
+from __future__ import annotations
+
+import fcntl
+import logging
+import socket
+import struct
+from typing import Iterator, List, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+# Linux SIOCGIFADDR — fetch IPv4 of an interface by name.  Used to enumerate
+# every UP IPv4 interface so the multicast group join can be made on each
+# of them.  Without this, joining with INADDR_ANY lets the kernel pick a
+# single interface (typically the default-route one), which misses:
+#
+#   * Loopback-only multicast emitted by a co-located radiod with TTL=0
+#     (packets sit on `lo`; the kernel won't deliver them to a socket
+#     joined on `ens0`).
+#   * Multi-homed stations where one radiod streams on lo and another
+#     on eth: a single receiver should consume both.
+#
+# Joining on EVERY local IPv4 interface lets one socket receive from any
+# radiod source on any path.
+_SIOCGIFADDR = 0x8915
+
+
+def iter_local_ipv4_interfaces() -> Iterator[Tuple[str, str]]:
+    """Yield (ifname, ipv4_addr_str) for every local interface with an IPv4.
+
+    Order is ``socket.if_nameindex()`` order — typically ``'lo'`` first,
+    then ``ens0``/``eth0``/``wlan0``/etc.  Interfaces without an IPv4
+    (IPv6-only, or freshly-created with no addr) are skipped silently.
+    Stays stdlib-only on Linux (no ``netifaces``/``psutil`` dependency).
+    """
+    try:
+        names = socket.if_nameindex()
+    except OSError:
+        return
+    probe = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    try:
+        for _idx, ifname in names:
+            try:
+                raw = fcntl.ioctl(
+                    probe.fileno(),
+                    _SIOCGIFADDR,
+                    struct.pack("256s", ifname.encode()[:15]),
+                )
+                addr = socket.inet_ntoa(raw[20:24])
+            except OSError:
+                continue
+            yield ifname, addr
+    finally:
+        probe.close()
+
+
+def join_multicast_all_interfaces(sock: socket.socket,
+                                  multicast_address: str) -> List[str]:
+    """Join ``multicast_address`` on every local IPv4 interface.
+
+    Returns the list of interface names where the join succeeded.  Empty
+    list means no interface was usable (extremely rare — even a freshly-
+    booted box has ``lo``).  Per-interface failures are logged at DEBUG
+    and skipped (e.g., a virtual interface without an IPv4).
+    """
+    joined: List[str] = []
+    group = socket.inet_aton(multicast_address)
+    for ifname, ifaddr in iter_local_ipv4_interfaces():
+        mreq = struct.pack("=4s4s", group, socket.inet_aton(ifaddr))
+        try:
+            sock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
+            joined.append(ifname)
+        except OSError as exc:
+            logger.debug(
+                "multicast join on %s (%s) failed: %s",
+                ifname, ifaddr, exc,
+            )
+    return joined

{ka9q_python-3.13.0 → ka9q_python-3.14.1}/ka9q/compat.py

@@ -12,4 +12,4 @@ Usage:
     print(f"Compatible with ka9q-radio at {KA9Q_RADIO_COMMIT}")
 """
 
-KA9Q_RADIO_COMMIT: str = "5498aefd6fd4be7d4ff2f5e33c9b310ecd3b8574"
+KA9Q_RADIO_COMMIT: str = "f78cff9cc8c7fa33ea49aac9176d9263c535a332"

{ka9q_python-3.13.0 → ka9q_python-3.14.1}/ka9q/control.py

@@ -691,18 +691,35 @@ class RadiodControl:
     """
     
     def __init__(self, status_address: str, max_commands_per_sec: int = 100,
-                 interface: Optional[str] = None):
+                 interface: Optional[str] = None,
+                 client_id: Optional[str] = None):
         """
         Initialize radiod control
-        
+
         Args:
             status_address: mDNS name or IP:port of radiod status stream
             max_commands_per_sec: Maximum commands per second (rate limiting)
             interface: IP address of network interface for multicast (e.g., '192.168.1.100').
                       Required on multi-homed systems. If None, uses INADDR_ANY (0.0.0.0).
+            client_id: Identity string for this client application
+                      (e.g. ``"psk-recorder"``, ``"hf-timestd"``).  When set,
+                      :py:meth:`ensure_channel` derives a per-(client, radiod)
+                      multicast destination via
+                      :py:func:`ka9q.generate_multicast_ip` whenever the
+                      caller does not supply an explicit ``destination=``.
+                      Same client_id + same radiod -> same destination
+                      (all of that client's channels share one multicast
+                      group); different client_id OR different radiod ->
+                      distinct destinations (peer clients on one station
+                      never collide; one client targeting two radiods
+                      sees one destination per radiod).  ``None`` (default)
+                      preserves pre-3.14 behavior: when no ``destination=``
+                      is passed, radiod uses its config-file default and
+                      every client lands on the same group.
         """
         self.status_address = status_address
         self.interface = interface
+        self.client_id = client_id
         self.socket = None
         self._status_sock = None  # Cached status listener socket for tune()
         self._status_sock_lock = None  # Will be initialized when needed
@@ -1363,8 +1380,16 @@ class RadiodControl:
             agc_enable: Enable automatic gain control (0=off, 1=on, default: 0)
             gain: Manual gain in dB (default: 0.0). Only used when agc_enable=0
             destination: RTP destination multicast address (optional).
-                        If not specified, uses radiod's default from config file.
-                        If specified, becomes part of the channel identity (SSRC).
+                        Precedence: (1) explicit ``destination=`` wins;
+                        (2) otherwise if the RadiodControl was constructed
+                        with ``client_id=``, this method derives a
+                        deterministic ``239.x.y.z`` address from the
+                        (client_id, status_address) pair so each peer
+                        client on a station gets its own multicast group;
+                        (3) otherwise (``destination=None`` and no
+                        ``client_id``), radiod's config-file default is
+                        used.  The resolved address becomes part of the
+                        channel identity (SSRC).
             encoding: Output encoding (0=none, 4=F32, etc.) - see Encoding class
             timeout: Maximum time to wait for channel verification (default: 5.0s)
             frequency_tolerance: Acceptable frequency deviation in Hz (default: 1.0)
@@ -1418,15 +1443,32 @@ class RadiodControl:
             applications requesting the same parameters will share the same
             channel, reducing radiod resource usage.
         """
+        from .addressing import generate_multicast_ip
         from .discovery import ChannelInfo, discover_channels
-        
+
         # Validate inputs
         _validate_frequency(frequency_hz)
         _validate_sample_rate(sample_rate)
         _validate_gain(gain)
         _validate_preset(preset)
         _validate_timeout(timeout)
-        
+
+        # CONTRACT v0.3 §7: when the RadiodControl was constructed with a
+        # client_id and the caller didn't pass an explicit destination,
+        # derive a deterministic per-(client, radiod) multicast address.
+        # This makes peer clients on the same host land on distinct
+        # multicast groups without per-client derivation code.  An
+        # explicit destination= still wins (e.g. operator override).
+        if destination is None and self.client_id:
+            destination = generate_multicast_ip(
+                unique_id=self.client_id,
+                radiod_host=self.status_address,
+            )
+            logger.debug(
+                "ensure_channel: derived destination=%s for client_id=%r "
+                "radiod=%r", destination, self.client_id, self.status_address,
+            )
+
         # Compute deterministic SSRC from parameters (including radiod identity)
         ssrc = allocate_ssrc(
             frequency_hz=frequency_hz,

{ka9q_python-3.13.0 → ka9q_python-3.14.1}/ka9q/multi_stream.py

@@ -59,6 +59,9 @@ from .stream_quality import GapEvent, GapSource, StreamQuality
 logger = logging.getLogger(__name__)
 
 
+from ._multicast import join_multicast_all_interfaces
+
+
 @dataclass
 class _ChannelSlot:
     """Per-SSRC state within a MultiStream."""
@@ -134,6 +137,7 @@ class MultiStream:
         high_edge: Optional[float] = None,
         kaiser_beta: Optional[float] = None,
         lifetime: Optional[int] = None,
+        timeout: float = 5.0,
     ) -> ChannelInfo:
         """Provision a channel and register it for reception.
 
@@ -153,6 +157,18 @@ class MultiStream:
         ``set_channel_lifetime()`` (or by calling
         RadiodControl.set_channel_lifetime directly on the SSRC).
 
+        ``timeout`` is forwarded to ``ensure_channel`` and bounds the
+        wait for radiod's status-message ACK confirming the channel
+        was created.  The default 5 s is fine for an idle radiod, but
+        when many producers register channels in quick succession
+        (e.g. a multi-client deployment restarting) radiod can stall
+        long enough that 5 s isn't enough — observed on bee1 2026-05-08
+        as the T6 BPSK PPS channel timing out and crashing
+        timestd-core-recorder, which in turn left TSL3 SHM stale.
+        Callers in latency-sensitive setups should pass a longer
+        value (10-30 s) so a brief radiod-busy window doesn't fail
+        the whole channel registration.
+
         Returns the ChannelInfo from ensure_channel().
         """
         channel_info = self._control.ensure_channel(
@@ -166,6 +182,7 @@ class MultiStream:
             high_edge=high_edge,
             kaiser_beta=kaiser_beta,
             lifetime=lifetime,
+            timeout=timeout,
         )
 
         addr = channel_info.multicast_address
@@ -308,12 +325,26 @@ class MultiStream:
 
         sock.bind(("0.0.0.0", self._port))
 
-        mreq = struct.pack(
-            "=4s4s",
-            socket.inet_aton(self._multicast_address),
-            socket.inet_aton("0.0.0.0"),
+        # Join the multicast group on EVERY local IPv4 interface, not
+        # via INADDR_ANY (which lets the kernel pick a single interface
+        # — typically the default route — and silently misses radiod
+        # outputs on other paths, e.g. TTL=0 loopback packets from a
+        # co-located radiod).  Helper lives in ka9q._multicast so
+        # stream.RadiodStream uses identical logic.
+        joined = join_multicast_all_interfaces(
+            sock, self._multicast_address,
         )
-        sock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
+        if not joined:
+            logger.warning(
+                "MultiStream: no interface accepted the multicast "
+                "join for %s — recvfrom() will return nothing",
+                self._multicast_address,
+            )
+        else:
+            logger.debug(
+                "MultiStream: joined %s on interfaces: %s",
+                self._multicast_address, ", ".join(joined),
+            )
         sock.settimeout(1.0)
         return sock
 

{ka9q_python-3.13.0 → ka9q_python-3.14.1}/ka9q/rtp_recorder.py

@@ -127,34 +127,72 @@ def parse_rtp_header(data: bytes) -> Optional[RTPHeader]:
 def rtp_to_wallclock(rtp_timestamp: int, channel: ChannelInfo) -> Optional[float]:
     """
     Convert RTP timestamp to Unix wall-clock time
-    
+
     Uses the GPS_TIME/RTP_TIMESNAP timing information from radiod.
-    
+
     Args:
         rtp_timestamp: RTP timestamp from packet header
         channel: ChannelInfo with gps_time, rtp_timesnap, sample_rate
-    
+
     Returns:
         Unix timestamp (seconds) or None if timing info unavailable
+
+    Wraparound handling:
+        RTP timestamps are 32-bit and wrap every 2**32 samples.  At
+        96 kHz that's 12.43 hours; at 16 kHz it's 74.6 hours.  The
+        ``rtp_timesnap``/``gps_time`` pair is captured once at SSRC
+        discovery, so an SSRC alive longer than one wrap period is
+        in a *later* RTP epoch than the snapshot — the naive signed
+        32-bit subtraction is correct only within ±2**31 samples
+        (~6 hours at 96 kHz) of the snapshot, beyond which it
+        silently aliases.
+
+        We disambiguate by picking the wrap-epoch count ``k`` (full
+        2**32-sample periods elapsed since the snapshot) that places
+        the resulting wall-clock time closest to the local system
+        clock.  System clock stays within seconds of true UTC even
+        under hostile conditions, and the wrap ambiguity period is
+        hours, so this is robust without tight NTP discipline.
+
+        Observed on bee1 2026-05-08: long-running SSRCs caused TSL3
+        SHM samples stuck at the snapshot's wall-clock time, ~12.4 h
+        behind.  Chrony filtered every sample and reach fell to 0.
     """
     if channel.gps_time is None or channel.rtp_timesnap is None:
         return None
-    
+
     # Convert GPS nanoseconds to Unix time
     # GPS epoch is Jan 6, 1980; Unix epoch is Jan 1, 1970
     # gps_time is nanoseconds since GPS epoch, so add GPS_UTC_OFFSET (in ns)
     # AND subtract current GPS_LEAP_SECONDS (18s) to align with UTC
     sender_time = channel.gps_time + BILLION * (GPS_UTC_OFFSET - GPS_LEAP_SECONDS)
-    
-    # Add offset from RTP timestamp difference
-    # Cast to int32 for proper wrapping behavior
+
+    # Signed 32-bit RTP delta — correct within ±2**31 samples of
+    # the snapshot.
     rtp_delta = int((rtp_timestamp - channel.rtp_timesnap) & 0xFFFFFFFF)
     if rtp_delta > 0x7FFFFFFF:
         rtp_delta -= 0x100000000
-    
-    time_offset = BILLION * rtp_delta // channel.sample_rate
-    
-    wall_time_ns = sender_time + time_offset
+
+    base_wall_ns = sender_time + (BILLION * rtp_delta // channel.sample_rate)
+
+    # Adjust for wrap epochs.  One period = 2**32 samples =
+    # BILLION * 2**32 // sample_rate ns.  Pick the integer k that
+    # minimises |base_wall_ns + k*period - sys_now_ns| — i.e. the
+    # value closest to the system clock.  Exact when sys clock is
+    # within ±period/2 of true UTC.
+    period_ns = BILLION * 0x100000000 // channel.sample_rate
+    sys_now_ns = int(time.time() * BILLION)
+    diff_ns = sys_now_ns - base_wall_ns
+    if period_ns > 0:
+        # Round-to-nearest of diff_ns / period_ns (Python `//` is
+        # floor; bias by half-period before flooring to round).
+        if diff_ns >= 0:
+            k = (diff_ns + period_ns // 2) // period_ns
+        else:
+            k = -(((-diff_ns) + period_ns // 2) // period_ns)
+    else:
+        k = 0
+    wall_time_ns = base_wall_ns + k * period_ns
 
     # Apply L6 BPSK PPS chain-delay calibration if available.
     # This corrects for the end-to-end RF→ADC→DSP→RTP latency

{ka9q_python-3.13.0 → ka9q_python-3.14.1}/ka9q/stream.py

@@ -36,6 +36,7 @@ import numpy as np
 from datetime import datetime, timezone
 from typing import Optional, Callable, List
 
+from ._multicast import join_multicast_all_interfaces
 from .discovery import ChannelInfo
 from .rtp_recorder import RTPHeader, parse_rtp_header, rtp_to_wallclock
 from .resequencer import PacketResequencer, RTPPacket
@@ -232,22 +233,34 @@ class RadiodStream:
         
         # Bind to port
         sock.bind(('0.0.0.0', self.channel.port))
-        
-        # Join multicast group
-        mreq = struct.pack(
-            '=4s4s',
-            socket.inet_aton(self.channel.multicast_address),
-            socket.inet_aton('0.0.0.0')
+
+        # Join the multicast group on EVERY local IPv4 interface (lo,
+        # ens0, etc.) — not via INADDR_ANY, which leaves the choice to
+        # the kernel's routing table and silently misses radiod outputs
+        # that arrive on a non-default interface.  Most notably, a
+        # co-located radiod with TTL=0 emits only on `lo`; an
+        # INADDR_ANY join typically resolves to `ens0` and never sees
+        # those packets.  Same helper used by MultiStream (the shared-
+        # socket abstraction) so both classes have identical behaviour.
+        joined = join_multicast_all_interfaces(
+            sock, self.channel.multicast_address,
         )
-        sock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
-        
+        if not joined:
+            logger.warning(
+                "RadiodStream: no interface accepted the multicast "
+                "join for %s — recvfrom() will return nothing",
+                self.channel.multicast_address,
+            )
+        else:
+            logger.debug(
+                "RadiodStream: joined %s:%d on interfaces: %s",
+                self.channel.multicast_address, self.channel.port,
+                ", ".join(joined),
+            )
+
         # Timeout for periodic running check
         sock.settimeout(1.0)
-        
-        logger.debug(
-            f"Joined multicast {self.channel.multicast_address}:{self.channel.port}"
-        )
-        
+
         return sock
     
     def _receive_loop(self):

{ka9q_python-3.13.0 → ka9q_python-3.14.1}/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: 5498aefd6fd4
+Validated against ka9q-radio commit: f78cff9cc8c7
 
 DO NOT EDIT MANUALLY — run: python scripts/sync_types.py --apply
 """

{ka9q_python-3.13.0 → ka9q_python-3.14.1/ka9q_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ka9q-python
-Version: 3.13.0
+Version: 3.14.1
 Summary: Python interface for ka9q-radio control and monitoring
 Home-page: https://github.com/mijahauan/ka9q-python
 Author: Michael Hauan AC0G

{ka9q_python-3.13.0 → ka9q_python-3.14.1}/ka9q_python.egg-info/SOURCES.txt

@@ -36,6 +36,7 @@ examples/tune_example.py
 examples/diagnostics/diagnose_packets.py
 examples/diagnostics/repro_utc_bug.py
 ka9q/__init__.py
+ka9q/_multicast.py
 ka9q/addressing.py
 ka9q/cli.py
 ka9q/compat.py
@@ -67,6 +68,7 @@ tests/__init__.py
 tests/conftest.py
 tests/test_addressing.py
 tests/test_channel_verification.py
+tests/test_client_id_destination.py
 tests/test_create_split_encoding.py
 tests/test_decode_description.py
 tests/test_decode_functions.py
@@ -80,6 +82,7 @@ tests/test_lifetime.py
 tests/test_listen_multicast.py
 tests/test_managed_stream_recovery.py
 tests/test_monitor.py
+tests/test_multicast_helpers.py
 tests/test_multihomed.py
 tests/test_native_discovery.py
 tests/test_performance_fixes.py

{ka9q_python-3.13.0 → ka9q_python-3.14.1}/ka9q_radio_compat

@@ -1,3 +1,3 @@
 # ka9q-radio commit that ka9q/types.py was last validated against
 # Updated by: scripts/sync_types.py --apply
-5498aefd6fd4be7d4ff2f5e33c9b310ecd3b8574
+f78cff9cc8c7fa33ea49aac9176d9263c535a332

{ka9q_python-3.13.0 → ka9q_python-3.14.1}/pyproject.toml

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