boneIO 1.3.0.dev17__py3-none-any.whl → 1.3.0.dev18__py3-none-any.whl

boneio/components/cover/cover.py

@@ -187,13 +187,17 @@ class BaseCover(BaseCoverABC, BasicMqtt):
 
         self._event_bus.add_sigterm_listener(self.on_exit)
 
-        self._loop.call_soon_threadsafe(
-            self._loop.call_later,
-            0.5,
-            self.send_state,
-            self.state,
-            self.json_position
-        )
+        try:
+            self._loop.call_soon_threadsafe(
+                self._loop.call_later,
+                0.5,
+                self.send_state,
+                self.state,
+                self.json_position
+            )
+        except RuntimeError:
+            # Event loop is closed (e.g. during tests)
+            pass
 
     async def on_exit(self) -> None:
         """Stop on exit."""
@@ -206,8 +210,12 @@ class BaseCover(BaseCoverABC, BasicMqtt):
             self._open_relay.turn_off()
             self._close_relay.turn_off()
             # Send relay states to WebSocket (not MQTT - that's handled by output_type check)
-            asyncio.create_task(self._open_relay.async_send_state())
-            asyncio.create_task(self._close_relay.async_send_state())
+            try:
+                asyncio.create_task(self._open_relay.async_send_state())
+                asyncio.create_task(self._close_relay.async_send_state())
+            except RuntimeError:
+                # Event loop is closed (e.g. during tests or shutdown)
+                pass
             if self._current_operation in (OPENING, CLOSING):
                 self._last_operation = self._current_operation
             self._current_operation = IDLE

boneio/components/cover/time_based.py

@@ -43,7 +43,7 @@ class TimeBasedCover(BaseCover):
 
     def _move_cover(self, direction: str, duration: float, target_position: int | None = None):
         """Run in sepearate thread.
-        
+
         Args:
             direction: Direction of movement (OPEN or CLOSE)
             duration: Full time for 0-100% movement in milliseconds
@@ -60,7 +60,10 @@ class TimeBasedCover(BaseCover):
 
         if total_steps == 0 or duration == 0:
             self._current_operation = IDLE
-            self._loop.call_soon_threadsafe(lambda: self.send_state(self.state, self.json_position))
+            try:
+                self._loop.call_soon_threadsafe(lambda: self.send_state(self.state, self.json_position))
+            except RuntimeError:
+                pass
             return
 
         # Calculate actual duration based on remaining distance
@@ -69,7 +72,10 @@ class TimeBasedCover(BaseCover):
 
         relay.turn_on()
         # Send relay state to WebSocket (not MQTT - that's handled by output_type check)
-        self._loop.call_soon_threadsafe(lambda r=relay: asyncio.ensure_future(r.async_send_state()))
+        try:
+            self._loop.call_soon_threadsafe(lambda r=relay: asyncio.ensure_future(r.async_send_state()))
+        except RuntimeError:
+            pass
         start_time = time.monotonic()
 
         while not self._stop_event.is_set():
@@ -84,7 +90,10 @@ class TimeBasedCover(BaseCover):
 
             self._last_timestamp = current_time # Użyj pobranego czasu
             if current_time - self._last_update_time >= 1:
-                self._loop.call_soon_threadsafe(lambda: self.send_state(self.state, self.json_position))
+                try:
+                    self._loop.call_soon_threadsafe(lambda: self.send_state(self.state, self.json_position))
+                except RuntimeError:
+                    break
                 self._last_update_time = current_time
 
             if target_position is not None:
@@ -98,9 +107,15 @@ class TimeBasedCover(BaseCover):
             time.sleep(0.05)  # Małe opóźnienie, aby nie blokować CPU
         relay.turn_off()
         # Send relay state to WebSocket (not MQTT - that's handled by output_type check)
-        self._loop.call_soon_threadsafe(lambda r=relay: asyncio.ensure_future(r.async_send_state()))
+        try:
+            self._loop.call_soon_threadsafe(lambda r=relay: asyncio.ensure_future(r.async_send_state()))
+        except RuntimeError:
+            pass
         self._current_operation = IDLE
-        self._loop.call_soon_threadsafe(lambda: self.send_state_and_save(self.json_position))
+        try:
+            self._loop.call_soon_threadsafe(lambda: self.send_state_and_save(self.json_position))
+        except RuntimeError:
+            pass
         self._last_update_time = time.monotonic() # Upewnij się, że aktualizacja jest wysłana na końcu ruchu
 
     async def run_cover(self, current_operation: str, target_position: int | None = None) -> None:

boneio/core/config/config_helper.py

@@ -386,8 +386,14 @@ class ConfigHelper:
     def reload_config(self) -> dict[str, Any]:
         """Reload configuration from file and update cache.
         
-        Waits for any background config cache rebuild to complete before
-        loading, so the fast cached path is used instead of full validation.
+        Loads config from file using load_config_from_file() which tries the
+        disk cache first (~0.5s) and falls back to full Cerberus validation
+        (~20s) on cache miss. This method does NOT wait for any background
+        cache rebuild — it's independent.
+        
+        NOTE: This method may take up to ~20s on BeagleBone if disk cache
+        is not available. Callers should run it via asyncio.to_thread() to
+        avoid blocking the event loop.
         
         Returns:
             dict: Reloaded configuration dictionary
@@ -395,13 +401,6 @@ class ConfigHelper:
         Raises:
             ValueError: If config_file_path is not set
         """
-        # Wait for background cache rebuild (started after config save)
-        try:
-            from boneio.webui.routes.config import wait_for_config_cache
-            wait_for_config_cache(timeout=30.0)
-        except ImportError:
-            pass  # Web module not available (e.g., during tests)
-        
         _LOGGER.info("Reloading config from file: %s", self._config_file_path)
         return self.get_config(force_reload=True)
 

boneio/core/discovery.py

@@ -18,10 +18,10 @@ _LOGGER = logging.getLogger(__name__)
 
 class BlackDiscoveryPublisher:
     """Publishes BoneIO Black device discovery information to MQTT.
-    
+
     This is NOT Home Assistant discovery - it's for autodiscovery
     of neighboring BoneIO Black devices.
-    
+
     Discovery is split into separate topics for efficiency:
     - discovery/device  - Device info (id, name, serial, firmware)
     - discovery/outputs - Available outputs
@@ -29,13 +29,13 @@ class BlackDiscoveryPublisher:
     - discovery/inputs  - Available inputs
     - discovery/sensors - Available sensors
     - discovery/modbus  - Available modbus devices
-    
+
     All topics are published with retain=True.
     """
-    
+
     def __init__(self, manager: Manager, message_bus: MessageBus) -> None:
         """Initialize discovery publisher.
-        
+
         Args:
             manager: Manager instance
             message_bus: Message bus for MQTT communication
@@ -43,10 +43,10 @@ class BlackDiscoveryPublisher:
         self._manager = manager
         self._message_bus = message_bus
         self._base_topic = f"{manager._config_helper.topic_prefix}/discovery"
-    
+
     def _publish(self, subtopic: str, payload: Any) -> None:
         """Publish payload to discovery subtopic with retain.
-        
+
         Args:
             subtopic: Subtopic name (e.g., "device", "outputs")
             payload: Payload to publish (will be JSON encoded)
@@ -55,11 +55,11 @@ class BlackDiscoveryPublisher:
         payload_json = json.dumps(payload)
         self._message_bus.send_message(topic=topic, payload=payload_json, retain=True)
         _LOGGER.debug("Published discovery/%s: %s", subtopic, payload_json)
-    
+
     def _build_device_info(self) -> dict[str, Any]:
         """Build device information payload."""
         from boneio.version import __version__
-        
+
         config_helper = self._manager._config_helper
         device_info = {
             "id": config_helper._serial_no or "unknown",
@@ -72,104 +72,116 @@ class BlackDiscoveryPublisher:
         if config_helper._network_info:
             device_info["ip"] = config_helper._network_info.get("ip", "")
         return device_info
-    
+
     def _build_outputs(self) -> list[dict[str, Any]]:
         """Build outputs list (excludes cover outputs - those are in discovery/covers)."""
         outputs = []
-        if hasattr(self._manager, 'outputs') and self._manager.outputs:
+        if hasattr(self._manager, "outputs") and self._manager.outputs:
             for output_id, output in self._manager.outputs._outputs.items():
                 # Skip cover outputs - they are published in discovery/covers
-                output_type = getattr(output, 'output_type', None)
-                if output_type == 'cover':
+                output_type = getattr(output, "output_type", None)
+                if output_type == "cover":
                     continue
                 output_info = {
                     "id": output_id,
-                    "name": getattr(output, 'name', output_id),
+                    "name": getattr(output, "name", output_id),
                 }
                 if output_type:
                     output_info["type"] = output_type
                 outputs.append(output_info)
         return outputs
-    
+
     def _build_covers(self) -> list[dict[str, Any]]:
-        """Build covers list."""
+        """Build covers list with tilt support info."""
         covers = []
-        if hasattr(self._manager, 'covers') and self._manager.covers:
+        if hasattr(self._manager, "covers") and self._manager.covers:
             for cover_id, cover in self._manager.covers._covers.items():
-                covers.append({
+                cover_info: dict[str, Any] = {
                     "id": cover_id,
-                    "name": getattr(cover, 'name', cover_id),
-                })
+                    "name": getattr(cover, "name", cover_id),
+                    "kind": getattr(cover, "kind", "time"),
+                    "supports_tilt": getattr(cover, "kind", "time") == "venetian",
+                }
+                covers.append(cover_info)
         return covers
-    
+
     def _build_inputs(self) -> list[dict[str, Any]]:
         """Build inputs list."""
         inputs = []
-        if hasattr(self._manager, 'inputs') and self._manager.inputs:
+        if hasattr(self._manager, "inputs") and self._manager.inputs:
             for input_id, input_device in self._manager.inputs._inputs.items():
-                inputs.append({
-                    "id": input_id,
-                    "name": getattr(input_device, 'name', input_id),
-                })
+                inputs.append(
+                    {
+                        "id": input_id,
+                        "name": getattr(input_device, "name", input_id),
+                    }
+                )
         return inputs
-    
+
     def _build_sensors(self) -> list[dict[str, Any]]:
         """Build sensors list."""
         sensors = []
-        if hasattr(self._manager, 'sensors') and self._manager.sensors:
-            if hasattr(self._manager.sensors, '_dallas_sensors'):
+        if hasattr(self._manager, "sensors") and self._manager.sensors:
+            if hasattr(self._manager.sensors, "_dallas_sensors"):
                 for sensor in self._manager.sensors._dallas_sensors:
-                    sensors.append({
-                        "id": sensor.id,
-                        "name": sensor.name,
-                        "type": "temperature",
-                    })
-            if hasattr(self._manager.sensors, '_adc_sensors'):
+                    sensors.append(
+                        {
+                            "id": sensor.id,
+                            "name": sensor.name,
+                            "type": "temperature",
+                        }
+                    )
+            if hasattr(self._manager.sensors, "_adc_sensors"):
                 for sensor in self._manager.sensors._adc_sensors:
-                    sensors.append({
-                        "id": sensor.id,
-                        "name": sensor.name,
-                        "type": "adc",
-                    })
+                    sensors.append(
+                        {
+                            "id": sensor.id,
+                            "name": sensor.name,
+                            "type": "adc",
+                        }
+                    )
         return sensors
-    
+
     def _build_modbus(self) -> list[dict[str, Any]]:
         """Build modbus devices list."""
         modbus_devices = []
-        if hasattr(self._manager, 'modbus') and self._manager.modbus:
-            if hasattr(self._manager.modbus, '_modbus_coordinators'):
-                for device_id, device in self._manager.modbus._modbus_coordinators.items():
-                    device_info = {
-                        "id": device_id,
-                        "name": getattr(device, 'name', device_id),
-                    }
-                    if hasattr(device, 'model'):
-                        device_info["model"] = device.model
-                    modbus_devices.append(device_info)
+        if (
+            hasattr(self._manager, "modbus")
+            and self._manager.modbus
+            and hasattr(self._manager.modbus, "_modbus_coordinators")
+        ):
+            for device_id, device in self._manager.modbus._modbus_coordinators.items():
+                device_info = {
+                    "id": device_id,
+                    "name": getattr(device, "name", device_id),
+                }
+                if hasattr(device, "model"):
+                    device_info["model"] = device.model
+                modbus_devices.append(device_info)
         return modbus_devices
-    
+
     # Public methods for publishing individual sections
-    
+
     def publish_device(self) -> None:
         """Publish device info to discovery/device."""
         self._publish("device", self._build_device_info())
-    
+
     def publish_outputs(self) -> None:
         """Publish outputs list to discovery/outputs."""
         self._publish("outputs", self._build_outputs())
-    
+
     def publish_covers(self) -> None:
         """Publish covers list to discovery/covers."""
         self._publish("covers", self._build_covers())
-    
+
     def publish_inputs(self) -> None:
         """Publish inputs list to discovery/inputs."""
         self._publish("inputs", self._build_inputs())
-    
+
     def publish_sensors(self) -> None:
         """Publish sensors list to discovery/sensors."""
         self._publish("sensors", self._build_sensors())
-    
+
     def publish_modbus(self) -> None:
         """Publish modbus devices list to discovery/modbus."""
         self._publish("modbus", self._build_modbus())
@@ -177,13 +189,15 @@ class BlackDiscoveryPublisher:
     def _build_irrigation(self) -> list[dict[str, Any]]:
         """Build irrigation controllers list."""
         controllers = []
-        if hasattr(self._manager, 'irrigation') and self._manager.irrigation:
+        if hasattr(self._manager, "irrigation") and self._manager.irrigation:
             for ctrl_id, ctrl in self._manager.irrigation._controllers.items():
-                controllers.append({
-                    "id": ctrl_id,
-                    "name": ctrl.name,
-                    "zones": [{"id": z.id, "name": z.name} for z in ctrl.zones],
-                })
+                controllers.append(
+                    {
+                        "id": ctrl_id,
+                        "name": ctrl.name,
+                        "zones": [{"id": z.id, "name": z.name} for z in ctrl.zones],
+                    }
+                )
         return controllers
 
     def publish_irrigation(self) -> None:
@@ -192,7 +206,7 @@ class BlackDiscoveryPublisher:
 
     async def publish_discovery(self) -> None:
         """Publish all discovery sections.
-        
+
         Publishes to:
         - boneio/{device_id}/discovery/device
         - boneio/{device_id}/discovery/outputs
@@ -201,24 +215,20 @@ class BlackDiscoveryPublisher:
         - boneio/{device_id}/discovery/sensors
         - boneio/{device_id}/discovery/modbus
         - boneio/{device_id}/discovery/irrigation
-        
+
         All with retain=True.
-        
+
         Does nothing if send_boneio_autodiscovery is disabled in config.
         """
         # Check if autodiscovery publishing is enabled
         if not self._manager._config_helper.send_boneio_autodiscovery:
             _LOGGER.debug("BoneIO autodiscovery publishing is disabled")
             return
-        
+
         try:
             device_info = self._build_device_info()
-            _LOGGER.info(
-                "Publishing discovery for device '%s' to '%s/*'",
-                device_info["id"],
-                self._base_topic
-            )
-            
+            _LOGGER.info("Publishing discovery for device '%s' to '%s/*'", device_info["id"], self._base_topic)
+
             self.publish_device()
             self.publish_outputs()
             self.publish_covers()
@@ -226,9 +236,8 @@ class BlackDiscoveryPublisher:
             self.publish_sensors()
             self.publish_modbus()
             self.publish_irrigation()
-            
+
             _LOGGER.info("Discovery published successfully")
-            
+
         except Exception as e:
             _LOGGER.error("Failed to publish discovery: %s", e, exc_info=True)
-