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

{ka9q_python-3.2.6/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.6
+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
@@ -192,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.6 → ka9q_python-3.2.7}/README.md

@@ -157,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.6 → 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.6'
+__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.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.6 → 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.6
+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
@@ -192,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.6 → 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
@@ -46,6 +47,7 @@ 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

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

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

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()