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

boneio/bonecli.py

@@ -240,13 +240,16 @@ def run(
 
     try:
         _t1 = _time.monotonic()
-        _config = load_config_from_file(config_file=config)
+        _config = load_config_from_file(
+            config_file=config, progress_callback=draw_status,
+        )
         _LOGGER.debug("[STARTUP TIMING] load_config_from_file: %.2fs", _time.monotonic() - _t1)
         if not _config:
             _LOGGER.error("Config not loaded. Exiting.")
             draw_config_error("Config file is empty or missing")
             return 1
         configure_logger(log_config=_config.get("logger") or {}, debug=debug)
+        draw_status("Importing modules...")
         # Granular timing of runner sub-imports to find the bottleneck
         _t_a = _time.monotonic()
         from boneio.const import ACTION

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)