boneIO 0.9.0.dev7__py3-none-any.whl → 0.9.0.dev9__py3-none-any.whl

boneio/boards/0.7/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/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/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/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/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/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

boneio/manager.py

@@ -29,6 +29,7 @@ from boneio.const import (
     MODBUS,
     MQTT,
     NONE,
+    ON,
     ONEWIRE,
     ONLINE,
     OPEN,
@@ -37,6 +38,7 @@ from boneio.const import (
     PCF,
     PIN,
     RELAY,
+    RESTORE_STATE,
     SET_BRIGHTNESS,
     STATE,
     STOP,
@@ -69,6 +71,7 @@ from boneio.helper.loader import (
     configure_relay,
     create_dallas_sensor,
     create_expander,
+    create_serial_number_sensor,
     create_temp_sensor,
 )
 from boneio.helper.logger import configure_logger
@@ -122,6 +125,8 @@ class Manager:
         self._config_file_path = config_file_path
         self._state_manager = state_manager
         self._event_bus = event_bus
+        self._is_web_on = False
+        self._web_bind_port = None
 
         self.send_message = send_message
         self._mqtt_state = mqtt_state
@@ -147,7 +152,7 @@ class Manager:
 
         self._configure_temp_sensors(sensors=sensors)
 
-        self._modbus_sensors = self._configure_modbus_sensors(sensors=sensors)
+        self._modbus_sensors = {}
         self._configure_ina219_sensors(sensors=sensors)
         self._configure_sensors(
             dallas=dallas, ds2482=ds2482, sensors=sensors.get(ONEWIRE)
@@ -180,19 +185,26 @@ class Manager:
 
         for _config in relay_pins:
             _name = _config.pop(ID)
+            restore_state = _config.pop(RESTORE_STATE, False)
             _id = strip_accents(_name)
             out = configure_relay(
                 manager=self,
                 state_manager=self._state_manager,
                 topic_prefix=self._config_helper.topic_prefix,
                 name=_name,
+                restore_state=restore_state,
                 relay_id=_id,
-                relay_callback=self._relay_callback,
                 config=_config,
                 event_bus=self._event_bus,
             )
             if not out:
                 continue
+            if restore_state:
+                self._event_bus.add_output_listener(
+                    output_id=out.id,
+                    listener_id="manager",
+                    target=self._relay_callback,
+                )
             self._outputs[_id] = out
             if out.output_type not in (NONE, COVER):
                 self.send_ha_autodiscovery(
@@ -253,6 +265,11 @@ class Manager:
         _LOGGER.info("Initializing inputs. This will take a while.")
         self.configure_inputs(reload_config=False)
 
+        self._serial_number_sensor = create_serial_number_sensor(
+            manager=self,
+            topic_prefix=self._config_helper.topic_prefix)
+        self._modbus_sensors = self._configure_modbus_sensors(sensors=sensors)
+
         if oled.get("enabled", False):
             from boneio.oled import Oled
 
@@ -261,6 +278,7 @@ class Manager:
 
             self._host_data = HostData(
                 manager=self,
+                event_bus=self._event_bus,
                 enabled_screens=self._screens,
                 output=self.grouped_outputs,
                 inputs=self._inputs,
@@ -271,7 +289,6 @@ class Manager:
                     self._ina219_sensors[0] if self._ina219_sensors else None
                 ),
                 extra_sensors=extra_sensors,
-                callback=self._host_data_callback,
             )
             try:
                 self._oled = Oled(
@@ -279,12 +296,28 @@ class Manager:
                     screen_order=self._screens,
                     grouped_outputs=list(self.grouped_outputs),
                     sleep_timeout=oled.get("screensaver_timeout", 60),
+                    event_bus=self._event_bus,
                 )
             except (GPIOInputException, I2CError) as err:
                 _LOGGER.error("Can't configure OLED display. %s", err)
+            finally:
+                if self._oled:
+                    self._oled.render_display()
         self.prepare_ha_buttons()
         _LOGGER.info("BoneIO manager is ready.")
 
+    def set_web_server_status(self, status: bool, bind: int):
+        self._is_web_on = status
+        self._web_bind_port = bind
+
+    @property
+    def is_web_on(self) -> bool:
+        return self._is_web_on
+
+    @property
+    def web_bind_port(self) -> int | None:
+        return self._web_bind_port
+
     @property
     def mqtt_state(self) -> bool:
         return self._mqtt_state()
@@ -321,7 +354,7 @@ class Manager:
         for group in self._outputs_group:
             members = get_outputs(group.pop("outputs"))
             if not members:
-                _LOGGER.warn(
+                _LOGGER.warning(
                     "This group %s doesn't have any valid members. Not adding it.",
                     group[ID],
                 )
@@ -592,19 +625,13 @@ class Manager:
     async def _relay_callback(
         self,
         event: OutputState,
-        restore_state: bool,
-        save_host_data: bool = True,
-        expander_id: str | None = None,
     ) -> None:
         """Relay callback function."""
-        if restore_state:
-            self._state_manager.save_attribute(
-                attr_type=RELAY,
-                attribute=event.id,
-                value=self._outputs[event.id].is_active,
-            )
-        if save_host_data and expander_id:
-            self._host_data_callback(type=expander_id)
+        self._state_manager.save_attribute(
+            attr_type=RELAY,
+            attribute=event.id,
+            value=event.state == ON,
+        )
 
     def _logger_reload(self) -> None:
         """_Logger reload function."""
@@ -613,10 +640,6 @@ class Manager:
             return
         configure_logger(log_config=_config.get("logger"), debug=-1)
 
-    def _host_data_callback(self, type: str) -> None:
-        if self._oled:
-            self._oled.handle_data_update(type)
-
     def get_tasks(self) -> Set[asyncio.Task]:
         """Retrieve asyncio tasks to run."""
         return self._tasks
@@ -743,11 +766,6 @@ class Manager:
             self._loop.call_soon_threadsafe(
                 self._loop.call_later, 0.2, self.send_message, topic, ""
             )
-        if (
-            "Inputs screen 1" in self._screens
-            or "Inputs screen 2" in self._screens
-        ):
-            self._host_data_callback(type="inputs")
 
     async def toggle_output(self, output_id: str) -> None:
         """Toggle output state."""