boneio 0.9.0.dev7__tar.gz → 0.9.0.dev8__tar.gz

{boneio-0.9.0.dev7 → boneio-0.9.0.dev8}/PKG-INFO

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

boneio-0.9.0.dev8/boneio/boards/0.8/input.yaml

@@ -0,0 +1,110 @@
+input_mapping:
+  in_01:
+    pin: P8_37
+    gpio_mode: gpio_pu
+  in_02:
+    pin: P8_38
+    gpio_mode: gpio_pu
+  in_03:
+    pin: P8_39
+  in_04:
+    pin: P8_40
+  in_05:
+    pin: P8_41
+  in_06:
+    pin: P8_42
+  in_07:
+    pin: P8_43
+  in_08:
+    pin: P8_44
+  in_09:
+    pin: P8_45
+  in_10:
+    pin: P8_46
+    gpio_mode: gpio_pu
+  in_11:
+    pin: P9_42
+  in_12:
+    pin: P9_31
+  in_13:
+    pin: P9_30
+  in_14:
+    pin: P9_29
+  in_15:
+    pin: P9_28
+  in_16:
+    pin: P9_27
+  in_17:
+    pin: P9_25
+  in_18:
+    pin: P9_23
+  in_19:
+    pin: P9_22
+    gpio_mode: gpio_pu
+  in_20:
+    pin: P9_21
+    gpio_mode: gpio_pu
+  in_21:
+    pin: P9_18
+  in_22:
+    pin: P9_17
+  in_23:
+    pin: P9_16
+  in_24:
+    pin: P9_15
+  in_25:
+    pin: P9_14
+  in_26:
+    pin: P8_7
+  in_27:
+    pin: P8_8
+  in_28:
+    pin: P8_9
+  in_29:
+    pin: P8_36
+    gpio_mode: gpio_pu
+  in_30:
+    pin: P8_35
+    gpio_mode: gpio_pu
+  in_31:
+    pin: P8_34
+    gpio_mode: gpio_pu
+  in_32:
+    pin: P8_33
+    gpio_mode: gpio_pu
+  in_33:
+    pin: P8_32
+    gpio_mode: gpio_pu
+  in_34:
+    pin: P8_31
+    gpio_mode: gpio_pu
+  in_35:
+    pin: P8_30
+  in_36:
+    pin: P8_29
+  in_37:
+    pin: P8_28
+  in_38:
+    pin: P8_27
+  in_39:
+    pin: P8_26
+  in_40:
+    pin: P8_19
+  in_41:
+    pin: P8_18
+  in_42:
+    pin: P8_17
+  in_43:
+    pin: P8_16
+  in_44:
+    pin: P8_15
+  in_45:
+    pin: P8_14
+  in_46:
+    pin: P8_13
+  in_47:
+    pin: P8_12
+  in_48:
+    pin: P8_11
+  in_49:
+    pin: P8_10

{boneio-0.9.0.dev7 → boneio-0.9.0.dev8}/boneio/helper/events.py

@@ -86,7 +86,15 @@ class EventBus:
         self._loop = loop or asyncio.get_event_loop()
         self._every_second_listeners = {}
         self._output_listeners = {}
-        self._event_listeners = {}
+        self._event_listeners = {
+            "input": {},
+            "output": {},
+            "modbus_sensor": {},
+            "sensor": {},
+            "host": {}
+        }
+        # Index to track listener_ids across all event types
+        self._listener_id_index = {}
         self._sigterm_listeners = []
         self._haonline_listeners = []
         self._timer_handle = _async_create_timer(
@@ -188,7 +196,7 @@ class EventBus:
         """Add sigterm listener."""
         self._sigterm_listeners.append(target)
 
-    def add_output_listener(self, output_id, listener_id, 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)
@@ -200,7 +208,7 @@ class EventBus:
             listener.set_target(target)
             return listener
         self._output_listeners[output_id][listener_id] = ListenerJob(target=target)
-        return self._output_listeners[output_id]
+        return self._output_listeners[output_id][listener_id]
 
     def remove_output_listener(self, output_id, listener_id):
         """Add output listener.
@@ -215,36 +223,80 @@ class EventBus:
         for listener in listeners.values():
             await listener.target(event)
 
-    def add_event_listener(self, event_type: str, entity_id: str, listener_id: str, target: Callable) -> ListenerJob:
-        """Add output listener.
+    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:
+        """Add event listener.
 
         listener_id is typically group_id for group outputs or ws (websocket)
         """
-        if event_type not in self._event_listeners:
-            self._event_listeners[event_type] = {}
+        if not target:
+            return
         if entity_id not in self._event_listeners[event_type]:
             self._event_listeners[event_type][entity_id] = {}
         if listener_id in self._event_listeners[event_type][entity_id]:
             listener = self._event_listeners[event_type][entity_id][listener_id]
             listener.set_target(target)
             return listener
-        self._event_listeners[event_type][entity_id][listener_id] = ListenerJob(target=target)
-        return self._event_listeners[event_type][entity_id][listener_id]
 
-    def remove_event_listener(self, event_type: str, entity_id: str, listener_id: str) -> None:
-        """Remove event listener."""
-        if event_type in self._event_listeners and entity_id in self._event_listeners[event_type] and listener_id in self._event_listeners[event_type][entity_id]:
-            del self._event_listeners[event_type][entity_id][listener_id]
-
-    def remove_event_listener_by_type(self, event_type: str) -> None:
-        """Remove event listener."""
-        if event_type in self._event_listeners:
-            del self._event_listeners[event_type]
-
-    async def async_trigger_event(self, event_type: str, entity_id: str, event: Any):
-        listeners = self._event_listeners.get(event_type, {}).get(entity_id, {})
-        for listener in listeners.values():
-            await listener.target(event)
+        # Add to main listeners
+        listener_job = ListenerJob(target=target)
+        self._event_listeners[event_type][entity_id][listener_id] = listener_job
+
+        # Add to index
+        if listener_id not in self._listener_id_index:
+            self._listener_id_index[listener_id] = []
+        self._listener_id_index[listener_id].append((event_type, entity_id))
+
+        return listener_job
+
+    def remove_event_listener(self, event_type: str = None, entity_id: str = None, listener_id: str = None) -> None:
+        """Remove event listener. Can remove by event_type, listener_id, or both."""
+        if listener_id and listener_id in self._listener_id_index:
+            # Remove by listener_id
+            for evt_type, ent_id in self._listener_id_index[listener_id]:
+                if event_type and evt_type != event_type:
+                    continue
+                if entity_id and ent_id != entity_id:
+                    continue
+                if ent_id in self._event_listeners[evt_type]:
+                    if listener_id in self._event_listeners[evt_type][ent_id]:
+                        del self._event_listeners[evt_type][ent_id][listener_id]
+                    if not self._event_listeners[evt_type][ent_id]:
+                        del self._event_listeners[evt_type][ent_id]
+            
+            if event_type is None and entity_id is None:
+                # If removing all references to this listener_id
+                del self._listener_id_index[listener_id]
+            else:
+                # Update index to remove only specific references
+                self._listener_id_index[listener_id] = [
+                    (evt_type, ent_id) 
+                    for evt_type, ent_id in self._listener_id_index[listener_id]
+                    if (event_type and evt_type != event_type) or (entity_id and ent_id != entity_id)
+                ]
+                if not self._listener_id_index[listener_id]:
+                    del self._listener_id_index[listener_id]
+
+        elif event_type:
+            # Remove by event_type
+            if entity_id:
+                # Remove specific entity
+                if entity_id in self._event_listeners[event_type]:
+                    for lid in list(self._event_listeners[event_type][entity_id].keys()):
+                        self.remove_event_listener(event_type, entity_id, lid)
+                    del self._event_listeners[event_type][entity_id]
+            else:
+                # Remove entire event_type
+                for ent_id in list(self._event_listeners[event_type].keys()):
+                    for lid in list(self._event_listeners[event_type][ent_id].keys()):
+                        self.remove_event_listener(event_type, ent_id, lid)
 
     def add_haonline_listener(self, target: Callable) -> None:
         """Add HA Online listener."""

{boneio-0.9.0.dev7 → boneio-0.9.0.dev8}/boneio/helper/gpio.py

@@ -194,7 +194,7 @@ class GpioBaseClass:
             timestamp=self.last_press_timestamp,
             boneio_input=self.boneio_input,
         )
-        await self._event_bus.async_trigger_event(event_type="input", entity_id=self._pin, event=event)
+        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
@@ -222,6 +222,10 @@ class GpioBaseClass:
         """Return configured pin."""
         return self._pin
 
+    @property
+    def id(self) -> str:
+        return self._pin
+
     @property
     def last_state(self) -> str:
         return self._last_state

{boneio-0.9.0.dev7 → boneio-0.9.0.dev8}/boneio/helper/ha_discovery.py

@@ -3,19 +3,19 @@ from boneio.const import (
     CLOSED,
     CLOSING,
     COVER,
+    DOUBLE,
     INPUT,
     INPUT_SENSOR,
+    LONG,
     OFF,
     ON,
     OPEN,
     OPENING,
     RELAY,
     SENSOR,
+    SINGLE,
     STATE,
     STOP,
-    SINGLE,
-    DOUBLE,
-    LONG
 )
 from boneio.version import __version__
 

{boneio-0.9.0.dev7 → boneio-0.9.0.dev8}/boneio/helper/loader.py

@@ -56,7 +56,10 @@ from boneio.helper import (
     ha_sensor_temp_availabilty_message,
 )
 from boneio.helper.events import EventBus
-from boneio.helper.ha_discovery import ha_cover_availabilty_message
+from boneio.helper.ha_discovery import (
+    ha_cover_availabilty_message,
+    ha_sensor_availabilty_message,
+)
 from boneio.helper.onewire import (
     DS2482,
     DS2482_ADDRESS,
@@ -67,12 +70,12 @@ from boneio.helper.onewire import (
 from boneio.helper.pcf8575 import PCF8575
 from boneio.helper.timeperiod import TimePeriod
 from boneio.input import GpioEventButtonNew, GpioEventButtonOld
-from boneio.models import OutputState
 from boneio.sensor import (
     DallasSensorDS2482,
     GpioInputBinarySensorNew,
     GpioInputBinarySensorOld,
 )
+from boneio.sensor.serial_number import SerialNumberSensor
 from boneio.sensor.temp.dallas import DallasSensorW1
 
 # Typing imports that create a circular dependency
@@ -166,6 +169,27 @@ def create_temp_sensor(
         pass
 
 
+def create_serial_number_sensor(
+    manager: Manager,
+    topic_prefix: str,
+):
+    """Create Serial number sensor in manager."""
+    sensor = SerialNumberSensor(
+        id="serial_number",
+        name="Serial number",
+        manager=manager,
+        send_message=manager.send_message,
+        topic_prefix=topic_prefix,
+    )
+    manager.send_ha_autodiscovery(
+        id="serial_number",
+        name="Serial number",
+        ha_type=SENSOR,
+        entity_category="diagnostic",
+        availability_msg_func=ha_sensor_availabilty_message,
+    )
+    return sensor
+
 expander_class = {MCP: MCP23017, PCA: PCA9685, PCF: PCF8575}
 
 
@@ -275,12 +299,11 @@ def configure_relay(
     topic_prefix: str,
     relay_id: str,
     name: str,
-    relay_callback: Callable,
     config: dict,
+    restore_state: bool = False,
     **kwargs,
 ) -> Any:
     """Configure kind of relay. Most common MCP."""
-    restore_state = config.pop(RESTORE_STATE, False)
     output_type = config.pop(OUTPUT_TYPE)
     restored_state = (
         state_manager.get(attr_type=RELAY, attr=relay_id, default_value=False)
@@ -342,13 +365,13 @@ def configure_relay(
         )
         return
 
-    # Create async callback wrapper
-    async def relay_callback_wrapper(event: OutputState):
-        await relay_callback(
-            expander_id=getattr(output, "expander_id"),
-            event=event,
-            restore_state=False if output_type == NONE else restore_state,
-        )
+    # # Create async callback wrapper
+    # async def relay_callback_wrapper(event: OutputState):
+    #     await relay_callback(
+    #         expander_id=expander_id,
+    #         event=event,
+    #         restore_state=False if output_type == NONE else restore_state,
+    #     )
 
     relay = getattr(output, "OutputClass")(
         send_message=manager.send_message,
@@ -359,7 +382,7 @@ def configure_relay(
         **config,
         **kwargs,
         **extra_args,
-        callback=relay_callback_wrapper,
+        # callback=relay_callback_wrapper,
     )
     manager.grouped_outputs[expander_id][relay_id] = relay
     return relay

{boneio-0.9.0.dev7 → boneio-0.9.0.dev8}/boneio/helper/stats.py

@@ -4,7 +4,6 @@ import asyncio
 import logging
 import socket
 import time
-from functools import partial
 from math import floor
 
 # Typing imports that create a circular dependency
@@ -28,7 +27,9 @@ from boneio.const import (
     SWAP,
     UPTIME,
 )
+from boneio.helper.events import EventBus
 from boneio.helper.gpio import GpioBaseClass
+from boneio.models import HostSensorState
 
 if TYPE_CHECKING:
     from boneio.manager import Manager
@@ -124,8 +125,8 @@ class HostSensor(AsyncUpdater):
 
     def __init__(
         self,
+        event_bus: EventBus,
         update_function: Callable,
-        manager_callback: Callable,
         static_data: dict | None,
         id: str,
         type: str,
@@ -135,16 +136,21 @@ class HostSensor(AsyncUpdater):
         self._static_data = static_data
         self._state = {}
         self._type = type
-        self._manager_callback = manager_callback
+        self._event_bus = event_bus
         self._loop = asyncio.get_event_loop()
         self.id = id
         super().__init__(**kwargs)
+        self._loop.create_task(self.async_update(time.time()))
 
     async def async_update(self, timestamp: float) -> None:
         self._state = self._update_function()
-        self._loop.call_soon_threadsafe(
-            partial(self._manager_callback, self._type)
+        sensor_state = HostSensorState(
+            id=self.id,
+            name=self._type,
+            state="new_state", #doesn't matter here, as we fetch everything in Oled.
+            timestamp=timestamp,
         )
+        await self._event_bus.async_trigger_event(event_type="host", entity_id=self.id, event=sensor_state)
 
     @property
     def state(self) -> dict:
@@ -160,14 +166,15 @@ class HostData:
         self,
         output: dict,
         inputs: dict[str, GpioBaseClass],
-        callback: Callable,
         temp_sensor: Callable[[LM75Sensor, MCP9808Sensor], None] | None,
         ina219: INA219Class | None,
         manager: Manager,
+        event_bus: EventBus,
         enabled_screens: List[str],
         extra_sensors: List[dict],
     ) -> None:
         """Initialize HostData."""
+        self._manager = manager
         self._hostname = socket.gethostname()
         self._temp_sensor = temp_sensor
         host_stats = {
@@ -293,8 +300,8 @@ class HostData:
             self._data[k] = HostSensor(
                 update_function=_v["f"],
                 static_data=_v.get("static"),
+                event_bus=event_bus,
                 manager=manager,
-                manager_callback=callback,
                 id=f"{k}_hoststats",
                 type=k,
                 update_interval=_v["update_interval"],
@@ -306,31 +313,44 @@ class HostData:
             ]
             for i in range((len(inputs) + 24) // 25)
         }
-        self._callback = callback
         self._loop = asyncio.get_running_loop()
 
+    def web_url(self) -> str | None:
+        if not self._manager.is_web_on:
+            return None
+        network_state = self._data[NETWORK].state
+        if IP in network_state:
+            return f"http://{network_state[IP]}:{self._manager.web_bind_port}"
+        return None
+
     def get(self, type: str) -> dict:
         """Get saved stats."""
         if type in self._output:
             return self._get_output(type)
         if type in self._inputs:
             return self._get_input(type)
+        if type == "web":
+            return self.web_url()
         return self._data[type].state
 
     def _get_output(self, type: str) -> dict:
         """Get stats for output."""
         out = {}
         for output in self._output[type].values():
-            out[output.id] = output.state
+            out[output.id] = {
+                "name": output.name, "state": output.state
+            }
+
         return out
 
     def _get_input(self, type: str) -> dict:
         """Get stats for input."""
         inputs = {}
         for input in self._inputs[type]:
-            inputs[input.name] = (
-                input.pressed_state[0].upper() if input.pressed_state else ""
-            )
+            inputs[input.id] = {
+                "name": input.name,
+                "state": input.last_state[0].upper() if input.last_state and input.last_state != "Unknown" else ""
+            }
         return inputs
 
     @property