boneio 1.5.0.dev11__tar.gz → 1.5.0.dev12__tar.gz

{boneio-1.5.0.dev11/boneio.egg-info → boneio-1.5.0.dev12}/PKG-INFO

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

{boneio-1.5.0.dev11 → boneio-1.5.0.dev12}/boneio/components/template/gate_cover.py

@@ -191,10 +191,14 @@ class BoneIOGateCover:
     # -- MQTT ----------------------------------------------------------------
 
     async def start(self) -> None:
-        """Subscribe to MQTT command topic."""
+        """Subscribe to MQTT command topic and publish current state.
+
+        Initial sensor state is already set by TemplateManager during
+        configuration, so start() just subscribes and publishes.
+        """
         await self._message_bus.subscribe_and_listen(self._cmd_topic, self.handle_command)
         self._publish_state()
-        _LOGGER.info("GateCover %s started, subscribed to %s", self._id, self._cmd_topic)
+        _LOGGER.info("GateCover %s started (state=%s), subscribed to %s", self._id, self._state, self._cmd_topic)
 
     async def stop(self) -> None:
         """Unsubscribe from MQTT and cancel timers."""

{boneio-1.5.0.dev11 → boneio-1.5.0.dev12}/boneio/core/manager/inputs.py

@@ -801,16 +801,18 @@ class InputManager:
         # Send event to MQTT for Home Assistant
         self._publish_input_event_to_mqtt(input_instance, event)
 
-        # Route to template entities (gate covers, alarm panels)
-        # This must happen before the publish_only check so initial state
-        # sync events reach gate covers and alarm panels.
-        self._manager.templates.on_input_event(event.entity_id, event.click_type)
-
-        # If publish_only is set, skip action execution (used for initial state sync)
+        # If publish_only is set, skip action execution AND template routing.
+        # publish_only events come from initial state sync (binary_sensor
+        # initial_send) — routing them to gate covers would cause spurious
+        # state transitions that trigger HA automations on every restart.
+        # Gate covers read sensor state silently during their own start().
         if event.publish_only:
-            _LOGGER.debug("Skipping action execution for %s (publish_only=True)", event.entity_id)
+            _LOGGER.debug("Skipping actions and template routing for %s (publish_only=True)", event.entity_id)
             return
 
+        # Route to template entities (gate covers, alarm panels)
+        self._manager.templates.on_input_event(event.entity_id, event.click_type)
+
         # Cancel pending delayed actions if this event matches delay_cancel_on
         # Check ALL click types' actions for delay_cancel_on (not just current click_type)
         self._cancel_delayed_if_matching(input_instance, event.entity_id, event.click_type)

{boneio-1.5.0.dev11 → boneio-1.5.0.dev12}/boneio/core/manager/remote.py

@@ -473,7 +473,11 @@ class RemoteDeviceManager:
                 action=action,
             )
 
-        # For WLED devices, use HTTP JSON API
+        # For WLED devices, use fire-and-forget HTTP JSON API.
+        # WLED HTTP requests can stall for seconds when the device is
+        # unreachable (DNS timeout on .local), which blocks the EventBus
+        # worker and freezes ALL input events.  Fire-and-forget schedules
+        # the request as a background task so the caller returns immediately.
         if device.protocol == RemoteDeviceProtocol.WLED:
             _LOGGER.debug("Controlling WLED '%s' segment '%s' on device '%s'", output_id, action, device_id)
             # Parse segment_id - "main" means whole device, otherwise it's segment ID
@@ -482,7 +486,9 @@ class RemoteDeviceManager:
             wled_rgb: tuple[int, int, int] | None = None
             if rgb and len(rgb) >= 3:
                 wled_rgb = (rgb[0], rgb[1], rgb[2])
-            return await cast(Any, device).control_light(
+            from boneio.core.remote.wled import WLEDRemoteDevice
+            wled_device = cast(WLEDRemoteDevice, device)
+            wled_device.control_light_fire_and_forget(
                 segment_id=segment_id,
                 action=action,
                 brightness=brightness,
@@ -494,6 +500,7 @@ class RemoteDeviceManager:
                 effect_speed=effect_speed,
                 effect_intensity=effect_intensity,
             )
+            return True  # Optimistic: task is scheduled
 
         # For MQTT devices, use standard control_output
         return await device.control_output(

{boneio-1.5.0.dev11 → boneio-1.5.0.dev12}/boneio/core/manager/templates/__init__.py

@@ -145,6 +145,9 @@ class TemplateManager:
         for alarm in self._alarms.items:
             await alarm.start()
         for gate in self._gates.items:
+            # Sync sensor state silently before start() publishes state.
+            # Done here (not in configure()) because GPIO manager is now running.
+            self._gates.sync_initial_state(gate)
             await gate.start()
         _LOGGER.info("TemplateManager started all entities")
 
@@ -242,6 +245,7 @@ class TemplateManager:
                 continue
             gate = self._gates.get(eid)
             if gate:
+                self._gates.sync_initial_state(gate)
                 await gate.start()
 
         # Re-register all sensor EventBus listeners (clean slate)

{boneio-1.5.0.dev11 → boneio-1.5.0.dev12}/boneio/core/manager/templates/gate_cover.py

@@ -143,10 +143,6 @@ class GateCoverManager:
                     self._input_map[sensor_id] = []
                 self._input_map[sensor_id].append(gate)
 
-        # Read current sensor states to set correct initial gate state.
-        # Without this, gate defaults to CLOSED which may be wrong.
-        self._sync_initial_state(closed_sensor_id, open_sensor_id)
-
         # Publish HA discovery
         self._publish_discovery(gate)
 
@@ -159,23 +155,69 @@ class GateCoverManager:
 
     def _sync_initial_state(
         self,
+        gate: BoneIOGateCover,
         closed_sensor_id: str | None,
         open_sensor_id: str | None,
     ) -> None:
-        """Sync initial gate state by asking InputManager to re-send sensor states.
+        """Read current sensor GPIO state and set gate cover's initial state.
 
-        Delegates to InputManager.send_current_state_for_input() which reads
-        live GPIO and fires an EventBus event. The gate cover's event listener
-        picks it up automatically — no direct GPIO access needed here.
+        Reads the binary sensor's ``is_active`` property directly —
+        no EventBus events are fired, no MQTT messages are published.
+        Gate cover's ``start()`` will publish the correct state later.
 
         Args:
+            gate: The gate cover instance to initialize.
             closed_sensor_id: ID of the closed contact sensor (or None).
             open_sensor_id: ID of the open contact sensor (or None).
         """
+        from boneio.components.input.binary_sensor import GpioInputBinarySensor
+        from boneio.components.template.gate_cover import CYCLE_CLOSE, CYCLE_OPEN
+        from boneio.const import CLOSED, IDLE, OPEN
+
         input_mgr = self._manager.inputs
-        for sensor_id in (closed_sensor_id, open_sensor_id):
-            if sensor_id:
-                input_mgr.send_current_state_for_input(sensor_id)
+
+        if closed_sensor_id:
+            sensor = input_mgr._inputs.get(closed_sensor_id)
+            if sensor and isinstance(sensor, GpioInputBinarySensor):
+                is_closed = sensor.is_active
+                _LOGGER.debug(
+                    "Gate %s: initial closed_sensor %s is_active=%s",
+                    gate.id, closed_sensor_id, is_closed,
+                )
+                if is_closed:
+                    gate._state = CLOSED
+                    gate._current_operation = IDLE
+                    gate._cycle_next = CYCLE_OPEN
+                elif not gate._has_open_sensor:
+                    gate._state = OPEN
+                    gate._current_operation = IDLE
+
+        if open_sensor_id:
+            sensor = input_mgr._inputs.get(open_sensor_id)
+            if sensor and isinstance(sensor, GpioInputBinarySensor):
+                is_open = sensor.is_active
+                _LOGGER.debug(
+                    "Gate %s: initial open_sensor %s is_active=%s",
+                    gate.id, open_sensor_id, is_open,
+                )
+                if is_open:
+                    gate._state = OPEN
+                    gate._current_operation = IDLE
+                    gate._cycle_next = CYCLE_CLOSE
+
+    def sync_initial_state(self, gate: BoneIOGateCover) -> None:
+        """Public entry point for setting gate's initial state from sensor GPIO.
+
+        Called by TemplateManager during start() when GPIO manager is ready.
+
+        Args:
+            gate: Gate cover to sync.
+        """
+        self._sync_initial_state(
+            gate,
+            gate._closed_sensor_id,
+            gate._open_sensor_id,
+        )
 
     # -- Removal -------------------------------------------------------------
 

{boneio-1.5.0.dev11 → boneio-1.5.0.dev12}/boneio/core/manager/templates.py

@@ -17,9 +17,9 @@ from boneio.components.template.alarm_panel import (
     BoneIOAlarmPanel,
     ZoneInput,
 )
-from boneio.components.template.gate_cover import BoneIOGateCover
+from boneio.components.template.gate_cover import BoneIOGateCover, CYCLE_CLOSE, CYCLE_OPEN
 from boneio.components.template.thermostat import BoneIOThermostat
-from boneio.const import ALARM_CONTROL_PANEL, CLIMATE, COVER
+from boneio.const import ALARM_CONTROL_PANEL, CLIMATE, CLOSED, COVER, IDLE, OPEN
 from boneio.core.utils.timeperiod import parse_time_to_ms, parse_time_to_seconds
 
 if TYPE_CHECKING:
@@ -365,7 +365,7 @@ class TemplateManager:
 
         # Read current sensor states to set correct initial gate state.
         # Without this, gate defaults to CLOSED which may be wrong.
-        self._sync_gate_initial_state(closed_sensor_id, open_sensor_id)
+        self._sync_gate_initial_state(gate, closed_sensor_id, open_sensor_id)
 
         # Publish HA discovery
         self._publish_gate_cover_discovery(gate)
@@ -379,23 +379,53 @@ class TemplateManager:
 
     def _sync_gate_initial_state(
         self,
+        gate: BoneIOGateCover,
         closed_sensor_id: str | None,
         open_sensor_id: str | None,
     ) -> None:
-        """Sync initial gate state by asking InputManager to re-send sensor states.
+        """Read current sensor GPIO state and set gate cover's initial state.
 
-        Delegates to InputManager.send_current_state_for_input() which reads
-        live GPIO and fires an EventBus event. The gate cover's event listener
-        picks it up automatically.
+        Reads the binary sensor's ``is_active`` property directly —
+        no EventBus events are fired, no MQTT messages are published.
+        Gate cover's ``start()`` will publish the correct state later.
 
         Args:
+            gate: The gate cover instance to initialize.
             closed_sensor_id: ID of the closed contact sensor (or None).
             open_sensor_id: ID of the open contact sensor (or None).
         """
+        from boneio.components.input.binary_sensor import GpioInputBinarySensor
+
         input_mgr = self._manager.inputs
-        for sensor_id in (closed_sensor_id, open_sensor_id):
-            if sensor_id:
-                input_mgr.send_current_state_for_input(sensor_id)
+
+        if closed_sensor_id:
+            sensor = input_mgr._inputs.get(closed_sensor_id)
+            if sensor and isinstance(sensor, GpioInputBinarySensor):
+                is_closed = sensor.is_active
+                _LOGGER.debug(
+                    "Gate %s: initial closed_sensor %s is_active=%s",
+                    gate.id, closed_sensor_id, is_closed,
+                )
+                if is_closed:
+                    gate._state = CLOSED
+                    gate._current_operation = IDLE
+                    gate._cycle_next = CYCLE_OPEN
+                elif not gate._has_open_sensor:
+                    gate._state = OPEN
+                    gate._current_operation = IDLE
+
+        if open_sensor_id:
+            sensor = input_mgr._inputs.get(open_sensor_id)
+            if sensor and isinstance(sensor, GpioInputBinarySensor):
+                is_open = sensor.is_active
+                _LOGGER.debug(
+                    "Gate %s: initial open_sensor %s is_active=%s",
+                    gate.id, open_sensor_id, is_open,
+                )
+                if is_open:
+                    gate._state = OPEN
+                    gate._current_operation = IDLE
+                    gate._cycle_next = CYCLE_CLOSE
 
     # -- HA Discovery --------------------------------------------------------
 

{boneio-1.5.0.dev11 → boneio-1.5.0.dev12}/boneio/core/remote/wled.py

@@ -169,10 +169,25 @@ class WLEDRemoteDevice(RemoteDevice):
             _LOGGER.debug("Closed session for WLED '%s'", self._name)
     
     async def _get_session(self) -> aiohttp.ClientSession:
-        """Get or create aiohttp session."""
+        """Get or create aiohttp session.
+
+        Uses ``ThreadedResolver`` (system ``getaddrinfo`` via NSS) so that
+        mDNS ``.local`` hostnames are resolved correctly through Avahi.
+        The default aiohttp resolver (``AsyncResolver`` / c-ares) bypasses
+        NSS entirely, causing ``Name or service not known`` errors for
+        ``.local`` names even when ``ping`` from the same host works fine.
+
+        Timeout is kept short (3s total, 2s connect) so that unreachable
+        devices do not block the caller.
+        """
         if self._session is None or self._session.closed:
-            timeout = aiohttp.ClientTimeout(total=10)
-            self._session = aiohttp.ClientSession(timeout=timeout)
+            timeout = aiohttp.ClientTimeout(total=3, connect=2)
+            resolver = aiohttp.resolver.ThreadedResolver()
+            connector = aiohttp.TCPConnector(resolver=resolver)
+            self._session = aiohttp.ClientSession(
+                timeout=timeout,
+                connector=connector,
+            )
         return self._session
     
     async def _send_state(self, state: dict[str, Any]) -> bool:
@@ -366,6 +381,34 @@ class WLEDRemoteDevice(RemoteDevice):
         )
         
         return await self._send_state(state)
+
+    def control_light_fire_and_forget(
+        self,
+        **kwargs: Any,
+    ) -> None:
+        """Schedule ``control_light`` as a background task.
+
+        Use this when the caller must not be blocked by network I/O
+        (e.g. when called from the EventBus action handler).  The task
+        runs independently; failures are logged but do not propagate.
+
+        Args:
+            **kwargs: Forwarded to :meth:`control_light`.
+        """
+        asyncio.create_task(
+            self._control_light_safe(**kwargs),
+            name=f"wled_ff_{self._id}",
+        )
+
+    async def _control_light_safe(self, **kwargs: Any) -> None:
+        """Wrapper that catches all exceptions so fire-and-forget tasks never crash."""
+        try:
+            await self.control_light(**kwargs)
+        except Exception as exc:
+            _LOGGER.error(
+                "WLED fire-and-forget failed for '%s': %s",
+                self._name, exc,
+            )
     
     async def control_output(
         self,

boneio-1.5.0.dev12/boneio/version.py

@@ -0,0 +1,2 @@
+# flake8: noqa
+__version__ = "1.5.0dev12"

{boneio-1.5.0.dev11 → boneio-1.5.0.dev12/boneio.egg-info}/PKG-INFO

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

boneio-1.5.0.dev11/boneio/version.py

@@ -1,2 +0,0 @@
-# flake8: noqa
-__version__ = "1.5.0dev11"