python-rako-2025 0.4.1__tar.gz → 0.4.4__tar.gz

{python_rako_2025-0.4.1 → python_rako_2025-0.4.4}/.claude/settings.local.json

@@ -6,7 +6,8 @@
       "mcp__ide__getDiagnostics",
       "WebFetch(domain:docs.python.org)",
       "Bash(python -m pytest tests/ -v)",
-      "Bash(pytest:*)"
+      "Bash(pytest:*)",
+      "Bash(git fetch:*)"
     ],
     "deny": []
   }

{python_rako_2025-0.4.1 → python_rako_2025-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-rako-2025
-Version: 0.4.1
+Version: 0.4.4
 Summary: Asynchronous Python client for Rako Controls Lighting
 Project-URL: Homepage, https://github.com/simonleigh/python-rako
 Project-URL: Repository, https://github.com/simonleigh/python-rako

python_rako_2025-0.4.4/python_rako/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.4.4"

{python_rako_2025-0.4.1 → python_rako_2025-0.4.4}/python_rako/bridge.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 import logging
 import threading
+import time
 from typing import TYPE_CHECKING, Any, cast
 
 import aiohttp
@@ -15,7 +16,7 @@ from python_rako.const import (
     MessageType,
     RequestType,
 )
-from python_rako.exceptions import RakoBridgeError
+from python_rako.exceptions import RakoBridgeError, RakoConnectionError, RakoCommandError
 from python_rako.helpers import (
     command_to_byte_list,
     deserialise_byte_list,
@@ -87,15 +88,36 @@ class BridgeCommanderUDP(_BridgeCommander):
         await self._send_command(command)
 
     async def _send_command(self, command: CommandUDP) -> None:
+        """Send command with retry logic."""
+        await self._send_command_with_retry(command, max_retries=2)
+
+    async def _send_command_with_retry(self, command: CommandUDP, max_retries: int = 2) -> bool:
+        """Send command with retry logic."""
         _LOGGER.debug("Sending command: %s", command)
         byte_list = command_to_byte_list(command)
-        async with get_dg_commander(self.host, self.port) as dg_client:
-            _LOGGER.debug("Sending command bytes: %s", byte_list)
-            await dg_client.send(bytes(byte_list))
-            data, _ = await dg_client.recv()
-
-        if data.decode("utf8").strip() != COMMAND_SUCCESS_RESPONSE:
-            _LOGGER.warning("Bad response after command %s %s", command, data)
+        
+        for attempt in range(max_retries + 1):
+            try:
+                async with get_dg_commander(self.host, self.port) as dg_client:
+                    _LOGGER.debug("Sending command bytes: %s (attempt %d)", byte_list, attempt + 1)
+                    await dg_client.send(bytes(byte_list))
+                    try:
+                        # Add timeout to prevent indefinite blocking
+                        data, _ = await asyncio.wait_for(dg_client.recv(), timeout=3.0)
+                        if data.decode("utf8").strip() != COMMAND_SUCCESS_RESPONSE:
+                            _LOGGER.warning("Bad response after command %s: %s", command, data)
+                        return True
+                    except TimeoutError:
+                        # Many bridges don't send consistent responses, just log and continue
+                        _LOGGER.debug("No response received for command %s (timeout after 3s)", command)
+                        return True  # Consider timeout as success for UDP commands
+            except (ConnectionError, OSError) as e:
+                if attempt == max_retries:
+                    _LOGGER.error("Command failed after %d attempts: %s", max_retries + 1, e)
+                    raise RakoConnectionError(f"Failed to send command after {max_retries + 1} attempts: {e}") from e
+                _LOGGER.warning("Command attempt %d failed, retrying: %s", attempt + 1, e)
+                await asyncio.sleep(0.5 * (2 ** attempt))  # Exponential backoff
+        return False
 
 
 class BridgeCommanderHTTP(_BridgeCommander):
@@ -151,6 +173,7 @@ class Bridge:
         self.scene_cache: SceneCache = SceneCache()
         self._cached_xml: str | None = None
         self._xml_fetch_lock = asyncio.Lock()
+        self._last_cache_refresh: float = 0
 
     @property
     def _discovery_url(self) -> str:
@@ -335,6 +358,17 @@ class Bridge:
 
         return level_cache, scene_cache
 
+    async def refresh_cache_if_stale(self, max_age_seconds: int = 300) -> None:
+        """Refresh level and scene cache if older than max_age_seconds."""
+        current_time = time.time()
+        if current_time - self._last_cache_refresh > max_age_seconds:
+            try:
+                self.level_cache, self.scene_cache = await self.get_cache_state()
+                self._last_cache_refresh = current_time
+                _LOGGER.debug("📚 Cache refreshed for bridge %s", self.mac)
+            except Exception as e:
+                _LOGGER.warning("Failed to refresh cache for bridge %s: %s", self.mac, e)
+
     async def set_room_scene(self, room_id: int, scene: int) -> None:
         """Set the scene of a room."""
         await self._bridge_commander.set_room_scene(room_id, scene)

python_rako_2025-0.4.4/python_rako/exceptions.py

@@ -0,0 +1,12 @@
+class RakoBridgeError(Exception):
+    pass
+
+
+class RakoConnectionError(RakoBridgeError):
+    """Raised when bridge connection fails."""
+    pass
+
+
+class RakoCommandError(RakoBridgeError):
+    """Raised when command execution fails."""
+    pass

{python_rako_2025-0.4.1 → python_rako_2025-0.4.4}/python_rako/helpers.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
 
+import asyncio
 import logging
+import socket
+import time
 from contextlib import asynccontextmanager
 from typing import TYPE_CHECKING
 
@@ -38,7 +41,13 @@ _LOGGER = logging.getLogger(__name__)
 async def get_dg_listener(port: int, listen_host: str = "0.0.0.0") -> AsyncIterator[DatagramServer]:
     server: DatagramServer | None = None
     try:
-        server = await asyncio_dgram.bind((listen_host, port))
+        # Create socket with broadcast capability for receiving status messages
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        sock.bind((listen_host, port))
+        
+        server = await asyncio_dgram.from_socket(sock)
         yield server
     finally:
         if server:
@@ -194,3 +203,38 @@ def convert_to_scene(brightness: int) -> int:
 
     scene = next(k for k, v in _scene_windows.items() if v["low"] <= brightness < v["high"])
     return scene
+
+
+def get_predicted_channel_brightness(level_cache: LevelCache, room: int, channel: int, scene: int) -> int:
+    """Predict channel brightness from scene using cache, fallback to conversion."""
+    # Try cache first
+    cached_brightness = level_cache.get_channel_level(
+        RoomChannel(room, channel), scene
+    )
+    if cached_brightness > 0:
+        return cached_brightness
+    
+    # Fallback to scene-to-brightness conversion
+    return convert_to_brightness(scene)
+
+
+class UDPMessageRateLimit:
+    """Rate limiter for UDP message processing to prevent flooding."""
+    
+    def __init__(self, max_messages_per_second: int = 50):
+        self.max_messages = max_messages_per_second
+        self.message_times: list[float] = []
+        self.lock = asyncio.Lock()
+    
+    async def should_process_message(self) -> bool:
+        """Rate limit UDP message processing."""
+        async with self.lock:
+            now = time.time()
+            # Remove messages older than 1 second
+            self.message_times = [t for t in self.message_times if now - t < 1.0]
+            
+            if len(self.message_times) >= self.max_messages:
+                return False
+            
+            self.message_times.append(now)
+            return True

python_rako_2025-0.4.1/python_rako/__version__.py

@@ -1 +0,0 @@
-__version__ = "0.4.1"

python_rako_2025-0.4.1/python_rako/exceptions.py

@@ -1,2 +0,0 @@
-class RakoBridgeError(Exception):
-    pass