ka9q-python 3.2.5__tar.gz → 3.2.7__tar.gz

{ka9q_python-3.2.5/ka9q_python.egg-info → ka9q_python-3.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ka9q-python
-Version: 3.2.5
+Version: 3.2.7
 Summary: Python interface for ka9q-radio control and monitoring
 Home-page: https://github.com/mijahauan/ka9q-python
 Author: Michael Hauan AC0G
@@ -99,6 +99,22 @@ control.create_channel(
 )
 
 # RTP stream now available with SSRC 10000000
+
+### Request Specific Output Encoding
+
+```python
+from ka9q import RadiodControl, Encoding
+
+control = RadiodControl("radiod.local")
+
+# Create a channel with 32-bit float output (highest quality)
+control.ensure_channel(
+    frequency_hz=14.074e6,
+    preset="usb",
+    sample_rate=12000,
+    encoding=Encoding.F32
+)
+```
 ```
 
 ### Monitor WSPR Bands
@@ -176,6 +192,25 @@ control = RadiodControl("radiod.local", interface=my_interface)
 channels = discover_channels("radiod.local", interface=my_interface)
 ```
 
+### Automatic Channel Recovery
+
+ensure your channels survive radiod restarts:
+
+```python
+from ka9q import RadiodControl, ChannelMonitor
+
+control = RadiodControl("radiod.local")
+monitor = ChannelMonitor(control)
+monitor.start()
+
+# This channel will be automatically re-created if it disappears
+monitor.monitor_channel(
+    frequency_hz=14.074e6,
+    preset="usb",
+    sample_rate=12000
+)
+```
+
 ## Documentation
 
 For detailed information, please refer to the documentation in the `docs/` directory:

{ka9q_python-3.2.5 → ka9q_python-3.2.7}/README.md

@@ -64,6 +64,22 @@ control.create_channel(
 )
 
 # RTP stream now available with SSRC 10000000
+
+### Request Specific Output Encoding
+
+```python
+from ka9q import RadiodControl, Encoding
+
+control = RadiodControl("radiod.local")
+
+# Create a channel with 32-bit float output (highest quality)
+control.ensure_channel(
+    frequency_hz=14.074e6,
+    preset="usb",
+    sample_rate=12000,
+    encoding=Encoding.F32
+)
+```
 ```
 
 ### Monitor WSPR Bands
@@ -141,6 +157,25 @@ control = RadiodControl("radiod.local", interface=my_interface)
 channels = discover_channels("radiod.local", interface=my_interface)
 ```
 
+### Automatic Channel Recovery
+
+ensure your channels survive radiod restarts:
+
+```python
+from ka9q import RadiodControl, ChannelMonitor
+
+control = RadiodControl("radiod.local")
+monitor = ChannelMonitor(control)
+monitor.start()
+
+# This channel will be automatically re-created if it disappears
+monitor.monitor_channel(
+    frequency_hz=14.074e6,
+    preset="usb",
+    sample_rate=12000
+)
+```
+
 ## Documentation
 
 For detailed information, please refer to the documentation in the `docs/` directory:

{ka9q_python-3.2.5 → ka9q_python-3.2.7}/ka9q/__init__.py

@@ -38,7 +38,7 @@ Lower-level usage (explicit control):
         # Or use allocate_ssrc() directly for coordination
         ssrc = allocate_ssrc(10.0e6, "iq", 16000)
 """
-__version__ = '3.2.5'
+__version__ = '3.2.7'
 __author__ = 'Michael Hauan AC0G'
 
 from .control import RadiodControl, allocate_ssrc
@@ -112,6 +112,8 @@ __all__ = [
     'RTPPacket',
     'ResequencerStats',
     'generate_multicast_ip',
+    'ChannelMonitor',
 ]
 
 from .addressing import generate_multicast_ip
+from .monitor import ChannelMonitor

{ka9q_python-3.2.5 → ka9q_python-3.2.7}/ka9q/control.py

@@ -73,7 +73,8 @@ def allocate_ssrc(
     sample_rate: int = 16000,
     agc: bool = False,
     gain: float = 0.0,
-    destination: Optional[str] = None
+    destination: Optional[str] = None,
+    encoding: int = 0
 ) -> int:
     """
     Allocate a deterministic SSRC from channel parameters.
@@ -110,7 +111,8 @@ def allocate_ssrc(
         sample_rate,              # Sample rate as-is
         agc,                      # AGC boolean
         round(gain, 1),           # Gain rounded to 0.1 dB
-        destination               # Destination address (None or string)
+        destination,              # Destination address (None or string)
+        encoding                  # Encoding type (int)
     )
     # Keep positive, 31 bits (matches signal-recorder)
     return hash(key) & 0x7FFFFFFF
@@ -1072,6 +1074,7 @@ class RadiodControl:
                        preset: str = "iq", sample_rate: Optional[int] = None,
                        agc_enable: int = 0, gain: float = 0.0,
                        destination: Optional[str] = None,
+                       encoding: int = 0,
                        ssrc: Optional[int] = None) -> int:
         """
         Create a new channel with specified configuration
@@ -1098,6 +1101,7 @@ class RadiodControl:
             destination: RTP destination multicast address (optional). Format: "address" or "address:port"
                         Examples: "239.1.2.3", "wspr.local", "239.1.2.3:5004"
                         If not specified, uses radiod's default from config file.
+            encoding: Output encoding (0=none, 4=F32, etc.) - see Encoding class
             ssrc: SSRC (channel identifier). If None, auto-allocated from parameters.
                   Auto-allocation uses allocate_ssrc() for deterministic, shareable SSRCs.
         
@@ -1133,7 +1137,9 @@ class RadiodControl:
                 preset=preset,
                 sample_rate=sample_rate or 16000,  # Default for allocation
                 agc=bool(agc_enable),
-                gain=gain
+                gain=gain,
+                destination=destination,
+                encoding=encoding
             )
             logger.info(f"Auto-allocated SSRC: {ssrc}")
         
@@ -1145,7 +1151,7 @@ class RadiodControl:
         _validate_gain(gain)
         
         logger.info(f"Creating channel: SSRC={ssrc}, freq={frequency_hz/1e6:.3f} MHz, "
-                   f"demod={preset}, rate={sample_rate}Hz, agc={agc_enable}, gain={gain}dB")
+                   f"demod={preset}, rate={sample_rate}Hz, agc={agc_enable}, gain={gain}dB, enc={encoding}")
         
         # Build a single command packet with ALL parameters
         # This ensures radiod creates the channel with the correct settings
@@ -1180,6 +1186,12 @@ class RadiodControl:
         encode_double(cmdbuffer, StatusType.GAIN, gain)
         logger.info(f"Setting GAIN for SSRC {ssrc} to {gain} dB")
         
+        # Encoding setting - NOT sending in main buffer anymore
+        # Radiod requires OUTPUT_ENCODING to be sent in a separate command after creation
+        # if encoding > 0:
+        #    encode_int(cmdbuffer, StatusType.OUTPUT_ENCODING, encoding)
+        #    logger.info(f"Setting OUTPUT_ENCODING for SSRC {ssrc} to {encoding}")
+        
         # Destination address (if specified)
         if destination is not None:
             _validate_multicast_address(destination)
@@ -1203,9 +1215,25 @@ class RadiodControl:
         encode_int(cmdbuffer, StatusType.COMMAND_TAG, secrets.randbits(31))
         encode_eol(cmdbuffer)
         
-        # Send the single packet
+        # Send the main creation packet
         self.send_command(cmdbuffer)
         
+        # Send separate encoding command if requested (radiod requirement)
+        if encoding > 0:
+            encbuffer = bytearray()
+            encbuffer.append(CMD)
+            
+            # Target the SSRC we just created
+            encode_int(encbuffer, StatusType.OUTPUT_SSRC, ssrc)
+            encode_int(encbuffer, StatusType.COMMAND_TAG, secrets.randbits(31))
+            
+            # Set the encoding
+            encode_int(encbuffer, StatusType.OUTPUT_ENCODING, encoding)
+            encode_eol(encbuffer)
+            
+            self.send_command(encbuffer)
+            logger.info(f"Sent separate OUTPUT_ENCODING command for SSRC {ssrc}: {encoding}")
+        
         logger.info(f"Channel {ssrc} created and configured")
         return ssrc
     
@@ -1248,6 +1276,7 @@ class RadiodControl:
         agc_enable: int = 0,
         gain: float = 0.0,
         destination: Optional[str] = None,
+        encoding: int = 0,
         timeout: float = 5.0,
         frequency_tolerance: float = 1.0,
     ):
@@ -1274,6 +1303,7 @@ class RadiodControl:
             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).
+            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)
         
@@ -1322,9 +1352,10 @@ class RadiodControl:
             sample_rate=sample_rate,
             agc=bool(agc_enable),
             gain=gain,
-            destination=destination
+            destination=destination,
+            encoding=encoding
         )
-        logger.info(f"ensure_channel: computed SSRC {ssrc} for {frequency_hz/1e6:.3f} MHz {preset} dest={destination}")
+        logger.info(f"ensure_channel: computed SSRC {ssrc} for {frequency_hz/1e6:.3f} MHz {preset} dest={destination} enc={encoding}")
         
         # Check if channel already exists with matching parameters
         existing_channels = discover_channels(self.status_address, listen_duration=1.0)
@@ -1343,6 +1374,15 @@ class RadiodControl:
                         if destination not in (existing.multicast_address or ""):
                             dest_ok = False
                     
+                    # Check encoding if requested
+                    if dest_ok and encoding != 0:
+                        if existing.encoding != encoding:
+                            dest_ok = False
+                            logger.info(
+                                f"ensure_channel: existing channel encoding mismatch "
+                                f"({existing.encoding} vs {encoding}), will reconfigure"
+                            )
+
                     if dest_ok:
                         logger.info(
                             f"ensure_channel: reusing existing channel SSRC {ssrc} "
@@ -1351,8 +1391,7 @@ class RadiodControl:
                         return existing
                     else:
                         logger.info(
-                            f"ensure_channel: existing channel destination mismatch "
-                            f"({existing.multicast_address} vs {destination}), will reconfigure"
+                            f"ensure_channel: existing channel configuration mismatch, will reconfigure"
                         )
                 else:
                     logger.info(
@@ -1374,6 +1413,7 @@ class RadiodControl:
             agc_enable=agc_enable,
             gain=gain,
             destination=destination,
+            encoding=encoding,
             ssrc=ssrc
         )
         

{ka9q_python-3.2.5 → ka9q_python-3.2.7}/ka9q/discovery.py

@@ -32,6 +32,7 @@ class ChannelInfo:
     port: int
     gps_time: Optional[int] = None  # GPS nanoseconds when RTP_TIMESNAP was captured
     rtp_timesnap: Optional[int] = None  # RTP timestamp at GPS_TIME
+    encoding: int = 0  # stream encoding (0=none, 4=F32, etc)
 
 
 def _create_status_listener_socket(multicast_addr: str, interface: Optional[str] = None) -> socket.socket:
@@ -206,7 +207,8 @@ def discover_channels_native(status_address: str, listen_duration: float = 2.0,
                 multicast_address=mcast_addr,
                 port=port,
                 gps_time=status.get('gps_time'),
-                rtp_timesnap=status.get('rtp_timesnap')
+                rtp_timesnap=status.get('rtp_timesnap'),
+                encoding=status.get('encoding', 0)
             )
             
             # Store or update channel info
@@ -316,7 +318,8 @@ def discover_channels_via_control(status_address: str, timeout: float = 30.0) ->
                     frequency=frequency,
                     snr=snr,
                     multicast_address=addr,
-                    port=port
+                    port=port,
+                    encoding=0  # Control utility text output may not include encoding explicitly
                 )
                 
                 channels[ssrc] = channel

ka9q_python-3.2.7/ka9q/monitor.py

@@ -0,0 +1,150 @@
+"""
+ChannelMonitor service for automatic channel recovery.
+
+This module provides a watchdog service that monitors active channels
+and automatically re-creates them if they disappear (e.g., due to a
+radiod restart).
+"""
+
+import threading
+import time
+import logging
+from typing import Dict, Any, Optional
+
+from .control import RadiodControl
+from .discovery import discover_channels, ChannelInfo
+
+logger = logging.getLogger(__name__)
+
+
+class ChannelMonitor:
+    """
+    Background service to monitor and recover channels.
+    
+    The ChannelMonitor maintains a list of "desired" channels and their
+    configuration. It periodically queries `radiod` to see what channels
+    actually exist. If a desired channel is missing, it automatically
+    calls `ensure_channel` to restore it.
+    
+    Usage:
+        control = RadiodControl("radiod.local")
+        monitor = ChannelMonitor(control)
+        monitor.start()
+        
+        # Register a channel to keep alive
+        monitor.monitor_channel(
+            frequency_hz=14.074e6,
+            preset="usb",
+            sample_rate=12000
+        )
+    """
+    
+    def __init__(self, control: RadiodControl, check_interval: float = 2.0):
+        """
+        Initialize the monitor.
+        
+        Args:
+            control: RadiodControl instance to use for discovery and creation
+            check_interval: How often to check channel status (seconds)
+        """
+        self.control = control
+        self.check_interval = check_interval
+        self._monitored_channels: Dict[int, Dict[str, Any]] = {}
+        self._running = False
+        self._thread: Optional[threading.Thread] = None
+        self._lock = threading.Lock()
+        
+    def start(self):
+        """Start the monitoring thread."""
+        if self._running:
+            return
+            
+        self._running = True
+        self._thread = threading.Thread(target=self._monitor_loop, daemon=True)
+        self._thread.start()
+        logger.info(f"ChannelMonitor started (interval={self.check_interval}s)")
+        
+    def stop(self):
+        """Stop the monitoring thread."""
+        self._running = False
+        if self._thread:
+            self._thread.join(timeout=self.check_interval * 2)
+            self._thread = None
+        logger.info("ChannelMonitor stopped")
+        
+    def monitor_channel(self, **kwargs) -> int:
+        """
+        Register a channel to be monitored/kept alive.
+        
+        Calls `ensure_channel` immediately to create/verify the channel,
+        then adds it to the monitoring list.
+        
+        Args:
+            **kwargs: Arguments to pass to `ensure_channel`
+                     (frequency_hz, preset, sample_rate, encoding, etc.)
+                     
+        Returns:
+            SSRC of the channel
+        """
+        # First ensure the channel exists
+        channel_info = self.control.ensure_channel(**kwargs)
+        ssrc = channel_info.ssrc
+        
+        with self._lock:
+            # Store parameters for future recovery
+            # We filter out 'timeout' as it's a runtime param, not a channel property
+            recovery_params = kwargs.copy()
+            if 'timeout' in recovery_params:
+                del recovery_params['timeout']
+                
+            self._monitored_channels[ssrc] = recovery_params
+            logger.info(f"Now monitoring channel {ssrc} for recovery")
+            
+        return ssrc
+        
+    def unmonitor_channel(self, ssrc: int):
+        """Stop monitoring a specific channel."""
+        with self._lock:
+            if ssrc in self._monitored_channels:
+                del self._monitored_channels[ssrc]
+                logger.info(f"Stopped monitoring channel {ssrc}")
+                
+    def _monitor_loop(self):
+        """Main monitoring loop."""
+        while self._running:
+            try:
+                self._check_and_recover()
+            except Exception as e:
+                logger.error(f"Error in monitor loop: {e}")
+                
+            time.sleep(self.check_interval)
+            
+    def _check_and_recover(self):
+        """Perform one check cycle: discover and recover missing channels."""
+        # Get list of desired channels safely
+        with self._lock:
+            if not self._monitored_channels:
+                return
+            desired = self._monitored_channels.copy()
+            
+        # Discover actual running channels
+        try:
+            # Use quick discovery
+            actual_channels = discover_channels(
+                self.control.status_address, 
+                listen_duration=0.5
+            )
+        except Exception as e:
+            logger.warning(f"Discovery failed during check (radiod down?): {e}")
+            return
+            
+        # Check for missing channels
+        for ssrc, params in desired.items():
+            if ssrc not in actual_channels:
+                logger.warning(f"Channel {ssrc} is missing! Attempting recovery...")
+                try:
+                    # Attempt to restore
+                    self.control.ensure_channel(**params)
+                    logger.info(f"Successfully recovered channel {ssrc}")
+                except Exception as e:
+                    logger.error(f"Failed to recover channel {ssrc}: {e}")

{ka9q_python-3.2.5 → ka9q_python-3.2.7/ka9q_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ka9q-python
-Version: 3.2.5
+Version: 3.2.7
 Summary: Python interface for ka9q-radio control and monitoring
 Home-page: https://github.com/mijahauan/ka9q-python
 Author: Michael Hauan AC0G
@@ -99,6 +99,22 @@ control.create_channel(
 )
 
 # RTP stream now available with SSRC 10000000
+
+### Request Specific Output Encoding
+
+```python
+from ka9q import RadiodControl, Encoding
+
+control = RadiodControl("radiod.local")
+
+# Create a channel with 32-bit float output (highest quality)
+control.ensure_channel(
+    frequency_hz=14.074e6,
+    preset="usb",
+    sample_rate=12000,
+    encoding=Encoding.F32
+)
+```
 ```
 
 ### Monitor WSPR Bands
@@ -176,6 +192,25 @@ control = RadiodControl("radiod.local", interface=my_interface)
 channels = discover_channels("radiod.local", interface=my_interface)
 ```
 
+### Automatic Channel Recovery
+
+ensure your channels survive radiod restarts:
+
+```python
+from ka9q import RadiodControl, ChannelMonitor
+
+control = RadiodControl("radiod.local")
+monitor = ChannelMonitor(control)
+monitor.start()
+
+# This channel will be automatically re-created if it disappears
+monitor.monitor_channel(
+    frequency_hz=14.074e6,
+    preset="usb",
+    sample_rate=12000
+)
+```
+
 ## Documentation
 
 For detailed information, please refer to the documentation in the `docs/` directory:

{ka9q_python-3.2.5 → ka9q_python-3.2.7}/ka9q_python.egg-info/SOURCES.txt

@@ -23,6 +23,7 @@ ka9q/addressing.py
 ka9q/control.py
 ka9q/discovery.py
 ka9q/exceptions.py
+ka9q/monitor.py
 ka9q/resequencer.py
 ka9q/rtp_recorder.py
 ka9q/stream.py
@@ -38,12 +39,15 @@ tests/__init__.py
 tests/conftest.py
 tests/test_addressing.py
 tests/test_channel_verification.py
+tests/test_create_split_encoding.py
 tests/test_decode_functions.py
 tests/test_encode_functions.py
 tests/test_encode_socket.py
+tests/test_ensure_channel_encoding.py
 tests/test_integration.py
 tests/test_iq_20khz_f32.py
 tests/test_listen_multicast.py
+tests/test_monitor.py
 tests/test_multihomed.py
 tests/test_native_discovery.py
 tests/test_performance_fixes.py
@@ -51,6 +55,7 @@ tests/test_remove_channel.py
 tests/test_rtp_recorder.py
 tests/test_security_features.py
 tests/test_ssrc_dest_unit.py
+tests/test_ssrc_encoding_unit.py
 tests/test_tune.py
 tests/test_tune_cli.py
 tests/test_tune_debug.py

{ka9q_python-3.2.5 → ka9q_python-3.2.7}/pyproject.toml

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

{ka9q_python-3.2.5 → ka9q_python-3.2.7}/tests/test_channel_verification.py

@@ -662,12 +662,11 @@ def verify_channel(
     )
     
     try:
-        # 1. Create and configure channel using tune()
-        # tune() supports encoding parameter and returns status
+        # 1. Create and configure channel using ensure_channel()
+        # This tests the high-level API which handles encoding commands
         logger.info(f"Creating channel: {test_case.name} (SSRC {ssrc})")
         
-        tune_kwargs = {
-            'ssrc': ssrc,
+        ensure_kwargs = {
             'frequency_hz': test_case.frequency_hz,
             'preset': test_case.preset,
             'sample_rate': test_case.sample_rate,
@@ -676,28 +675,37 @@ def verify_channel(
         
         # Add gain/AGC settings
         if test_case.agc_enable:
-            tune_kwargs['agc_enable'] = True
+            ensure_kwargs['agc_enable'] = 1
         else:
-            tune_kwargs['gain'] = test_case.gain
+            ensure_kwargs['gain'] = test_case.gain
         
         # Add encoding if specified
         if test_case.encoding is not None:
-            tune_kwargs['encoding'] = test_case.encoding
+            ensure_kwargs['encoding'] = test_case.encoding
         
         # Add destination if specified
         if test_case.destination is not None:
-            tune_kwargs['destination'] = test_case.destination
-        
+            ensure_kwargs['destination'] = test_case.destination
+            
         try:
-            status = control.tune(**tune_kwargs)
+            # ensure_channel returns the discovered ChannelInfo
+            channel_info = control.ensure_channel(**ensure_kwargs)
             result.channel_created = True
-            logger.info(f"tune() returned status: {status}")
+            
+            # Since ensure_channel doesn't return the raw status dict from tune,
+            # we'll synthesize a status dict for subsequent checks or rely on discovery
+            status = {
+                'ssrc': channel_info.ssrc,
+                'frequency': channel_info.frequency,
+                'encoding': getattr(channel_info, 'encoding', 0),
+                # Add other fields if needed for compatibility
+            }
+            logger.info(f"ensure_channel returned: {channel_info}")
         except TimeoutError:
             # Channel may have been created but status not received
-            # Try to verify via discovery
-            result.channel_created = True
+            result.channel_created = False # ensure_channel should have raised if verification failed
             status = {}
-            logger.warning("tune() timed out waiting for status, continuing with discovery")
+            logger.warning("ensure_channel timed out")
         
         # Wait for channel to stabilize
         time.sleep(0.5)

ka9q_python-3.2.7/tests/test_create_split_encoding.py

@@ -0,0 +1,33 @@
+import unittest
+from unittest.mock import MagicMock
+from ka9q.control import RadiodControl
+from ka9q.types import Encoding
+
+class TestCreateChannelSplit(unittest.TestCase):
+    @unittest.mock.patch('ka9q.control.RadiodControl._connect')
+    def test_create_channel_splits_encoding(self, mock_connect):
+        """Verify that create_channel sends two packets when encoding is specified"""
+        control = RadiodControl("radiod.local")
+        control.send_command = MagicMock()
+        
+        # 1. Create channel WITH encoding
+        control.create_channel(
+            frequency_hz=14074000.0,
+            encoding=Encoding.F32
+        )
+        
+        # Should call send_command twice
+        self.assertEqual(control.send_command.call_count, 2, "Should call send_command twice")
+        
+        # 2. Create channel WITHOUT encoding
+        control.send_command.reset_mock()
+        control.create_channel(
+            frequency_hz=14074000.0,
+            encoding=Encoding.NO_ENCODING # or 0
+        )
+        
+        # Should call send_command once
+        self.assertEqual(control.send_command.call_count, 1, "Should call send_command once")
+
+if __name__ == '__main__':
+    unittest.main()

ka9q_python-3.2.7/tests/test_ensure_channel_encoding.py

@@ -0,0 +1,75 @@
+import unittest
+from unittest.mock import MagicMock, patch
+from ka9q.control import RadiodControl
+from ka9q.discovery import ChannelInfo
+from ka9q.types import Encoding
+
+class TestEnsureChannelEncoding(unittest.TestCase):
+    @patch('ka9q.control.RadiodControl._connect')
+    def setUp(self, mock_connect):
+        self.control = RadiodControl("radiod.local")
+        self.control.create_channel = MagicMock()
+        self.control.verify_channel = MagicMock(return_value=True)
+
+    @patch('ka9q.discovery.discover_channels')
+    def test_ensure_channel_encoding_match(self, mock_discover):
+        """Verify that matching encoding reuses channel"""
+        # Mock existing channel with F32 encoding
+        ssrc = 12345
+        existing = ChannelInfo(
+            ssrc=ssrc,
+            preset="iq",
+            sample_rate=16000,
+            frequency=14074000.0,
+            snr=0.0,
+            multicast_address="239.1.1.1",
+            port=5004,
+            encoding=Encoding.F32
+        )
+        mock_discover.return_value = {ssrc: existing}
+        
+        # Patch allocate_ssrc to return our mock SSRC
+        with patch('ka9q.control.allocate_ssrc', return_value=ssrc):
+            # Call ensure_channel asking for F32
+            result = self.control.ensure_channel(
+                frequency_hz=14.074e6,
+                encoding=Encoding.F32
+            )
+            
+            # Should return existing channel
+            self.assertEqual(result, existing)
+            # Should NOT call create_channel
+            self.control.create_channel.assert_not_called()
+
+    @patch('ka9q.discovery.discover_channels')
+    def test_ensure_channel_encoding_mismatch(self, mock_discover):
+        """Verify that mismatching encoding triggers recreation"""
+        # Mock existing channel with S16 encoding
+        ssrc = 12345
+        existing = ChannelInfo(
+            ssrc=ssrc,
+            preset="iq",
+            sample_rate=16000,
+            frequency=14074000.0,
+            snr=0.0,
+            multicast_address="239.1.1.1",
+            port=5004,
+            encoding=Encoding.S16LE # Different encoding
+        )
+        mock_discover.return_value = {ssrc: existing}
+        
+        # Patch allocate_ssrc to return our mock SSRC
+        with patch('ka9q.control.allocate_ssrc', return_value=ssrc):
+            # Call ensure_channel asking for F32
+            result = self.control.ensure_channel(
+                frequency_hz=14.074e6,
+                encoding=Encoding.F32
+            )
+            
+            # Should call create_channel with correct encoding
+            self.control.create_channel.assert_called_once()
+            _, kwargs = self.control.create_channel.call_args
+            self.assertEqual(kwargs['encoding'], Encoding.F32)
+
+if __name__ == '__main__':
+    unittest.main()

ka9q_python-3.2.7/tests/test_monitor.py

@@ -0,0 +1,76 @@
+import unittest
+from unittest.mock import MagicMock, patch
+import time
+from ka9q.monitor import ChannelMonitor
+from ka9q.discovery import ChannelInfo
+
+class TestChannelMonitor(unittest.TestCase):
+    def setUp(self):
+        self.control = MagicMock()
+        # Mock ensure_channel to return a ChannelInfo object
+        self.control.ensure_channel.return_value = ChannelInfo(
+            ssrc=12345,
+            preset="usb",
+            sample_rate=12000,
+            frequency=14.074e6,
+            snr=30.0,
+            multicast_address="239.1.1.1",
+            port=5004
+        )
+        self.monitor = ChannelMonitor(self.control, check_interval=0.1)
+
+    def tearDown(self):
+        self.monitor.stop()
+
+    def test_monitor_registration(self):
+        """Verify channels are registered for monitoring"""
+        ssrc = self.monitor.monitor_channel(frequency_hz=14.074e6, preset="usb")
+        
+        self.assertEqual(ssrc, 12345)
+        self.assertIn(12345, self.monitor._monitored_channels)
+        self.assertEqual(
+            self.monitor._monitored_channels[12345],
+            {'frequency_hz': 14.074e6, 'preset': 'usb'}
+        )
+        
+        # Verify ensure_channel was called
+        self.control.ensure_channel.assert_called_with(frequency_hz=14.074e6, preset="usb")
+
+    def test_unmonitor(self):
+        """Verify unmonitoring works"""
+        ssrc = self.monitor.monitor_channel(frequency_hz=14.074e6)
+        self.monitor.unmonitor_channel(ssrc)
+        self.assertNotIn(ssrc, self.monitor._monitored_channels)
+
+    @patch('ka9q.monitor.discover_channels')
+    def test_recovery(self, mock_discover):
+        """Verify recovery triggers when channel is missing"""
+        # Register channel
+        self.monitor.monitor_channel(frequency_hz=14.074e6, preset="usb")
+        self.control.ensure_channel.reset_mock()
+        
+        # Scenario 1: Channel exists
+        mock_discover.return_value = {
+            12345: ChannelInfo(
+                ssrc=12345, frequency=14.074e6, preset="usb", sample_rate=12000, 
+                snr=0, multicast_address="239.1.1.1", port=5004
+            )
+        }
+        
+        # Run one loop cycle
+        self.monitor._check_and_recover()
+        
+        # Should NOT call ensure_channel
+        self.control.ensure_channel.assert_not_called()
+        
+        # Scenario 2: Channel missing (radiod restarted)
+        mock_discover.return_value = {}  # Empty discovery
+        
+        # Run one loop cycle
+        self.monitor._check_and_recover()
+        
+        # Should call ensure_channel to restore it
+        self.control.ensure_channel.assert_called_with(frequency_hz=14.074e6, preset="usb")
+
+if __name__ == '__main__':
+    unittest.main()

ka9q_python-3.2.7/tests/test_ssrc_encoding_unit.py

@@ -0,0 +1,35 @@
+import unittest
+from ka9q.control import allocate_ssrc
+from ka9q.types import Encoding
+
+class TestEncodingSSRC(unittest.TestCase):
+    def test_ssrc_uniqueness_with_encoding(self):
+        """Verify that providing encoding changes the SSRC"""
+        params = {
+            'frequency_hz': 14074000.0,
+            'preset': 'iq',
+            'sample_rate': 16000,
+            'agc': False,
+            'gain': 0.0,
+            'destination': None
+        }
+        
+        # 1. Base SSRC (no encoding or 0)
+        ssrc_base = allocate_ssrc(**params)
+        
+        # 2. SSRC with F32
+        ssrc_f32 = allocate_ssrc(**params, encoding=Encoding.F32)
+        
+        # 3. SSRC with S16LE
+        ssrc_s16 = allocate_ssrc(**params, encoding=Encoding.S16LE)
+        
+        # Verify all are different
+        self.assertNotEqual(ssrc_base, ssrc_f32, "SSRC with encoding should differ from base")
+        self.assertNotEqual(ssrc_f32, ssrc_s16, "SSRCs for different encodings should differ")
+        
+        # Verify determinism
+        ssrc_f32_2 = allocate_ssrc(**params, encoding=Encoding.F32)
+        self.assertEqual(ssrc_f32, ssrc_f32_2, "SSRC should be deterministic for same encoding")
+
+if __name__ == '__main__':
+    unittest.main()