boneio 1.4.4.dev1__tar.gz → 1.5.0.dev1__tar.gz

{boneio-1.4.4.dev1/boneio.egg-info → boneio-1.5.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boneio
-Version: 1.4.4.dev1
+Version: 1.5.0.dev1
 Summary: Python App for BoneIO
 Author-email: Paweł Szafer <pszafer@gmail.com>
 License: GNU General Public License v3.0

{boneio-1.4.4.dev1 → boneio-1.5.0.dev1}/boneio/components/input/detectors.py

@@ -467,7 +467,7 @@ class MultiClickDetector:
         if event.event_type is event.Type.FALLING_EDGE:
             # Button pressed (FALLING_EDGE on BeagleBone with pull-up)
             
-            # Software debounce
+            # Software debounce (press-vs-press)
             if self._state.last_press_ts and (timestamp_s - self._state.last_press_ts) < self._debounce_seconds:
                 delta_ms = (timestamp_s - self._state.last_press_ts) * 1000
                 _LOGGER.debug(
@@ -478,6 +478,19 @@ class MultiClickDetector:
                 )
                 return
 
+            # Cross-debounce: ignore press too close to release (bounce on falling edge
+            # after a real release). Without this, releasing a long-held button can
+            # generate a bounce FALLING that starts a new phantom press cycle.
+            if self._state.last_release_ts and (timestamp_s - self._state.last_release_ts) < self._debounce_seconds:
+                delta_ms = (timestamp_s - self._state.last_release_ts) * 1000
+                _LOGGER.debug(
+                    "Ignoring bounced press on %s (%.3f ms since release, debounce %.3f ms)",
+                    self._name,
+                    delta_ms,
+                    self._debounce_seconds * 1000,
+                )
+                return
+
             _LOGGER.debug("PRESSED: %s (%s)", self._name, self._pin)
             self._state.last_press_ts = timestamp_s
             self._state.last_press_loop_ts = self._loop.time()  # Store loop time for duration calc
@@ -618,13 +631,20 @@ class MultiClickDetector:
         timestamp_s = time.time()
 
         if is_pressed:
-            # Debounce
+            # Debounce (press-vs-press)
             if (
                 self._state.last_press_ts
                 and (timestamp_s - self._state.last_press_ts) < self._debounce_seconds
             ):
                 return
 
+            # Cross-debounce: ignore press too close to release (bounce)
+            if (
+                self._state.last_release_ts
+                and (timestamp_s - self._state.last_release_ts) < self._debounce_seconds
+            ):
+                return
+
             _LOGGER.debug("RAW PRESSED: %s (%s)", self._name, self._pin)
             self._state.last_press_ts = timestamp_s
             self._state.last_press_loop_ts = self._loop.time()

{boneio-1.4.4.dev1 → boneio-1.5.0.dev1}/boneio/components/irrigation/controller.py

@@ -469,7 +469,7 @@ class IrrigationController:
         await self._advance_to_next_zone(force=True)
 
     async def start_full_cycle(self) -> None:
-        _LOGGER.debug(
+        _LOGGER.info(
             "Irrigation %s start_full_cycle: state=%s standby=%s skip_next=%s",
             self.id,
             self._state.value,
@@ -486,6 +486,11 @@ class IrrigationController:
             return
 
         if self._state in (ControllerState.RUNNING, ControllerState.PAUSED):
+            _LOGGER.info(
+                "Irrigation %s: already %s, shutting down before new cycle",
+                self.id,
+                self._state.value,
+            )
             await self.shutdown()
 
         self._single_zone_mode = False
@@ -548,7 +553,7 @@ class IrrigationController:
         eligible = self._eligible_zones()
         if scheduled:
             self._apply_skip_counters()
-        _LOGGER.debug(
+        _LOGGER.info(
             "Irrigation %s _start_cycle_from_eligible: %d eligible zones: %s",
             self.id,
             len(eligible),
@@ -1121,31 +1126,128 @@ class IrrigationController:
         return earliest
 
     def start_schedules(self) -> None:
+        """Start all schedule loops as asyncio tasks.
+
+        Cancels any existing schedule tasks first, then creates new ones.
+        Each schedule entry gets its own long-lived asyncio.Task that
+        sleeps until the next fire time.
+        """
         self.stop_schedules()
+        if not self._schedule:
+            _LOGGER.debug("Irrigation %s: no schedules configured", self.id)
+            return
         for idx, schedule in enumerate(self._schedule):
-            task = asyncio.create_task(self._run_schedule_loop(idx, schedule))
+            task = asyncio.create_task(
+                self._run_schedule_loop(idx, schedule),
+                name=f"irrigation_{self.id}_schedule_{idx}",
+            )
             self._schedule_tasks.append(task)
+            _LOGGER.info(
+                "Irrigation %s: schedule task #%d started (time=%s, days=%s)",
+                self.id,
+                idx,
+                schedule.get("time", "06:00"),
+                schedule.get("days", "daily"),
+            )
 
     def stop_schedules(self) -> None:
+        """Cancel all schedule tasks."""
+        if self._schedule_tasks:
+            _LOGGER.info(
+                "Irrigation %s: stopping %d schedule task(s)",
+                self.id,
+                len(self._schedule_tasks),
+            )
         for task in self._schedule_tasks:
             task.cancel()
         self._schedule_tasks = []
 
     async def _run_schedule_loop(self, schedule_idx: int, schedule: dict[str, Any]) -> None:
+        """Run a single schedule entry in a loop.
+
+        Sleeps until the next fire time, then starts a full irrigation cycle.
+        This task runs for the entire lifetime of the controller.
+
+        CRITICAL: This method must NEVER raise an unhandled exception,
+        as that would permanently kill the schedule task with no recovery.
+        All exceptions are caught, logged, and the loop continues with
+        a back-off delay.
+
+        Args:
+            schedule_idx: Index of this schedule in the schedule list.
+            schedule: Schedule configuration dict with 'time' and 'days'.
+        """
         time_str = schedule.get("time", "06:00")
         days = str(schedule.get("days", "daily")).strip().lower()
+        consecutive_errors = 0
+
+        _LOGGER.info(
+            "Irrigation %s: schedule loop #%d started (time=%s, days=%s)",
+            self.id,
+            schedule_idx,
+            time_str,
+            days,
+        )
+
         while True:
-            next_run = _next_fire_time(time_str, days)
-            wait_s = max(1.0, (next_run - utcnow()).total_seconds())
-            await asyncio.sleep(wait_s)
+            try:
+                next_run = _next_fire_time(time_str, days)
+                now = utcnow()
+                wait_s = max(1.0, (next_run - now).total_seconds())
+
+                # Convert to local for human-readable log
+                local_tz = _local_now().tzinfo
+                next_run_local = next_run.astimezone(local_tz)
+                _LOGGER.info(
+                    "Irrigation %s: schedule #%d next fire at %s (in %.0f seconds)",
+                    self.id,
+                    schedule_idx,
+                    next_run_local.strftime("%Y-%m-%d %H:%M:%S %Z"),
+                    wait_s,
+                )
 
-            if bool(schedule.get("skip", False)):
-                schedule["skip"] = False
-                self._save(f"schedule/{schedule_idx}/skip", False)
-                await self.publish_all_states()
-                continue
+                await asyncio.sleep(wait_s)
 
-            await self.start_full_cycle()
+                # Reset error counter on successful wake-up
+                consecutive_errors = 0
+
+                if bool(schedule.get("skip", False)):
+                    _LOGGER.info(
+                        "Irrigation %s: schedule #%d skipped (one-time skip)",
+                        self.id,
+                        schedule_idx,
+                    )
+                    schedule["skip"] = False
+                    self._save(f"schedule/{schedule_idx}/skip", False)
+                    await self.publish_all_states()
+                    continue
+
+                _LOGGER.info(
+                    "Irrigation %s: schedule #%d firing — starting full cycle",
+                    self.id,
+                    schedule_idx,
+                )
+                await self.start_full_cycle()
+
+            except asyncio.CancelledError:
+                _LOGGER.info(
+                    "Irrigation %s: schedule loop #%d cancelled",
+                    self.id,
+                    schedule_idx,
+                )
+                raise
+            except Exception:
+                consecutive_errors += 1
+                backoff_s = min(300, 30 * consecutive_errors)
+                _LOGGER.exception(
+                    "Irrigation %s: schedule loop #%d encountered an error "
+                    "(attempt %d, retrying in %ds)",
+                    self.id,
+                    schedule_idx,
+                    consecutive_errors,
+                    backoff_s,
+                )
+                await asyncio.sleep(backoff_s)
 
 def _local_now() -> datetime:
     """Return the current time in the system's local timezone.

{boneio-1.4.4.dev1 → boneio-1.5.0.dev1}/boneio/components/output/remote.py

@@ -178,14 +178,27 @@ class RemoteOutputBase:
     def _sync_initial_state(self) -> None:
         """Sync initial state from device manager's current known states.
 
-        Reads _light_states or _switch_states from the ESPHome device
-        to populate brightness and on/off state immediately, without
-        waiting for the next state change event.
+        Reads cached states from ESPHome (_light_states / _switch_states)
+        or WLED (_cached_state) to populate brightness and on/off state
+        immediately, without waiting for the next state change event.
         """
         if self._device_manager is None:
             return
 
-        # Try light state first
+        # WLED: sync from WebSocket cached state
+        get_output_is_on = getattr(self._device_manager, "get_output_is_on", None)
+        if get_output_is_on is not None:
+            is_on = get_output_is_on(self._output_id)
+            if is_on is not None:
+                self.on_remote_state_change(is_on)
+                _LOGGER.debug(
+                    "Synced initial WLED state for '%s': on=%s",
+                    self._id,
+                    is_on,
+                )
+                return
+
+        # ESPHome: try light state first
         light_states = getattr(self._device_manager, "_light_states", {})
         _LOGGER.debug(
             "Sync initial state for '%s': output_id='%s', light_states_keys=%s, switch_states_keys=%s",
@@ -208,7 +221,7 @@ class RemoteOutputBase:
             )
             return
 
-        # Try switch state
+        # ESPHome: try switch state
         switch_states = getattr(self._device_manager, "_switch_states", {})
         if self._output_id in switch_states:
             is_on = switch_states[self._output_id]

{boneio-1.4.4.dev1 → boneio-1.5.0.dev1}/boneio/core/cloud/data/docker-compose.yaml

@@ -9,17 +9,22 @@ services:
       - ./node-red/settings.js:/data/settings.js:ro
     extra_hosts:
       - "host.docker.internal:host-gateway"
+    logging:
+      driver: json-file
+      options:
+        max-size: "5m"
+        max-file: "2"
     networks:
       - edge
   caddy:
     image: caddy:2-alpine
     restart: unless-stopped
-    hostname: ${HOSTNAME}
+    hostname: ${HOSTNAME:-boneio}
     ports:
       - "${HTTP_PORT:-8091}:80"
       - "${HTTPS_PORT:-8443}:443"
     environment:
-      - HOST_HOSTNAME=${HOSTNAME}
+      - HOST_HOSTNAME=${HOSTNAME:-boneio}
     volumes:
       - ./caddy/502.html:/srv/502.html:ro
       - ./caddy/init-certs.sh:/init-certs.sh:ro
@@ -30,6 +35,11 @@ services:
     command: ["/init-certs.sh"]
     extra_hosts:
       - "host.docker.internal:host-gateway"
+    logging:
+      driver: json-file
+      options:
+        max-size: "5m"
+        max-file: "2"
     networks:
       - edge
 

{boneio-1.4.4.dev1 → boneio-1.5.0.dev1}/boneio/core/config/yaml_util.py

@@ -895,7 +895,7 @@ def _try_load_cached_config(config_file: str) -> dict | None:
             _LOGGER.debug("Schema file changed, cache invalidated")
             return None
 
-        _LOGGER.info("Loading validated config from cache (skipping Cerberus validation)")
+        _LOGGER.debug("Loading validated config from cache (skipping Cerberus validation)")
         return cached["data"]
     except (FileNotFoundError, pickle.UnpicklingError, OSError, EOFError) as e:
         _LOGGER.debug("Config cache not available: %s", e)

{boneio-1.4.4.dev1 → boneio-1.5.0.dev1}/boneio/core/manager/irrigation.py

@@ -176,10 +176,37 @@ class IrrigationManager:
             self._publish_discovery(ctrl)
 
     async def start(self) -> None:
+        """Start irrigation controllers — called once on first MQTT connection.
+
+        Subscribes MQTT command topics, starts schedule tasks, and publishes
+        initial states.
+        """
         for ctrl in self._controllers.values():
             await self._subscribe_controller(ctrl)
             ctrl.start_schedules()
             await ctrl.publish_all_states()
+            _LOGGER.info(
+                "Irrigation controller '%s' started with %d schedule(s), %d zone(s)",
+                ctrl.id,
+                len(ctrl._schedule),
+                len(ctrl.zones),
+            )
+
+    async def reconnect(self) -> None:
+        """Handle MQTT reconnect — re-subscribe topics and re-publish states.
+
+        IMPORTANT: This does NOT restart schedule tasks.  Schedule tasks are
+        long-lived asyncio.Tasks that sleep until the next fire time.
+        Restarting them on every MQTT reconnect would cancel the pending sleep
+        and recalculate the next fire time from "now", potentially skipping
+        a schedule that was about to fire.
+
+        Only MQTT subscriptions and state publication are refreshed.
+        """
+        _LOGGER.info("Irrigation MQTT reconnect: re-subscribing topics and re-publishing states")
+        for ctrl in self._controllers.values():
+            await self._subscribe_controller(ctrl)
+            await ctrl.publish_all_states()
 
     async def stop(self) -> None:
         for topic in list(self._subscribed_topics):

{boneio-1.4.4.dev1 → boneio-1.5.0.dev1}/boneio/core/manager/manager.py

@@ -855,6 +855,8 @@ class Manager:
         """Resolve a boneIO entity by type and ID for condition evaluation.
 
         Used by the conditions system to check entity states.
+        Remote outputs from ``remote_outputs`` config are registered in
+        OutputManager, so they are resolved via ``entity_type='output'``.
 
         Args:
             entity_type: Entity type ('binary_sensor', 'cover', 'output', 'light')
@@ -865,13 +867,13 @@ class Manager:
         """
         if entity_type in ("output", "light"):
             return self.outputs.get_output(entity_id) or self.outputs.get_output_group(entity_id)
-        elif entity_type == "cover":
+        if entity_type == "cover":
             return self.covers.get_cover(entity_id)
-        elif entity_type == "binary_sensor":
+        if entity_type == "binary_sensor":
             return self.inputs.get_input(entity_id)
-        else:
-            _LOGGER.warning("Unknown entity type for condition: %s", entity_type)
-            return None
+        _LOGGER.warning("Unknown entity type for condition: %s", entity_type)
+        return None
+
 
     async def execute_actions(
         self,
@@ -1691,6 +1693,13 @@ class Manager:
         """Function to invoke when connection to MQTT is (re-)established.
 
         Sends online status to MQTT and starts template MQTT subscriptions.
+
+        IMPORTANT: This is called on every MQTT reconnect, not just the first
+        connection.  Schedule tasks must NOT be restarted here — they are
+        long-lived ``asyncio.Task``s that sleep until the next fire time.
+        Restarting them on reconnect would cancel the pending sleep and
+        recalculate the next fire time from "now", potentially skipping
+        a schedule that was about to fire.
         """
         _LOGGER.info("Sending online state.")
         topic = f"{self._config_helper.topic_prefix}/{STATE}"
@@ -1701,7 +1710,7 @@ class Manager:
 
         # Start template entities (subscribe to MQTT command topics)
         await self.templates.start()
-        await self.irrigation.start()
+        await self.irrigation.reconnect()
 
     async def receive_message(self, topic: str, message: str) -> None:
         """Callback for receiving MQTT messages.

{boneio-1.4.4.dev1 → boneio-1.5.0.dev1}/boneio/core/manager/remote.py

@@ -309,11 +309,11 @@ class RemoteDeviceManager:
         """Initialize remote devices in background.
 
         Configures devices from pending config (importing ESPHome/WLED modules
-        only at this point) and starts persistent ESPHome connections.
+        only at this point) and starts persistent ESPHome and WLED connections.
         This runs as a background task so it does not block application startup.
 
         Args:
-            delay_seconds: Seconds to wait before starting ESPHome connections
+            delay_seconds: Seconds to wait before starting connections
         """
         # 1. Configure devices (this triggers lazy module imports)
         if self._pending_config:
@@ -322,7 +322,10 @@ class RemoteDeviceManager:
             self._pending_config = None
         self._initialized = True
 
-        # 2. Start ESPHome connections after delay
+        # 2. Start WLED WebSocket listeners immediately (lightweight)
+        self._start_wled_ws_listeners()
+
+        # 3. Start ESPHome connections after delay
         esphome_devices = [
             (device_id, device)
             for device_id, device in self._devices.items()
@@ -345,6 +348,24 @@ class RemoteDeviceManager:
             except Exception as e:
                 _LOGGER.error("Failed to start connection for ESPHome device '%s': %s", device_id, e)
 
+    def _start_wled_ws_listeners(self) -> None:
+        """Start WebSocket listeners for all WLED devices.
+
+        Each WLED device gets a background task that maintains a persistent
+        WebSocket connection for real-time state updates.
+        """
+        wled_devices = [
+            (device_id, device)
+            for device_id, device in self._devices.items()
+            if device.protocol == RemoteDeviceProtocol.WLED
+        ]
+
+        for device_id, device in wled_devices:
+            try:
+                cast(Any, device).start_ws_listener()
+            except Exception as e:
+                _LOGGER.error("Failed to start WLED WS for '%s': %s", device_id, e)
+
     async def stop_all_connections(self) -> None:
         """Stop all persistent connections.
 
@@ -686,6 +707,9 @@ class RemoteDeviceManager:
         if remote_devices_config:
             self._configure_devices(remote_devices_config)
 
+        # Start WLED WS listeners immediately
+        self._start_wled_ws_listeners()
+
         # Start ESPHome connections immediately (no delay for reload)
         await self._start_esphome_connections_immediate()
 

{boneio-1.4.4.dev1 → boneio-1.5.0.dev1}/boneio/core/manager/sensors.py

@@ -843,29 +843,40 @@ class SensorManager:
 
         Creates sensors for monitoring system resources and sends
         HA autodiscovery messages for each.
+
+        For disk sensors, auto-detects mounted partitions:
+        - eMMC (/dev/mmcblk1) → "eMMC Usage"
+        - SD card (/dev/mmcblk0) → "SD Card Usage"
+        - Other root partitions → "System Disk Usage"
         """
         from boneio.core.sensor.system import (
             CpuUsageSensor,
             DiskUsageSensor,
             MemoryUsageSensor,
+            detect_disk_sensors,
         )
         from boneio.integration.homeassistant import ha_sensor_system_availabilty_message
 
-        # Disk Usage Sensor
-        disk_sensor = DiskUsageSensor(
-            manager=self._manager,
-            message_bus=self._manager._message_bus,
-            topic_prefix=self._manager._topic_prefix,
-        )
-        self._system_sensors.append(disk_sensor)
-        payload = ha_sensor_system_availabilty_message(
-            id=disk_sensor.id,
-            name=disk_sensor.name,
-            config_helper=self._manager._config_helper,
-            unit_of_measurement="%",
-            icon="mdi:harddisk",
-        )
-        self._manager.publish_ha_discovery(id=disk_sensor.id, ha_type=SENSOR, payload=payload)
+        # Disk Usage Sensors — auto-detect all connected disks
+        disk_configs = detect_disk_sensors()
+        for disk_cfg in disk_configs:
+            disk_sensor = DiskUsageSensor(
+                manager=self._manager,
+                message_bus=self._manager._message_bus,
+                topic_prefix=self._manager._topic_prefix,
+                mount_point=disk_cfg["mount_point"],
+                sensor_id=disk_cfg["id"],
+                name=disk_cfg["name"],
+            )
+            self._system_sensors.append(disk_sensor)
+            payload = ha_sensor_system_availabilty_message(
+                id=disk_sensor.id,
+                name=disk_sensor.name,
+                config_helper=self._manager._config_helper,
+                unit_of_measurement="%",
+                icon=disk_cfg["icon"],
+            )
+            self._manager.publish_ha_discovery(id=disk_sensor.id, ha_type=SENSOR, payload=payload)
 
         # Memory Usage Sensor
         memory_sensor = MemoryUsageSensor(
@@ -1382,14 +1393,20 @@ class SensorManager:
         # System sensors
         from boneio.integration.homeassistant import ha_sensor_system_availabilty_message
 
-        _icon_map = {"disk_usage": "mdi:harddisk", "memory_usage": "mdi:memory", "cpu_usage": "mdi:cpu-64-bit"}
+        _icon_map = {
+            "disk_usage": "mdi:harddisk",
+            "emmc_usage": "mdi:harddisk",
+            "sd_card_usage": "mdi:micro-sd",
+            "memory_usage": "mdi:memory",
+            "cpu_usage": "mdi:cpu-64-bit",
+        }
         for sensor in self._system_sensors:
             payload = ha_sensor_system_availabilty_message(
                 id=sensor.id,
                 name=sensor.name,
                 config_helper=self._manager._config_helper,
                 unit_of_measurement="%",
-                icon=_icon_map.get(sensor.id, "mdi:chip"),
+                icon=_icon_map.get(sensor.id, "mdi:harddisk"),
             )
             self._manager.publish_ha_discovery(id=sensor.id, ha_type=SENSOR, payload=payload)
 

{boneio-1.4.4.dev1 → boneio-1.5.0.dev1}/boneio/core/manager/templates/__init__.py

@@ -65,17 +65,17 @@ class TemplateManager:
     # -- Sub-manager accessors -----------------------------------------------
 
     @property
-    def thermostats(self) -> ThermostatManager:
+    def thermostat_manager(self) -> ThermostatManager:
         """Thermostat sub-manager."""
         return self._thermostats
 
     @property
-    def alarms(self) -> AlarmManager:
+    def alarm_manager(self) -> AlarmManager:
         """Alarm panel sub-manager."""
         return self._alarms
 
     @property
-    def gates(self) -> GateCoverManager:
+    def gate_manager(self) -> GateCoverManager:
         """Gate cover sub-manager."""
         return self._gates