boneIO 0.12.0.dev2__tar.gz → 0.12.1.dev1__tar.gz

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

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

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

@@ -172,13 +172,10 @@ 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,
-            _schedule_send_state_task,
+            self.send_state,
             self.state,
             self.json_position
         )
@@ -195,16 +192,16 @@ class BaseCover(BaseCoverABC, BasicMqtt):
             self._close_relay.turn_off()
             self._current_operation = IDLE
             if not on_exit:
-                await self.send_state(self.state, self.json_position)
+                self.send_state(self.state, self.json_position)
 
-    async def open(self) -> None:
+    async def open(self, **kwargs) -> None:
         if self._position >= 100:
             return
         _LOGGER.info("Opening cover %s.", self._id)
         await self.run_cover(current_operation=OPENING)
         self._message_bus.send_message(topic=f"{self._send_topic}/state", payload=OPENING)
 
-    async def close(self) -> None:
+    async def close(self, **kwargs) -> None:
         if self._position <= 0:
             return
         _LOGGER.info("Closing cover %s.", self._id)
@@ -223,21 +220,21 @@ class BaseCover(BaseCoverABC, BasicMqtt):
         elif position < self._position:
             await self.run_cover(current_operation=CLOSING, target_position=position)
 
-    async def toggle(self) -> None:
+    async def toggle(self, **kwargs) -> None:
         _LOGGER.debug("Toggle cover %s from input.", self._id)
         if self._position > 50:
             await self.close()
         else:
             await self.open()
 
-    async def toggle_open(self) -> None:
+    async def toggle_open(self, **kwargs) -> None:
         _LOGGER.debug("Toggle open cover %s from input.", self._id)
         if self._current_operation != IDLE:
             await self.stop()
         else:
             await self.open()
 
-    async def toggle_close(self) -> None:
+    async def toggle_close(self, **kwargs) -> None:
         _LOGGER.debug("Toggle close cover %s from input.", self._id)
         if self._current_operation != IDLE:
             await self.stop()
@@ -270,7 +267,7 @@ class BaseCover(BaseCoverABC, BasicMqtt):
     def last_timestamp(self) -> float:
         return self._last_timestamp
 
-    async def send_state(self, state: str, json_position: PositionDict = None) -> None:
+    def send_state(self, state: str, json_position: PositionDict = None) -> None:
         event = CoverState(
             id=self.id,
             name=self.name,
@@ -280,10 +277,14 @@ class BaseCover(BaseCoverABC, BasicMqtt):
             current_operation=self._current_operation,
             **json_position
         )
-        await self._event_bus.async_trigger_event(event_type="cover", entity_id=self.id, event=event)
+        self._event_bus.trigger_event({
+            "event_type": "cover", 
+            "entity_id": self.id, 
+            "event_state": 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)
 
-    async def send_state_and_save(self, json_position: PositionDict):
-        await self.send_state(self.state, json_position)
+    def send_state_and_save(self, json_position: PositionDict):
+        self.send_state(self.state, json_position)
         self._state_save(json_position)

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

@@ -146,7 +146,7 @@ class PreviousCover(BasicMqtt):
             timestamp=self.last_timestamp,
             current_operation=self._current_operation,
         )
-        await self._event_bus.async_trigger_event(event_type="cover", entity_id=self.id, event=event)
+        self._event_bus.trigger_event({"event_type": "cover", "entity_id": self.id, "event_state": event})
 
     def send_state(self) -> None:
         """Send state of cover to mqtt."""
@@ -283,14 +283,14 @@ class PreviousCover(BasicMqtt):
         else:
             await self.open()
 
-    async def toggle_open(self) -> None:
+    async def toggle_open(self, **kwargs) -> None:
         _LOGGER.debug("Toggle open cover %s from input.", self._id)
         if self._current_operation != IDLE:
             await self.stop()
         else:
             await self.open()
 
-    async def toggle_close(self) -> None:
+    async def toggle_close(self, **kwargs) -> None:
         _LOGGER.debug("Toggle close cover %s from input.", self._id)
         if self._current_operation != IDLE:
             await self.stop()

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

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import asyncio
 import logging
 import threading
 import time
@@ -54,7 +53,7 @@ class TimeBasedCover(BaseCover):
 
         if total_steps == 0 or duration == 0:
             self._current_operation = IDLE
-            self._loop.call_soon_threadsafe(asyncio.run_coroutine_threadsafe, self.send_state(self.state, self.json_position), self._loop)
+            self._loop.call_soon_threadsafe(self.send_state(self.state, self.json_position))
             return
 
         relay.turn_on()
@@ -72,7 +71,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(asyncio.run_coroutine_threadsafe, self.send_state(self.state, self.json_position), self._loop)
+                self._loop.call_soon_threadsafe(self.send_state(self.state, self.json_position))
                 self._last_update_time = current_time
 
             if target_position is not None:
@@ -86,8 +85,7 @@ 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(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._loop.call_soon_threadsafe(self.send_state_and_save(self.json_position))
         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.dev2 → boneio-0.12.1.dev1}/boneio/cover/venetian.py

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

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

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

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

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

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

@@ -6,7 +6,6 @@ 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
@@ -79,23 +78,30 @@ class ListenerJob:
 
 
 class EventBus:
-    """Simple event bus which ticks every second."""
+    """
+    Simple event bus with async queue for multiple event types.
+    Obsługuje wiele typów eventów oraz asynchroniczne kolejkowanie i dispatching.
+    """
 
-    def __init__(self, loop: asyncio.AbstractEventLoop) -> None:
-        """Initialize handler"""
+    def __init__(self, loop: asyncio.AbstractEventLoop = None) -> None:
+        """
+        Initialize the event bus.
+        :param loop: asyncio event loop
+        """
         self._loop = loop or asyncio.get_event_loop()
-        self._every_second_listeners = {}
-        self._output_listeners = {}
+        self._event_queue = asyncio.Queue()
         self._event_listeners = {
             "input": {},
             "output": {},
             "cover": {},
-            "modbus_sensor": {},
+            "modbus_device": {},
             "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(
@@ -105,37 +111,84 @@ class EventBus:
         self._monitor_task = None
 
     async def start(self):
-        """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
+        """
+        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)
 
     def request_stop(self):
         """Request the event bus to stop."""
-        if self._monitor_task and not self._shutting_down:
+        if self._worker_task and not self._shutting_down:
             self._shutting_down = True
-            self._monitor_task.cancel()
+            self._worker_task.cancel()
 
-    async def ask_stop(self):
-        """Function to call on restart. Should invoke all sigterm listeners."""
+    async def stop(self):
+        """
+        Stop the event bus and worker task gracefully.
+        """
         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()
-        _LOGGER.info("Shutdown Eventbus gracefully.")
+            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.")
 
     def _run_second_event(self, time):
         """Run event every second."""
@@ -185,9 +238,6 @@ 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)
@@ -197,39 +247,6 @@ 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.dev2 → boneio-0.12.1.dev1}/boneio/helper/gpio.py

@@ -121,7 +121,7 @@ class GpioBaseClass:
     def __init__(
         self,
         pin: str,
-        press_callback: Callable[
+        manager_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._press_callback = press_callback
+        self._manager_press_callback = manager_press_callback
         self._name = name
         setup_input(pin=self._pin, pull_mode=gpio_mode)
         self._actions = actions
@@ -153,57 +153,69 @@ 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
+        self, click_type: ClickTypes, duration: float | None = None, start_time: float | None = None
     ) -> None:
         """Handle press callback."""
-        self._last_timestamp = time.time()
+        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()
         _LOGGER.debug(
-            "Press callback: %s on pin %s - %s at %s",
-            click_type,
-            self._pin,
-            self.name,
-            self._last_timestamp,
+            "[%s] Attempting to acquire lock for event '%s'. Duration: %s", self.name, click_type, now - start_time
         )
-        self._last_state = click_type
-        self._loop.create_task(
-            self.async_press_callback(
+        async with self._event_lock:
+            _LOGGER.debug(
+                "[%s] Acquired lock for event '%s'. Processing...",
+                self.name,
                 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,
             )
-        )
-
-    async def async_press_callback(
-        self,
-        click_type: ClickTypes,
-        duration: float | None = None,
-    ) -> None:
+            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)
 
-        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:
+        print("SETTING ACTIONS", actions)
         self._actions = actions
 
     def get_actions_of_click(self, click_type: ClickTypes) -> dict:
+        print("actiong of click", self._actions)
         return self._actions.get(click_type, [])
 
     @property

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

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