boneIO 0.12.0__tar.gz → 0.12.0.dev2__tar.gz

{boneio-0.12.0 → boneio-0.12.0.dev2}/PKG-INFO

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

{boneio-0.12.0 → boneio-0.12.0.dev2}/boneio/cover/cover.py

@@ -172,10 +172,13 @@ class BaseCover(BaseCoverABC, BasicMqtt):
 
         self._event_bus.add_sigterm_listener(self.on_exit)
 
+        def _schedule_send_state_task(state_to_send, json_pos_to_send):
+            asyncio.ensure_future(self.send_state(state_to_send, json_pos_to_send), loop=self._loop)
+
         self._loop.call_soon_threadsafe(
             self._loop.call_later,
             0.5,
-            self.send_state,
+            _schedule_send_state_task,
             self.state,
             self.json_position
         )
@@ -192,7 +195,7 @@ class BaseCover(BaseCoverABC, BasicMqtt):
             self._close_relay.turn_off()
             self._current_operation = IDLE
             if not on_exit:
-                self.send_state(self.state, self.json_position)
+                await self.send_state(self.state, self.json_position)
 
     async def open(self) -> None:
         if self._position >= 100:
@@ -267,7 +270,7 @@ class BaseCover(BaseCoverABC, BasicMqtt):
     def last_timestamp(self) -> float:
         return self._last_timestamp
 
-    def send_state(self, state: str, json_position: PositionDict = None) -> None:
+    async def send_state(self, state: str, json_position: PositionDict = None) -> None:
         event = CoverState(
             id=self.id,
             name=self.name,
@@ -277,14 +280,10 @@ class BaseCover(BaseCoverABC, BasicMqtt):
             current_operation=self._current_operation,
             **json_position
         )
-        self._event_bus.trigger_event({
-            "event_type": "cover", 
-            "entity_id": self.id, 
-            "event_state": event
-        })
+        await self._event_bus.async_trigger_event(event_type="cover", entity_id=self.id, event=event)
         self._message_bus.send_message(topic=f"{self._send_topic}/state", payload=state)
         self._message_bus.send_message(topic=f"{self._send_topic}/pos", payload=json_position)
 
-    def send_state_and_save(self, json_position: PositionDict):
-        self.send_state(self.state, json_position)
+    async def send_state_and_save(self, json_position: PositionDict):
+        await self.send_state(self.state, json_position)
         self._state_save(json_position)

{boneio-0.12.0 → boneio-0.12.0.dev2}/boneio/cover/previous.py

@@ -146,7 +146,7 @@ class PreviousCover(BasicMqtt):
             timestamp=self.last_timestamp,
             current_operation=self._current_operation,
         )
-        self._event_bus.trigger_event({"event_type": "cover", "entity_id": self.id, "event_state": event})
+        await self._event_bus.async_trigger_event(event_type="cover", entity_id=self.id, event=event)
 
     def send_state(self) -> None:
         """Send state of cover to mqtt."""

{boneio-0.12.0 → boneio-0.12.0.dev2}/boneio/cover/time_based.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import logging
 import threading
 import time
@@ -53,7 +54,7 @@ class TimeBasedCover(BaseCover):
 
         if total_steps == 0 or duration == 0:
             self._current_operation = IDLE
-            self._loop.call_soon_threadsafe(self.send_state(self.state, self.json_position))
+            self._loop.call_soon_threadsafe(asyncio.run_coroutine_threadsafe, self.send_state(self.state, self.json_position), self._loop)
             return
 
         relay.turn_on()
@@ -71,7 +72,7 @@ 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(self.send_state(self.state, self.json_position))
+                self._loop.call_soon_threadsafe(asyncio.run_coroutine_threadsafe, self.send_state(self.state, self.json_position), self._loop)
                 self._last_update_time = current_time
 
             if target_position is not None:
@@ -85,7 +86,8 @@ class TimeBasedCover(BaseCover):
             time.sleep(0.05)  # Małe opóźnienie, aby nie blokować CPU
         relay.turn_off()
         self._current_operation = IDLE
-        self._loop.call_soon_threadsafe(self.send_state_and_save(self.json_position))
+        self._loop.call_soon_threadsafe(asyncio.run_coroutine_threadsafe, self.async_state_save(self.json_position), self._loop)
+        self._loop.call_soon_threadsafe(asyncio.run_coroutine_threadsafe, self.send_state(self.state, self.json_position), self._loop)
         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: Optional[int] = None) -> None:

{boneio-0.12.0 → boneio-0.12.0.dev2}/boneio/cover/venetian.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import logging
 import threading
 import time
@@ -88,7 +89,9 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         if total_steps == 0 or duration == 0:
             self._current_operation = IDLE
             self._loop.call_soon_threadsafe(
-                self.send_state, self.state, self.json_position
+                asyncio.run_coroutine_threadsafe,
+                self.send_state(self.state, self.json_position),
+                self._loop,
             )
             return
 
@@ -143,7 +146,9 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
             self._last_timestamp = current_time  # Użyj pobranego czasu
             if current_time - self._last_update_time >= 1:
                 self._loop.call_soon_threadsafe(
-                    self.send_state, self.state, self.json_position
+                    asyncio.run_coroutine_threadsafe,
+                    self.send_state(self.state, self.json_position),
+                    self._loop,
                 )
                 self._last_update_time = current_time
 
@@ -171,7 +176,9 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         relay.turn_off()
         self._current_operation = IDLE
         self._loop.call_soon_threadsafe(
-            self.send_state_and_save, self.json_position
+            asyncio.run_coroutine_threadsafe,
+            self.send_state_and_save(self.json_position),
+            self._loop,
         )
         self._last_update_time = (
             time.monotonic()

{boneio-0.12.0 → boneio-0.12.0.dev2}/boneio/example_config/24x16/output24x16A.yaml

@@ -1,4 +1,4 @@
-# config to Relay board 24x16 v0.4
+# config to Relay board 32x10 v0.4
 - id: OUT_01
   boneio_output: OUT_01
   output_type: switch

{boneio-0.12.0 → boneio-0.12.0.dev2}/boneio/group/output.py

@@ -35,9 +35,8 @@ class OutputGroup(BasicRelay):
         self.check_state()
 
         for member in self._group_members:
-            self._event_bus.add_event_listener(
-                event_type="output",
-                entity_id=member.id,
+            self._event_bus.add_output_listener(
+                output_id=member.id,
                 listener_id=self.id,
                 target=self.event_listener,
             )

{boneio-0.12.0 → boneio-0.12.0.dev2}/boneio/helper/events.py

@@ -6,6 +6,7 @@ from datetime import datetime
 from typing import Any, Callable, Coroutine, List, Optional
 
 from boneio.helper.util import callback
+from boneio.models import OutputState
 
 _LOGGER = logging.getLogger(__name__)
 UTC = dt.timezone.utc
@@ -78,30 +79,23 @@ class ListenerJob:
 
 
 class EventBus:
-    """
-    Simple event bus with async queue for multiple event types.
-    Obsługuje wiele typów eventów oraz asynchroniczne kolejkowanie i dispatching.
-    """
+    """Simple event bus which ticks every second."""
 
-    def __init__(self, loop: asyncio.AbstractEventLoop = None) -> None:
-        """
-        Initialize the event bus.
-        :param loop: asyncio event loop
-        """
+    def __init__(self, loop: asyncio.AbstractEventLoop) -> None:
+        """Initialize handler"""
         self._loop = loop or asyncio.get_event_loop()
-        self._event_queue = asyncio.Queue()
+        self._every_second_listeners = {}
+        self._output_listeners = {}
         self._event_listeners = {
             "input": {},
             "output": {},
             "cover": {},
-            "modbus_device": {},
+            "modbus_sensor": {},
             "sensor": {},
             "host": {}
         }
+        # Index to track listener_ids across all event types
         self._listener_id_index = {}
-        self._worker_task = None
-        self._every_second_listeners = {}
-        self._shutting_down = False
         self._sigterm_listeners = []
         self._haonline_listeners = []
         self._timer_handle = _async_create_timer(
@@ -111,84 +105,37 @@ class EventBus:
         self._monitor_task = None
 
     async def start(self):
-        """
-        Start the event bus worker.
-        """
-        if self._worker_task is not None:
-            _LOGGER.warning("Event bus worker already started.")
-            return
-        self._worker_task = asyncio.create_task(self._event_worker())
-        _LOGGER.info("Event bus worker started.")
-
-    async def _event_worker(self):
-        """
-        Background task to process events from the queue.
-        """
-        while not self._shutting_down:
-            try:
-                event = await self._event_queue.get()
-            except asyncio.CancelledError:
-                _LOGGER.info("Event bus worker cancelled.")
-                await self.stop()
-                raise
-            try:
-                await self._handle_event(event)
-            except Exception as exc:
-                _LOGGER.error(f"Error handling event: {exc}")
-            finally:
-                self._event_queue.task_done()
-
-    async def _handle_event(self, event: dict):
-        """
-        Dispatch event to registered listeners.
-        :param event: dict or object with at least 'event_type' field
-        """
-        event_type = event.get('event_type')
-        event_state = event.get('event_state')
-        entity_id = event.get('entity_id')
-        if not event_type or event_type not in self._event_listeners:
-            _LOGGER.warning(f"Unknown event_type: {event_type}")
-            return
-        if not entity_id:
-            _LOGGER.warning(f"Unknown entity_id: {entity_id}")
-            return
-        entity_id_listeners = self._event_listeners.get(event_type, {}).get(entity_id, {})
-        for listener in entity_id_listeners.values():
-            try:
-                await listener.target(event_state)
-            except Exception as exc:
-                _LOGGER.error(f"Listener error: {exc}")
-
-    def trigger_event(self, event):
-        """
-        Put event into the queue for async processing.
-        :param event: dict or object with at least 'event_type' field
-        """
-        self._event_queue.put_nowait(event)
+        """Start the event bus monitor."""
+        self._monitor_task = asyncio.create_task(self._monitor_loop())
+
+    async def _monitor_loop(self):
+        """Monitor loop that can be cancelled for cleanup."""
+        try:
+            while True:
+                await asyncio.sleep(1)
+        except asyncio.CancelledError:
+            _LOGGER.info("Monitor loop cancelled, cleaning up...")
+            await self.ask_stop()
+            raise
 
     def request_stop(self):
         """Request the event bus to stop."""
-        if self._worker_task and not self._shutting_down:
+        if self._monitor_task and not self._shutting_down:
             self._shutting_down = True
-            self._worker_task.cancel()
+            self._monitor_task.cancel()
 
-    async def stop(self):
-        """
-        Stop the event bus and worker task gracefully.
-        """
+    async def ask_stop(self):
+        """Function to call on restart. Should invoke all sigterm listeners."""
         if self._shutting_down:
             return
         self._shutting_down = True
+        self._every_second_listeners = {}
+        self._output_listeners = {}
+        
         await self._handle_sigterm_listeners()
         for listener in self._every_second_listeners.values():
-            listener.target(None)
-        if self._worker_task:
-            self._worker_task.cancel()
-            try:
-                await self._worker_task
-            except asyncio.CancelledError:
-                _LOGGER.info("Event bus worker cancelled.")
-        _LOGGER.info("Shutdown EventBus gracefully.")
+            listener.target()
+        _LOGGER.info("Shutdown Eventbus gracefully.")
 
     def _run_second_event(self, time):
         """Run event every second."""
@@ -238,6 +185,9 @@ class EventBus:
         exit_task = self._loop.create_task(cleanup_and_exit())
         exit_task.add_done_callback(task_done_callback)
         
+        
+
+
     def add_every_second_listener(self, name, target):
         """Add listener on every second job."""
         self._every_second_listeners[name] = ListenerJob(target=target)
@@ -247,6 +197,39 @@ class EventBus:
         """Add sigterm listener."""
         self._sigterm_listeners.append(target)
 
+    def add_output_listener(self, output_id, listener_id, target) -> ListenerJob:
+        """Add output listener.
+
+        listener_id is typically group_id for group outputs or ws (websocket)
+        """
+        if output_id not in self._output_listeners:
+            self._output_listeners[output_id] = {}
+        if listener_id in self._output_listeners[output_id]:
+            listener = self._output_listeners[output_id][listener_id]
+            listener.set_target(target)
+            return listener
+        self._output_listeners[output_id][listener_id] = ListenerJob(target=target)
+        return self._output_listeners[output_id][listener_id]
+
+    def remove_output_listener(self, output_id, listener_id):
+        """Add output listener.
+
+        listener_id is typically group_id for group outputs or ws (websocket)
+        """
+        if output_id in self._output_listeners and listener_id in self._output_listeners[output_id]:
+            del self._output_listeners[output_id][listener_id]
+
+    async def async_trigger_output_event(self, output_id: str, event: OutputState):
+        listeners = self._output_listeners.get(output_id, {})
+        for listener in listeners.values():
+            await listener.target(event)
+
+    async def async_trigger_event(self, event_type: str, entity_id: str, event: Any):
+        """Trigger event for all listeners of given type and entity."""
+        listeners = self._event_listeners.get(event_type, {}).get(entity_id, {})
+        for listener in listeners.values():
+            await listener.target(event)
+
     def add_event_listener(
         self, event_type: str, entity_id: str, listener_id: str, target
     ) -> ListenerJob:

{boneio-0.12.0 → boneio-0.12.0.dev2}/boneio/helper/gpio.py

@@ -121,7 +121,7 @@ class GpioBaseClass:
     def __init__(
         self,
         pin: str,
-        manager_press_callback: Callable[
+        press_callback: Callable[
             [ClickTypes, GpioBaseClass, str, bool, float | None],
             Awaitable[None],
         ],
@@ -141,7 +141,7 @@ class GpioBaseClass:
         )
         self._bounce_time = bounce_time.total_in_seconds
         self._loop = asyncio.get_running_loop()
-        self._manager_press_callback = manager_press_callback
+        self._press_callback = press_callback
         self._name = name
         setup_input(pin=self._pin, pull_mode=gpio_mode)
         self._actions = actions
@@ -153,62 +153,52 @@ class GpioBaseClass:
         self._last_state = "Unknown"
         self._last_timestamp = 0.0
         self._event_bus = event_bus
-        self._event_lock = asyncio.Lock()
 
     @property
     def boneio_input(self) -> str:
         return self._boneio_input or ""
 
     def press_callback(
-        self, click_type: ClickTypes, duration: float | None = None, start_time: float | None = None
+        self, click_type: ClickTypes, duration: float | None = None
     ) -> None:
         """Handle press callback."""
-        asyncio.run_coroutine_threadsafe(self._handle_press_with_lock(click_type, duration, start_time), self._loop)
-        
-        
-    async def _handle_press_with_lock(self, click_type: ClickTypes, duration: float | None = None, start_time: float | None = None):
-        """Handle press event with a lock to ensure sequential execution."""
-        now = time.time()
+        self._last_timestamp = time.time()
         _LOGGER.debug(
-            "[%s] Attempting to acquire lock for event '%s'. Duration: %s", self.name, click_type, now - start_time
+            "Press callback: %s on pin %s - %s at %s",
+            click_type,
+            self._pin,
+            self.name,
+            self._last_timestamp,
         )
-        async with self._event_lock:
-            _LOGGER.debug(
-                "[%s] Acquired lock for event '%s'. Processing...",
-                self.name,
+        self._last_state = click_type
+        self._loop.create_task(
+            self.async_press_callback(
                 click_type,
-            )
-            self._last_timestamp = time.time()
-            _LOGGER.debug(
-                "Press callback: %s on pin %s - %s. Duration: %s",
-                click_type,
-                self._pin,
-                self.name,
-                self._last_timestamp - start_time,
-            )
-            self._last_state = click_type
-            await self._manager_press_callback(
-                click_type,
-                self,
-                self._empty_message_after,
                 duration,
-                start_time,
-            )
-            event = InputState(
-                name=self.name,
-                pin=self._pin,
-                state=self.last_state,
-                type=self.input_type,
-                timestamp=self.last_press_timestamp,
-                boneio_input=self.boneio_input,
             )
-            self._event_bus.trigger_event({
-                "event_type": "input", 
-                "entity_id": self.id, 
-                "event_state": event
-            })
-        _LOGGER.debug("[%s] Released lock for event '%s'", self.name, click_type)
+        )
 
+    async def async_press_callback(
+        self,
+        click_type: ClickTypes,
+        duration: float | None = None,
+    ) -> None:
+
+        await self._press_callback(
+            click_type,
+            self,
+            self._empty_message_after,
+            duration,
+        )
+        event = InputState(
+            name=self.name,
+            pin=self._pin,
+            state=self.last_state,
+            type=self.input_type,
+            timestamp=self.last_press_timestamp,
+            boneio_input=self.boneio_input,
+        )
+        await self._event_bus.async_trigger_event(event_type="input", entity_id=self.id, event=event)
 
     def set_actions(self, actions: dict) -> None:
         self._actions = actions

{boneio-0.12.0 → boneio-0.12.0.dev2}/boneio/helper/loader.py

@@ -9,6 +9,7 @@ from adafruit_mcp230xx.mcp23017 import MCP23017
 from adafruit_pca9685 import PCA9685
 
 from boneio.const import (
+    ACTIONS,
     ADDRESS,
     BINARY_SENSOR,
     COVER,
@@ -447,11 +448,10 @@ def configure_relay(
 def configure_event_sensor(
     gpio: dict,
     pin: str,
-    manager_press_callback: Callable,
+    press_callback: Callable,
     event_bus: EventBus,
     send_ha_autodiscovery: Callable,
     input: GpioEventButtonOld | GpioEventButtonNew | GpioInputBinarySensorOld | GpioInputBinarySensorNew | None = None,
-    actions: dict = {},
 ) -> GpioEventButtonOld | GpioEventButtonNew | None:
     """Configure input sensor or button."""
     try:
@@ -467,15 +467,15 @@ def configure_event_sensor(
                     "You reconfigured type of input. It's forbidden. Please restart boneIO."
                 )
                 return input
-            input.set_actions(actions=actions)
+            input.set_actions(actions=gpio.get(ACTIONS, {}))
         else:
             input = gpioEventButtonClass(
                 pin=pin,
                 name=name,
                 input_type=INPUT,
                 empty_message_after=gpio.pop("clear_message", False),
-                actions=actions,
-                manager_press_callback=manager_press_callback,
+                actions=gpio.pop(ACTIONS, {}),
+                press_callback=press_callback,
                 event_bus=event_bus,
                 **gpio,
             )
@@ -496,11 +496,10 @@ def configure_event_sensor(
 def configure_binary_sensor(
     gpio: dict,
     pin: str,
-    manager_press_callback: Callable,
+    press_callback: Callable,
     event_bus: EventBus,
     send_ha_autodiscovery: Callable,
     input: GpioEventButtonOld | GpioEventButtonNew | GpioInputBinarySensorOld | GpioInputBinarySensorNew | None = None,
-    actions: dict = {},
 ) -> GpioInputBinarySensorOld | GpioInputBinarySensorNew | None:
     """Configure input sensor or button."""
     try:
@@ -516,15 +515,15 @@ def configure_binary_sensor(
                     "You preconfigured type of input. It's forbidden. Please restart boneIO."
                 )
                 return input
-            input.set_actions(actions=actions)
+            input.set_actions(actions=gpio.get(ACTIONS, {}))
         else:
             input = GpioInputBinarySensorClass(
                 pin=pin,
                 name=name,
-                actions=actions,
+                actions=gpio.pop(ACTIONS, {}),
                 input_type=INPUT_SENSOR,
                 empty_message_after=gpio.pop("clear_message", False),
-                manager_press_callback=manager_press_callback,
+                press_callback=press_callback,
                 event_bus=event_bus,
                 **gpio,
             )