ka9q-python 3.4.1__tar.gz → 3.5.0__tar.gz

{ka9q_python-3.4.1 → ka9q_python-3.5.0}/MANIFEST.in

@@ -2,6 +2,12 @@
 include README.md
 include LICENSE
 include SUMMARY.md
+
+# Include protocol compatibility pin
+include ka9q_radio_compat
+
+# Include sync tooling
+recursive-include scripts *.py
 include TUNE_IMPLEMENTATION.md
 include NATIVE_DISCOVERY.md
 include CROSS_PLATFORM_SUPPORT.md

{ka9q_python-3.4.1/ka9q_python.egg-info → ka9q_python-3.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ka9q-python
-Version: 3.4.1
+Version: 3.5.0
 Summary: Python interface for ka9q-radio control and monitoring
 Home-page: https://github.com/mijahauan/ka9q-python
 Author: Michael Hauan AC0G
@@ -48,6 +48,7 @@ Control radiod channels for any application: AM/FM/SSB radio, WSPR monitoring, S
 
 - [Features](#features)
 - [Installation](#installation)
+- [Getting Started](docs/GETTING_STARTED.md)
 - [Quick Start](#quick-start)
 - [Documentation](#documentation)
 - [Examples](#examples)

{ka9q_python-3.4.1 → ka9q_python-3.5.0}/README.md

@@ -13,6 +13,7 @@ Control radiod channels for any application: AM/FM/SSB radio, WSPR monitoring, S
 
 - [Features](#features)
 - [Installation](#installation)
+- [Getting Started](docs/GETTING_STARTED.md)
 - [Quick Start](#quick-start)
 - [Documentation](#documentation)
 - [Examples](#examples)

{ka9q_python-3.4.1 → ka9q_python-3.5.0}/examples/stream_example.py

@@ -123,15 +123,13 @@ def main():
     if args.discover:
         print("Discovering channels...")
         channels = discover_channels(timeout=3.0)
-        channel = None
-        for ch in channels:
-            if ch.ssrc == args.ssrc:
-                channel = ch
-                break
+        
+        # FIX: Properly access the channel from the dictionary
+        channel = channels.get(args.ssrc)
         
         if channel is None:
             print(f"SSRC {args.ssrc} not found in discovered channels")
-            print(f"Available SSRCs: {[ch.ssrc for ch in channels]}")
+            print(f"Available SSRCs: {list(channels.keys())}")
             return 1
         
         print(f"Found channel: {channel.frequency/1e6:.3f} MHz, {channel.sample_rate} Hz")

{ka9q_python-3.4.1 → ka9q_python-3.5.0}/ka9q/__init__.py

@@ -56,7 +56,7 @@ Lower-level usage (explicit control):
         )
         print(f"Created channel with SSRC: {ssrc}")
 """
-__version__ = '3.4.1'
+__version__ = '3.5.0'
 __author__ = 'Michael Hauan AC0G'
 
 from .control import RadiodControl, allocate_ssrc
@@ -147,3 +147,4 @@ __all__ = [
 
 from .addressing import generate_multicast_ip
 from .monitor import ChannelMonitor
+from .compat import KA9Q_RADIO_COMMIT

ka9q_python-3.5.0/ka9q/compat.py

@@ -0,0 +1,15 @@
+"""
+ka9q-radio compatibility pin.
+
+Exposes the ka9q-radio commit hash that this version of ka9q-python
+was validated against.  Intended for consumption by ka9q-update and
+other deployment tooling.
+
+Auto-updated by: scripts/sync_types.py --apply
+
+Usage:
+    from ka9q.compat import KA9Q_RADIO_COMMIT
+    print(f"Compatible with ka9q-radio at {KA9Q_RADIO_COMMIT}")
+"""
+
+KA9Q_RADIO_COMMIT: str = "6b0fec7dae82bf5f4d80cad88ec343453d6e6950"

{ka9q_python-3.4.1 → ka9q_python-3.5.0}/ka9q/control.py

@@ -2407,38 +2407,43 @@ class RadiodControl:
         logger.info(f"Setting Opus FEC for SSRC {ssrc}: {loss_percent}% expected loss")
         self.send_command(cmdbuffer)
     
-    def set_packet_buffering(self, ssrc: int, min_blocks: int):
+    def set_max_delay(self, ssrc: int, max_blocks: int):
         """
-        Set minimum packet buffering (0-4 blocks)
+        Set maximum allowable aggregation delay in blocks (0-5)
         
-        Controls how many blocks to buffer before sending a packet.
+        Controls how many blocks radiod may aggregate before sending a packet.
         Higher values reduce packet rate but increase latency.
         
         Args:
             ssrc: SSRC of the channel
-            min_blocks: Minimum blocks (0-4). At 20ms/block: 0=no minimum, 4=80ms minimum
+            max_blocks: Maximum delay in blocks (0-5). At 20ms/block: 0=immediate, 5=100ms
         
         Raises:
-            ValidationError: If min_blocks is not 0-4
+            ValidationError: If max_blocks is not 0-5
         
         Example:
-            >>> control.set_packet_buffering(ssrc=12345, min_blocks=2)  # 40ms minimum
+            >>> control.set_max_delay(ssrc=12345, max_blocks=2)  # up to 40ms
         """
         _validate_ssrc(ssrc)
-        if not (0 <= min_blocks <= 4):
-            raise ValidationError(f"min_blocks must be 0-4, got {min_blocks}")
+        if not (0 <= max_blocks <= 5):
+            raise ValidationError(f"max_blocks must be 0-5, got {max_blocks}")
         
         cmdbuffer = bytearray()
         cmdbuffer.append(CMD)
         
-        encode_int(cmdbuffer, StatusType.MINPACKET, min_blocks)
+        encode_int(cmdbuffer, StatusType.MAXDELAY, max_blocks)
         encode_int(cmdbuffer, StatusType.OUTPUT_SSRC, ssrc)
         encode_int(cmdbuffer, StatusType.COMMAND_TAG, secrets.randbits(31))
         encode_eol(cmdbuffer)
         
-        logger.info(f"Setting packet buffering for SSRC {ssrc}: {min_blocks} blocks")
+        logger.info(f"Setting max delay for SSRC {ssrc}: {max_blocks} blocks")
         self.send_command(cmdbuffer)
     
+    # Backward compatibility alias
+    def set_packet_buffering(self, ssrc: int, min_blocks: int):
+        """Deprecated: use set_max_delay() instead."""
+        self.set_max_delay(ssrc, min_blocks)
+    
     def set_filter2(self, ssrc: int, blocksize: int, kaiser_beta: Optional[float] = None):
         """
         Configure secondary filter (linear modes only)

ka9q_python-3.5.0/ka9q/types.py

@@ -0,0 +1,158 @@
+"""
+ka9q-radio protocol types and constants
+
+Auto-generated by scripts/sync_types.py from ka9q-radio C headers.
+Validated against ka9q-radio commit: 6b0fec7dae82
+
+DO NOT EDIT MANUALLY — run: python scripts/sync_types.py --apply
+"""
+
+
+class StatusType:
+    """TLV type identifiers for radiod status/control protocol"""
+
+    EOL = 0
+    COMMAND_TAG = 1  # Echoes tag from requester
+    CMD_CNT = 2  # Count of input commands
+    GPS_TIME = 3  # Nanoseconds since GPS epoch (remember to update the leap second tables!)
+    DESCRIPTION = 4  # Free form text describing source
+    STATUS_DEST_SOCKET = 5
+    SETOPTS = 6
+    CLEAROPTS = 7
+    RTP_TIMESNAP = 8  # snapshot of current real-time-protocol timestamp, for linking RTP timestamps to clock time via GPS_TIME
+    BIN_BYTE_DATA = 9  # Vector of 1-byte spectrum analyzer data
+    INPUT_SAMPRATE = 10  # Nominal sample rate (integer)
+    SPECTRUM_BASE = 11  # base level of 1-byte analyzer data, dB
+    SPECTRUM_AVG = 12  # Number of FFTs averaged into each spectrum response
+    INPUT_SAMPLES = 13
+    WINDOW_TYPE = 14  # Window type for FFT analyzer
+    NOISE_BW = 15  # Noise bandwidth of FFT spectrum bin, in bins
+    OUTPUT_DATA_SOURCE_SOCKET = 16
+    OUTPUT_DATA_DEST_SOCKET = 17
+    OUTPUT_SSRC = 18
+    OUTPUT_TTL = 19
+    OUTPUT_SAMPRATE = 20
+    OUTPUT_METADATA_PACKETS = 21
+    OUTPUT_DATA_PACKETS = 22
+    OUTPUT_ERRORS = 23
+    CALIBRATE = 24
+    LNA_GAIN = 25
+    MIXER_GAIN = 26
+    IF_GAIN = 27
+    DC_I_OFFSET = 28
+    DC_Q_OFFSET = 29
+    IQ_IMBALANCE = 30
+    IQ_PHASE = 31
+    DIRECT_CONVERSION = 32  # Boolean indicating SDR is direct conversion -- should avoid DC
+    RADIO_FREQUENCY = 33
+    FIRST_LO_FREQUENCY = 34
+    SECOND_LO_FREQUENCY = 35
+    SHIFT_FREQUENCY = 36
+    DOPPLER_FREQUENCY = 37
+    DOPPLER_FREQUENCY_RATE = 38
+    LOW_EDGE = 39
+    HIGH_EDGE = 40
+    KAISER_BETA = 41
+    FILTER_BLOCKSIZE = 42
+    FILTER_FIR_LENGTH = 43
+    FILTER2 = 44
+    IF_POWER = 45
+    BASEBAND_POWER = 46
+    NOISE_DENSITY = 47
+    DEMOD_TYPE = 48  # 0 = linear (default), 1 = FM, 2 = WFM/Stereo, 3 = spectrum
+    OUTPUT_CHANNELS = 49  # 1 or 2 in Linear and WFM, 1 in FM
+    INDEPENDENT_SIDEBAND = 50  # Linear only
+    PLL_ENABLE = 51
+    PLL_LOCK = 52  # Linear PLL
+    PLL_SQUARE = 53  # Linear PLL
+    PLL_PHASE = 54  # Linear PLL
+    PLL_BW = 55  # PLL loop bandwidth
+    ENVELOPE = 56  # Envelope detection in linear mode
+    SNR_SQUELCH = 57  # Enable SNR squelch, all modes
+    PLL_SNR = 58  # FM, PLL linear
+    FREQ_OFFSET = 59  # FM, PLL linear
+    PEAK_DEVIATION = 60  # FM only
+    PL_TONE = 61  # PL tone squelch frequency (FM only)
+    AGC_ENABLE = 62  # boolean, linear modes only
+    HEADROOM = 63  # Audio level headroom, stored as amplitude ratio, exchanged as dB
+    AGC_HANGTIME = 64  # AGC hang time, stored as samples, exchanged as sec
+    AGC_RECOVERY_RATE = 65  # stored as amplitude ratio/sample, exchanged as dB/sec
+    FM_SNR = 66  # selected FM SNR (variance or signal snr)
+    AGC_THRESHOLD = 67  # stored as amplitude ratio, exchanged as dB
+    GAIN = 68  # AM, Linear only, stored as amplitude ratio, exchanged as dB
+    OUTPUT_LEVEL = 69  # All modes
+    OUTPUT_SAMPLES = 70
+    OPUS_BIT_RATE = 71
+    MAXDELAY = 72  # Maximum allowable aggregation delay, blocks (0-5)
+    FILTER2_BLOCKSIZE = 73
+    FILTER2_FIR_LENGTH = 74
+    FILTER2_KAISER_BETA = 75
+    SPECTRUM_FFT_N = 76
+    FILTER_DROPS = 77
+    LOCK = 78  # Tuner is locked, will ignore retune commands (boolean)
+    TP1 = 79  # General purpose test points (floating point)
+    TP2 = 80
+    UNUSED4 = 81
+    AD_BITS_PER_SAMPLE = 82  # Front end A/D width, used for gain scaling
+    SQUELCH_OPEN = 83  # Squelch opening threshold SNR
+    SQUELCH_CLOSE = 84  # and closing
+    PRESET = 85  # char string containing mode presets
+    DEEMPH_TC = 86  # De-emphasis time constant (FM only)
+    DEEMPH_GAIN = 87  # De-emphasis gain (FM only)
+    UNUSED3 = 88
+    PL_DEVIATION = 89  # Measured PL tone deviation, Hz (FM only)
+    THRESH_EXTEND = 90  # threshold extension enable (FM only)
+    SPECTRUM_SHAPE = 91  # parameter for spectrum analysis window (eg, Kaiser beta)
+    UNUSED2 = 92
+    RESOLUTION_BW = 93  # Bandwidth (Hz) of noncoherent integration bin, some multiple of COHERENT_BIN_SPACING
+    BIN_COUNT = 94  # Integer number of bins accumulating energy noncoherently
+    CROSSOVER = 95  # Frequency in Hz where spectrum algorithm changes
+    BIN_DATA = 96  # Vector of relative bin energies, real (I^2 + Q^2)
+    RF_ATTEN = 97  # Front end attenuation (introduced with rx888)
+    RF_GAIN = 98  # Front end gain (introduced with rx888)
+    RF_AGC = 99  # Front end AGC on/off
+    FE_LOW_EDGE = 100  # edges of front end filter
+    FE_HIGH_EDGE = 101
+    FE_ISREAL = 102  # Boolean, true -> front end uses real sampling, false -> front end uses complex
+    UNUSED = 103
+    AD_OVER = 104  # A/D full scale samples, proxy for overranges
+    RTP_PT = 105  # Real Time Protocol Payload Type
+    STATUS_INTERVAL = 106  # Automatically send channel status over *data* channel every STATUS_INTERVAL frames
+    OUTPUT_ENCODING = 107  # Output data encoding (see enum encoding in multicast.h)
+    SAMPLES_SINCE_OVER = 108  # Samples since last A/D overrange
+    PLL_WRAPS = 109  # Count of complete linear mode PLL rotations
+    RF_LEVEL_CAL = 110  # Adjustment relating dBm to dBFS
+    OPUS_DTX = 111  # Opus encoder discontinuous transmission enable/disable
+    OPUS_APPLICATION = 112  # Opus encoder application voice/audio/etc
+    OPUS_BANDWIDTH = 113  # Opus encoder audio bandwidth limita
+    OPUS_FEC = 114  # Opus encoder forward error correction loss rate, %
+    SPECTRUM_STEP = 115  # size of byte spectrum data level step, dB
+    SPECTRUM_OVERLAP = 116  # Overlap of FFT windows when averaging (0-1)
+
+
+# Command packet type
+CMD = 1
+
+
+# Encoding types — auto-generated from ka9q-radio/src/rtp.h
+class Encoding:
+    """Output encoding types — values must match ka9q-radio/src/rtp.h enum encoding"""
+
+    NO_ENCODING = 0
+    S16LE = 1
+    S16BE = 2
+    OPUS = 3
+    F32LE = 4
+    AX25 = 5
+    F16LE = 6
+    OPUS_VOIP = 7  # Opus with APPLICATION_VOIP
+    F32BE = 8
+    F16BE = 9
+    MULAW = 10
+    ALAW = 11
+    UNUSED_ENCODING = 12  # Sentinel, not used
+
+    # Backward compatibility aliases
+    F32 = F32LE
+    F16 = F16LE
+

{ka9q_python-3.4.1 → ka9q_python-3.5.0/ka9q_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ka9q-python
-Version: 3.4.1
+Version: 3.5.0
 Summary: Python interface for ka9q-radio control and monitoring
 Home-page: https://github.com/mijahauan/ka9q-python
 Author: Michael Hauan AC0G
@@ -48,6 +48,7 @@ Control radiod channels for any application: AM/FM/SSB radio, WSPR monitoring, S
 
 - [Features](#features)
 - [Installation](#installation)
+- [Getting Started](docs/GETTING_STARTED.md)
 - [Quick Start](#quick-start)
 - [Documentation](#documentation)
 - [Examples](#examples)

{ka9q_python-3.4.1 → ka9q_python-3.5.0}/ka9q_python.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 LICENSE
 MANIFEST.in
 README.md
+ka9q_radio_compat
 pyproject.toml
 setup.py
 examples/advanced_features_demo.py
@@ -22,6 +23,7 @@ examples/diagnostics/diagnose_packets.py
 examples/diagnostics/repro_utc_bug.py
 ka9q/__init__.py
 ka9q/addressing.py
+ka9q/compat.py
 ka9q/control.py
 ka9q/discovery.py
 ka9q/exceptions.py
@@ -38,6 +40,7 @@ ka9q_python.egg-info/SOURCES.txt
 ka9q_python.egg-info/dependency_links.txt
 ka9q_python.egg-info/requires.txt
 ka9q_python.egg-info/top_level.txt
+scripts/sync_types.py
 tests/__init__.py
 tests/conftest.py
 tests/test_addressing.py
@@ -55,6 +58,7 @@ tests/test_monitor.py
 tests/test_multihomed.py
 tests/test_native_discovery.py
 tests/test_performance_fixes.py
+tests/test_protocol_compat.py
 tests/test_remove_channel.py
 tests/test_rtp_recorder.py
 tests/test_security_features.py

ka9q_python-3.5.0/ka9q_radio_compat

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

{ka9q_python-3.4.1 → ka9q_python-3.5.0}/pyproject.toml

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

ka9q_python-3.5.0/scripts/sync_types.py

@@ -0,0 +1,402 @@
+#!/usr/bin/env python3
+"""
+Synchronize ka9q/types.py with ka9q-radio C header files.
+
+Parses enum status_type from status.h and enum encoding from rtp.h,
+then either checks for drift or regenerates types.py.
+
+Usage:
+    python scripts/sync_types.py --check   # exit non-zero if drift detected
+    python scripts/sync_types.py --apply   # regenerate types.py and update pin
+    python scripts/sync_types.py --diff    # show what would change (dry run)
+
+Options:
+    --ka9q-radio PATH   Path to ka9q-radio source tree
+                        (default: ../ka9q-radio)
+"""
+
+import argparse
+import re
+import subprocess
+import sys
+import textwrap
+from pathlib import Path
+from typing import Dict, List, Optional, Set, Tuple
+
+# ---------------------------------------------------------------------------
+# Paths (relative to this script's location)
+# ---------------------------------------------------------------------------
+SCRIPT_DIR = Path(__file__).resolve().parent
+PROJECT_ROOT = SCRIPT_DIR.parent
+TYPES_PY = PROJECT_ROOT / "ka9q" / "types.py"
+COMPAT_PY = PROJECT_ROOT / "ka9q" / "compat.py"
+COMPAT_FILE = PROJECT_ROOT / "ka9q_radio_compat"
+
+
+# ---------------------------------------------------------------------------
+# C enum parser
+# ---------------------------------------------------------------------------
+def parse_c_enum(header_text: str, enum_name: str) -> List[Tuple[str, int, str]]:
+    """
+    Parse a C enum from header text.
+
+    Returns list of (name, value, comment) tuples in declaration order.
+    """
+    # Match the enum block — handles both "enum foo {" and "enum foo\n{"
+    pattern = rf"enum\s+{enum_name}\s*\{{(.*?)\}}"
+    match = re.search(pattern, header_text, re.DOTALL)
+    if not match:
+        raise ValueError(f"Could not find 'enum {enum_name}' in header text")
+
+    body = match.group(1)
+    entries: List[Tuple[str, int, str]] = []
+    value = 0
+
+    for line in body.split("\n"):
+        line = line.strip()
+        if not line or line.startswith("//") or line.startswith("/*"):
+            continue
+
+        # Match:  NAME,  NAME = 3,  NAME = 3, // comment   NAME, // comment
+        m = re.match(
+            r"([A-Z][A-Z0-9_]*)\s*(?:=\s*(\d+))?\s*,?\s*(?://\s*(.*))?\s*$",
+            line,
+        )
+        if not m:
+            continue
+
+        name = m.group(1)
+        if m.group(2) is not None:
+            value = int(m.group(2))
+        comment = (m.group(3) or "").strip()
+
+        entries.append((name, value, comment))
+        value += 1
+
+    return entries
+
+
+def get_git_commit(repo_path: Path) -> str:
+    """Return the full SHA-1 of HEAD in the given repo."""
+    result = subprocess.run(
+        ["git", "-C", str(repo_path), "rev-parse", "HEAD"],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    return result.stdout.strip()
+
+
+# ---------------------------------------------------------------------------
+# types.py parser — reads the CURRENT file to learn what Python already has
+# ---------------------------------------------------------------------------
+def parse_types_py() -> Tuple[Dict[str, int], Dict[str, int]]:
+    """
+    Parse the existing types.py and return:
+        (status_entries, encoding_entries)
+    Each is {name: value}.  Aliases (F32 = F32LE) are excluded.
+    """
+    # We import the module directly so we get the truth including aliases
+    import importlib.util
+
+    spec = importlib.util.spec_from_file_location("_types", str(TYPES_PY))
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+
+    def _class_entries(cls) -> Dict[str, int]:
+        seen_values: Set[int] = set()
+        entries: Dict[str, int] = {}
+        # First pass: collect non-alias attributes (declared first wins)
+        for attr in sorted(dir(cls)):
+            if attr.startswith("_"):
+                continue
+            val = getattr(cls, attr)
+            if not isinstance(val, int):
+                continue
+            entries[attr] = val
+        return entries
+
+    return _class_entries(mod.StatusType), _class_entries(mod.Encoding)
+
+
+# ---------------------------------------------------------------------------
+# Code generator
+# ---------------------------------------------------------------------------
+
+# Comments extracted from the C headers, keyed by enum value ranges.
+# The generator preserves the section-comment structure of the original
+# types.py while replacing the constant definitions.
+
+STATUS_SECTIONS = [
+    (None, None, None),           # section header emitted inline
+]
+
+
+def generate_types_py(
+    status_entries: List[Tuple[str, int, str]],
+    encoding_entries: List[Tuple[str, int, str]],
+    commit_hash: str,
+) -> str:
+    """Generate the full contents of ka9q/types.py from parsed enums."""
+
+    lines: List[str] = []
+
+    lines.append('"""')
+    lines.append("ka9q-radio protocol types and constants")
+    lines.append("")
+    lines.append("Auto-generated by scripts/sync_types.py from ka9q-radio C headers.")
+    lines.append(f"Validated against ka9q-radio commit: {commit_hash[:12]}")
+    lines.append("")
+    lines.append("DO NOT EDIT MANUALLY — run: python scripts/sync_types.py --apply")
+    lines.append('"""')
+    lines.append("")
+    lines.append("")
+    lines.append("class StatusType:")
+    lines.append('    """TLV type identifiers for radiod status/control protocol"""')
+    lines.append("")
+
+    for name, value, comment in status_entries:
+        suffix = f"  # {comment}" if comment else ""
+        lines.append(f"    {name} = {value}{suffix}")
+
+    lines.append("")
+    lines.append("")
+    lines.append("# Command packet type")
+    lines.append("CMD = 1")
+    lines.append("")
+    lines.append("")
+    lines.append("# Encoding types — auto-generated from ka9q-radio/src/rtp.h")
+    lines.append("class Encoding:")
+    lines.append(
+        '    """Output encoding types — values must match '
+        'ka9q-radio/src/rtp.h enum encoding"""'
+    )
+    lines.append("")
+
+    for name, value, comment in encoding_entries:
+        suffix = f"  # {comment}" if comment else ""
+        lines.append(f"    {name} = {value}{suffix}")
+
+    # Backward-compat aliases
+    lines.append("")
+    lines.append("    # Backward compatibility aliases")
+    # Only emit aliases if the canonical names exist
+    enc_names = {n for n, _, _ in encoding_entries}
+    if "F32LE" in enc_names:
+        lines.append("    F32 = F32LE")
+    if "F16LE" in enc_names:
+        lines.append("    F16 = F16LE")
+
+    lines.append("")  # final newline
+    return "\n".join(lines) + "\n"
+
+
+# ---------------------------------------------------------------------------
+# Diff / check / apply
+# ---------------------------------------------------------------------------
+def compute_drift(
+    c_status: List[Tuple[str, int, str]],
+    c_encoding: List[Tuple[str, int, str]],
+) -> List[str]:
+    """
+    Compare C headers against current types.py.
+    Returns a list of human-readable drift descriptions (empty = in sync).
+    """
+    py_status, py_encoding = parse_types_py()
+    issues: List[str] = []
+
+    # --- StatusType ---
+    c_status_map = {name: val for name, val, _ in c_status}
+
+    # Missing in Python
+    for name, val, comment in c_status:
+        if name not in py_status:
+            issues.append(f"StatusType: MISSING  {name} = {val}  // {comment}")
+        elif py_status[name] != val:
+            issues.append(
+                f"StatusType: VALUE MISMATCH  {name}: "
+                f"C={val}, Python={py_status[name]}"
+            )
+
+    # Extra in Python (removed from C or renamed)
+    for name, val in sorted(py_status.items(), key=lambda x: x[1]):
+        if name not in c_status_map:
+            issues.append(f"StatusType: EXTRA in Python  {name} = {val}")
+
+    # --- Encoding ---
+    c_enc_map = {name: val for name, val, _ in c_encoding}
+    # Exclude known aliases from comparison
+    alias_names = {"F32", "F16"}
+
+    for name, val, comment in c_encoding:
+        if name not in py_encoding:
+            issues.append(f"Encoding: MISSING  {name} = {val}  // {comment}")
+        elif py_encoding[name] != val:
+            issues.append(
+                f"Encoding: VALUE MISMATCH  {name}: "
+                f"C={val}, Python={py_encoding[name]}"
+            )
+
+    for name, val in sorted(py_encoding.items(), key=lambda x: x[1]):
+        if name in alias_names:
+            continue
+        if name not in c_enc_map:
+            issues.append(f"Encoding: EXTRA in Python  {name} = {val}")
+
+    return issues
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Synchronize ka9q/types.py with ka9q-radio C headers"
+    )
+    parser.add_argument(
+        "--ka9q-radio",
+        type=Path,
+        default=None,
+        help="Path to ka9q-radio source tree (default: ../ka9q-radio relative to project root)",
+    )
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument(
+        "--check",
+        action="store_true",
+        help="Exit non-zero if types.py is out of sync",
+    )
+    group.add_argument(
+        "--apply",
+        action="store_true",
+        help="Regenerate types.py and update ka9q_radio_compat",
+    )
+    group.add_argument(
+        "--diff",
+        action="store_true",
+        help="Show drift without modifying anything",
+    )
+
+    args = parser.parse_args()
+
+    # Resolve ka9q-radio path
+    if args.ka9q_radio:
+        radio_path = args.ka9q_radio.resolve()
+    else:
+        # Try ../ka9q-radio relative to project root
+        radio_path = (PROJECT_ROOT / ".." / "ka9q-radio").resolve()
+
+    status_h = radio_path / "src" / "status.h"
+    rtp_h = radio_path / "src" / "rtp.h"
+
+    if not status_h.exists():
+        print(f"ERROR: {status_h} not found", file=sys.stderr)
+        print(
+            f"  Provide --ka9q-radio PATH or ensure ka9q-radio is at {radio_path}",
+            file=sys.stderr,
+        )
+        return 2
+
+    if not rtp_h.exists():
+        print(f"ERROR: {rtp_h} not found", file=sys.stderr)
+        return 2
+
+    # Parse C headers
+    status_text = status_h.read_text()
+    rtp_text = rtp_h.read_text()
+
+    c_status = parse_c_enum(status_text, "status_type")
+    c_encoding = parse_c_enum(rtp_text, "encoding")
+
+    commit = get_git_commit(radio_path)
+
+    if args.check or args.diff:
+        issues = compute_drift(c_status, c_encoding)
+        if issues:
+            print(f"Protocol drift detected vs ka9q-radio {commit[:12]}:")
+            print()
+            for issue in issues:
+                print(f"  {issue}")
+            print()
+            print(f"  {len(issues)} issue(s) found")
+            print()
+            print("Run 'python scripts/sync_types.py --apply' to synchronize.")
+            return 1
+        else:
+            print(f"types.py is in sync with ka9q-radio {commit[:12]}")
+            return 0
+
+    # --apply
+    new_content = generate_types_py(c_status, c_encoding, commit)
+
+    # Read current for comparison
+    old_content = TYPES_PY.read_text() if TYPES_PY.exists() else ""
+
+    if new_content == old_content:
+        print(f"types.py is already in sync with ka9q-radio {commit[:12]}")
+    else:
+        TYPES_PY.write_text(new_content)
+        print(f"Updated {TYPES_PY}")
+
+    # Update compat pin (plain text file for scripts/humans)
+    pin_content = (
+        "# ka9q-radio commit that ka9q/types.py was last validated against\n"
+        "# Updated by: scripts/sync_types.py --apply\n"
+        f"{commit}\n"
+    )
+    COMPAT_FILE.write_text(pin_content)
+    print(f"Updated {COMPAT_FILE} → {commit[:12]}")
+
+    # Update ka9q/compat.py (importable constant for ka9q-update)
+    compat_py_content = (
+        '"""\n'
+        "ka9q-radio compatibility pin.\n"
+        "\n"
+        "Exposes the ka9q-radio commit hash that this version of ka9q-python\n"
+        "was validated against.  Intended for consumption by ka9q-update and\n"
+        "other deployment tooling.\n"
+        "\n"
+        "Auto-updated by: scripts/sync_types.py --apply\n"
+        "\n"
+        "Usage:\n"
+        "    from ka9q.compat import KA9Q_RADIO_COMMIT\n"
+        '    print(f"Compatible with ka9q-radio at {KA9Q_RADIO_COMMIT}")\n'
+        '"""\n'
+        "\n"
+        f'KA9Q_RADIO_COMMIT: str = "{commit}"\n'
+    )
+    COMPAT_PY.write_text(compat_py_content)
+    print(f"Updated {COMPAT_PY} → {commit[:12]}")
+
+    # Report what changed
+    issues = []
+    if old_content:
+        # Re-parse to show the delta
+        py_status_old, py_enc_old = parse_types_py()
+        c_status_map = {name: val for name, val, _ in c_status}
+        c_enc_map = {name: val for name, val, _ in c_encoding}
+
+        added_s = [n for n, v, _ in c_status if n not in py_status_old]
+        removed_s = [n for n in py_status_old if n not in c_status_map]
+        added_e = [n for n, v, _ in c_encoding if n not in py_enc_old]
+        removed_e = [
+            n for n in py_enc_old if n not in c_enc_map and n not in {"F32", "F16"}
+        ]
+
+        if added_s:
+            print(f"  StatusType added:   {', '.join(added_s)}")
+        if removed_s:
+            print(f"  StatusType removed: {', '.join(removed_s)}")
+        if added_e:
+            print(f"  Encoding added:     {', '.join(added_e)}")
+        if removed_e:
+            print(f"  Encoding removed:   {', '.join(removed_e)}")
+
+    print()
+    print("Next steps:")
+    print("  1. Review the diff:  git diff ka9q/types.py")
+    print("  2. Update control.py if any names were renamed/removed")
+    print("  3. Run tests:        python -m pytest tests/")
+    print("  4. Commit and bump version")
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{ka9q_python-3.4.1 → ka9q_python-3.5.0}/setup.py

@@ -12,7 +12,7 @@ long_description = readme.read_text() if readme.exists() else ''
 
 setup(
     name='ka9q-python',
-    version='3.4.1',
+    version='3.5.0',
     description='Python interface for ka9q-radio control and monitoring',
     long_description=long_description,
     long_description_content_type='text/markdown',

ka9q_python-3.5.0/tests/test_protocol_compat.py

@@ -0,0 +1,82 @@
+"""
+Protocol compatibility test — catches drift between ka9q/types.py
+and the ka9q-radio C headers (status.h, rtp.h).
+
+Skipped automatically when ka9q-radio source is not available on disk.
+"""
+
+import subprocess
+import sys
+from pathlib import Path
+from typing import Optional
+
+import pytest
+
+# Resolve paths relative to this file
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+SYNC_SCRIPT = PROJECT_ROOT / "scripts" / "sync_types.py"
+KA9Q_RADIO_DEFAULT = PROJECT_ROOT.parent / "ka9q-radio"
+
+
+def _find_ka9q_radio() -> Optional[Path]:
+    """Return the ka9q-radio source path, or None if unavailable."""
+    # Check default sibling location
+    if (KA9Q_RADIO_DEFAULT / "src" / "status.h").exists():
+        return KA9Q_RADIO_DEFAULT
+    return None
+
+
+ka9q_radio_path = _find_ka9q_radio()
+
+
+@pytest.mark.skipif(
+    ka9q_radio_path is None,
+    reason="ka9q-radio source tree not found at ../ka9q-radio",
+)
+def test_types_match_status_h():
+    """types.py must match the ka9q-radio C headers exactly."""
+    result = subprocess.run(
+        [sys.executable, str(SYNC_SCRIPT), "--check",
+         "--ka9q-radio", str(ka9q_radio_path)],
+        capture_output=True,
+        text=True,
+        cwd=str(PROJECT_ROOT),
+    )
+    assert result.returncode == 0, (
+        f"types.py is out of sync with ka9q-radio status.h / rtp.h:\n"
+        f"{result.stdout}\n{result.stderr}"
+    )
+
+
+@pytest.mark.skipif(
+    ka9q_radio_path is None,
+    reason="ka9q-radio source tree not found at ../ka9q-radio",
+)
+def test_compat_pin_matches_ka9q_radio_head():
+    """ka9q_radio_compat pin should match the ka9q-radio HEAD we validated against."""
+    compat_file = PROJECT_ROOT / "ka9q_radio_compat"
+    assert compat_file.exists(), "ka9q_radio_compat pin file is missing"
+
+    pinned = None
+    for line in compat_file.read_text().splitlines():
+        line = line.strip()
+        if line and not line.startswith("#"):
+            pinned = line
+            break
+
+    assert pinned, "ka9q_radio_compat contains no commit hash"
+
+    # Get ka9q-radio HEAD
+    result = subprocess.run(
+        ["git", "-C", str(ka9q_radio_path), "rev-parse", "HEAD"],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    head = result.stdout.strip()
+
+    assert pinned == head, (
+        f"ka9q_radio_compat pin ({pinned[:12]}) does not match "
+        f"ka9q-radio HEAD ({head[:12]}). "
+        f"Run: python scripts/sync_types.py --apply"
+    )

ka9q_python-3.4.1/ka9q/types.py

@@ -1,175 +0,0 @@
-"""
-ka9q-radio protocol types and constants
-
-Status types from ka9q-radio/src/status.h
-These MUST match the enum values in status.h exactly!
-Verified against https://github.com/ka9q/ka9q-radio (official repository)
-"""
-
-class StatusType:
-    """TLV type identifiers for radiod status/control protocol"""
-    
-    EOL = 0
-    COMMAND_TAG = 1
-    CMD_CNT = 2
-    GPS_TIME = 3
-    
-    DESCRIPTION = 4
-    STATUS_DEST_SOCKET = 5
-    SETOPTS = 6
-    CLEAROPTS = 7
-    RTP_TIMESNAP = 8
-    BIN_BYTE_DATA = 9
-    INPUT_SAMPRATE = 10
-    SPECTRUM_BASE = 11
-    SPECTRUM_AVG = 12
-    INPUT_SAMPLES = 13
-    WINDOW_TYPE = 14
-    NOISE_BW = 15
-    
-    OUTPUT_DATA_SOURCE_SOCKET = 16
-    OUTPUT_DATA_DEST_SOCKET = 17
-    OUTPUT_SSRC = 18
-    OUTPUT_TTL = 19
-    OUTPUT_SAMPRATE = 20
-    OUTPUT_METADATA_PACKETS = 21
-    OUTPUT_DATA_PACKETS = 22
-    OUTPUT_ERRORS = 23
-    
-    # Hardware
-    CALIBRATE = 24
-    LNA_GAIN = 25
-    MIXER_GAIN = 26
-    IF_GAIN = 27
-    
-    DC_I_OFFSET = 28
-    DC_Q_OFFSET = 29
-    IQ_IMBALANCE = 30
-    IQ_PHASE = 31
-    DIRECT_CONVERSION = 32
-    
-    # Tuning
-    RADIO_FREQUENCY = 33
-    FIRST_LO_FREQUENCY = 34
-    SECOND_LO_FREQUENCY = 35
-    SHIFT_FREQUENCY = 36
-    DOPPLER_FREQUENCY = 37
-    DOPPLER_FREQUENCY_RATE = 38
-    
-    # Filtering
-    LOW_EDGE = 39
-    HIGH_EDGE = 40
-    KAISER_BETA = 41
-    FILTER_BLOCKSIZE = 42
-    FILTER_FIR_LENGTH = 43
-    FILTER2 = 44
-    
-    # Signals
-    IF_POWER = 45
-    BASEBAND_POWER = 46
-    NOISE_DENSITY = 47
-    
-    # Demodulation configuration
-    DEMOD_TYPE = 48  # 0 = linear (default), 1 = FM, 2 = WFM/Stereo, 3 = spectrum
-    OUTPUT_CHANNELS = 49  # 1 or 2 in Linear, otherwise 1
-    INDEPENDENT_SIDEBAND = 50  # Linear only
-    PLL_ENABLE = 51
-    PLL_LOCK = 52
-    PLL_SQUARE = 53
-    PLL_PHASE = 54
-    PLL_BW = 55
-    ENVELOPE = 56
-    SNR_SQUELCH = 57
-    
-    # Demodulation status
-    PLL_SNR = 58  # FM, PLL linear
-    FREQ_OFFSET = 59
-    PEAK_DEVIATION = 60
-    PL_TONE = 61
-    
-    # Settable gain parameters
-    AGC_ENABLE = 62  # Boolean, linear modes only
-    HEADROOM = 63
-    AGC_HANGTIME = 64
-    AGC_RECOVERY_RATE = 65
-    FM_SNR = 66
-    AGC_THRESHOLD = 67
-    
-    GAIN = 68  # AM, Linear only
-    OUTPUT_LEVEL = 69
-    OUTPUT_SAMPLES = 70
-    
-    OPUS_BIT_RATE = 71
-    MINPACKET = 72
-    FILTER2_BLOCKSIZE = 73
-    FILTER2_FIR_LENGTH = 74
-    FILTER2_KAISER_BETA = 75
-    SPECTRUM_FFT_N = 76
-    
-    FILTER_DROPS = 77
-    LOCK = 78
-    
-    TP1 = 79  # Test points
-    TP2 = 80
-    
-    GAINSTEP = 81
-    AD_BITS_PER_SAMPLE = 82
-    SQUELCH_OPEN = 83
-    SQUELCH_CLOSE = 84
-    PRESET = 85  # Mode/preset name (e.g., "iq", "usb", "lsb")
-    DEEMPH_TC = 86
-    DEEMPH_GAIN = 87
-    CONVERTER_OFFSET = 88
-    PL_DEVIATION = 89
-    THRESH_EXTEND = 90
-    
-    # Spectral analysis
-    SPECTRUM_SHAPE = 91
-    COHERENT_BIN_SPACING = 92
-    RESOLUTION_BW = 93
-    BIN_COUNT = 94
-    CROSSOVER = 95
-    BIN_DATA = 96
-    
-    RF_ATTEN = 97
-    RF_GAIN = 98
-    RF_AGC = 99
-    FE_LOW_EDGE = 100
-    FE_HIGH_EDGE = 101
-    FE_ISREAL = 102
-    BLOCKS_SINCE_POLL = 103
-    AD_OVER = 104
-    RTP_PT = 105
-    STATUS_INTERVAL = 106
-    OUTPUT_ENCODING = 107
-    SAMPLES_SINCE_OVER = 108
-    PLL_WRAPS = 109
-    RF_LEVEL_CAL = 110
-    OPUS_DTX = 111
-    OPUS_APPLICATION = 112
-    OPUS_BANDWIDTH = 113
-    OPUS_FEC = 114
-    SPECTRUM_STEP = 115
-
-
-# Command packet type
-CMD = 1
-
-# Encoding types - must match enum encoding in ka9q-radio/src/rtp.h
-class Encoding:
-    """Output encoding types - values must match ka9q-radio/src/rtp.h enum encoding"""
-    NO_ENCODING = 0
-    S16LE = 1  # Signed 16-bit little-endian
-    S16BE = 2  # Signed 16-bit big-endian
-    OPUS = 3   # Opus codec
-    F32LE = 4  # 32-bit float little-endian
-    AX25 = 5   # AX.25 packet
-    F16LE = 6  # 16-bit float little-endian
-    OPUS_VOIP = 7  # Opus with APPLICATION_VOIP
-    F32BE = 8  # 32-bit float big-endian
-    F16BE = 9  # 16-bit float big-endian
-    UNUSED_ENCODING = 10  # Sentinel, not used
-    
-    # Backward compatibility aliases
-    F32 = F32LE
-    F16 = F16LE