boneIO 0.3.0.dev3__tar.gz → 0.3.0.dev5__tar.gz

{boneio-0.3.0.dev3/boneio.egg-info → boneio-0.3.0.dev5}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: boneio
-Version: 0.3.0.dev3
+Version: 0.3.0.dev5
 Summary: Python App for BoneIO
 Home-page: https://github.com/boneIO-eu/app_bbb
-Download-URL: https://github.com/boneIO-eu/app_bbb/archive/0.3.0.dev3.zip
+Download-URL: https://github.com/boneIO-eu/app_bbb/archive/0.3.0.dev5.zip
 License: GNU General Public License v3.0
 Platform: UNKNOWN
 Classifier: Programming Language :: Python

{boneio-0.3.0.dev3 → boneio-0.3.0.dev5}/boneio/bonecli.py

@@ -68,7 +68,7 @@ def get_arguments() -> argparse.Namespace:
 
 def run(config: str, debug: int, mqttusername: str = "", mqttpassword: str = ""):
     """Run BoneIO."""
-    _LOGGER.info("BoneIO starting.")
+    _LOGGER.info("BoneIO %s starting.", __version__)
     try:
         _config = load_config_from_file(config_file=config)
         if not _config:

{boneio-0.3.0.dev3 → boneio-0.3.0.dev5}/boneio/cover.py

@@ -4,6 +4,7 @@ import logging
 from typing import Any, Callable
 from boneio.const import CLOSE, COVER, IDLE, OPEN, OPENING, CLOSING, CLOSED, STOP
 from boneio.helper.events import EventBus
+from boneio.helper.exceptions import CoverRelayException
 from boneio.helper.mqtt import BasicMqtt
 from boneio.helper.timeperiod import TimePeriod
 from boneio.relay import MCPRelay
@@ -44,7 +45,7 @@ class Cover(BasicMqtt):
     def __init__(
         self,
         id: str,
-        open_relay: Any,
+        open_relay: MCPRelay,
         close_relay: MCPRelay,
         state_save: Callable,
         open_time: TimePeriod,

{boneio-0.3.0.dev3 → boneio-0.3.0.dev5}/boneio/example_config/output32x5A.yaml

@@ -1,160 +1,198 @@
-- id: light 1
+# mcp1 - upper left 8 relays
+- id: OUT_01
   kind: mcp
   mcp_id: mcp1
   pin: 0
   output_type: light
-- id: light 2
+  
+- id: OUT_02
   kind: mcp
   mcp_id: mcp1
   pin: 1
   output_type: light
-- id: light 3
+  
+- id: OUT_03
   kind: mcp
   mcp_id: mcp1
   pin: 2
   output_type: light
-- id: light 4
+  
+- id: OUT_04
   kind: mcp
   mcp_id: mcp1
   pin: 3
   output_type: light
-- id: light 5
+  
+- id: OUT_05
   kind: mcp
   mcp_id: mcp1
   pin: 4
   output_type: light
-- id: light 6
+  
+- id: OUT_06
   kind: mcp
   mcp_id: mcp1
   pin: 5
   output_type: light
-- id: light 7
+  
+- id: OUT_07
   kind: mcp
   mcp_id: mcp1
   pin: 6
   output_type: light
-- id: light 8
+  
+- id: OUT_08
   kind: mcp
   mcp_id: mcp1
   pin: 7
   output_type: light
-- id: light 9
+  
+  
+# mcp2 - upper right 8 relays
+- id: OUT_09
+  kind: mcp
+  mcp_id: mcp2
+  pin: 0
+  output_type: light
+  
+- id: OUT_10
+  kind: mcp
+  mcp_id: mcp2
+  pin: 1
+  output_type: light
+  
+- id: OUT_11
+  kind: mcp
+  mcp_id: mcp2
+  pin: 2
+  output_type: light
+  
+- id: OUT_12
+  kind: mcp
+  mcp_id: mcp2
+  pin: 3
+  output_type: light
+  
+- id: OUT_13
+  kind: mcp
+  mcp_id: mcp2
+  pin: 4
+  output_type: light
+  
+- id: OUT_14
+  kind: mcp
+  mcp_id: mcp2
+  pin: 5
+  output_type: light
+  
+- id: OUT_15
+  kind: mcp
+  mcp_id: mcp2
+  pin: 6
+  output_type: light
+  
+- id: OUT_16
+  kind: mcp
+  mcp_id: mcp2
+  pin: 7
+  output_type: light
+  
+  
+# mcp1 - lower left 8 relays
+- id: OUT_17
   kind: mcp
   mcp_id: mcp1
   pin: 8
   output_type: light
-- id: light 10
+  
+- id: OUT_18
   kind: mcp
   mcp_id: mcp1
   pin: 9
   output_type: light
-- id: light 11
+  
+- id: OUT_19
   kind: mcp
   mcp_id: mcp1
   pin: 10
   output_type: light
-- id: light 12
+  
+- id: OUT_20
   kind: mcp
   mcp_id: mcp1
   pin: 11
   output_type: light
-- id: light 13
+  
+- id: OUT_21
   kind: mcp
   mcp_id: mcp1
   pin: 12
   output_type: light
-- id: light 14
+  
+- id: OUT_22
   kind: mcp
   mcp_id: mcp1
   pin: 13
   output_type: light
-- id: light 15
+  
+- id: OUT_23
   kind: mcp
   mcp_id: mcp1
   pin: 14
   output_type: light
-- id: light 16
+  
+- id: OUT_24
   kind: mcp
   mcp_id: mcp1
   pin: 15
   output_type: light
-- id: switch 1
-  kind: mcp
-  mcp_id: mcp2
-  pin: 0
-  output_type: switch
-- id: switch 2
-  kind: mcp
-  mcp_id: mcp2
-  pin: 1
-  output_type: switch
-- id: switch 3
-  kind: mcp
-  mcp_id: mcp2
-  pin: 2
-  output_type: switch
-- id: switch 4
-  kind: mcp
-  mcp_id: mcp2
-  pin: 3
-  output_type: switch
-- id: switch 5
-  kind: mcp
-  mcp_id: mcp2
-  pin: 4
-  output_type: switch
-- id: switch 6
-  kind: mcp
-  mcp_id: mcp2
-  pin: 5
-  output_type: switch
-- id: switch 7
-  kind: mcp
-  mcp_id: mcp2
-  pin: 6
-  output_type: switch
-- id: switch 8
-  kind: mcp
-  mcp_id: mcp2
-  pin: 7
-  output_type: switch
-- id: switch 9
+  
+  
+# mcp2 - lower right 8 relays
+- id: OUT_25
   kind: mcp
   mcp_id: mcp2
   pin: 8
-  output_type: switch
-- id: switch 10
+  output_type: light
+  
+- id: OUT_26
   kind: mcp
   mcp_id: mcp2
   pin: 9
-  output_type: switch
-- id: switch 11
+  output_type: light
+  
+- id: OUT_27
   kind: mcp
   mcp_id: mcp2
   pin: 10
-  output_type: switch
-- id: switch 12
+  output_type: light
+  
+- id: OUT_28
   kind: mcp
   mcp_id: mcp2
   pin: 11
-  output_type: switch
-- id: switch 13
+  output_type: light
+  
+- id: OUT_29
   kind: mcp
   mcp_id: mcp2
   pin: 12
-  output_type: switch
-- id: switch 14
+  output_type: light
+  
+- id: OUT_30
   kind: mcp
   mcp_id: mcp2
   pin: 13
-  output_type: switch
-- id: switch 15
+  output_type: light
+  
+- id: OUT_31
   kind: mcp
   mcp_id: mcp2
   pin: 14
-  output_type: switch
-- id: switch 16
+  output_type: light
+  
+- id: OUT_32
   kind: mcp
   mcp_id: mcp2
   pin: 15
-  output_type: switch
+  output_type: light

boneio-0.3.0.dev5/boneio/helper/config.py

@@ -0,0 +1,36 @@
+"""
+Module to provide basic config options.
+"""
+from boneio.const import BONEIO, HOMEASSISTANT
+
+
+class ConfigHelper:
+    def __init__(
+        self,
+        topic_prefix: str = BONEIO,
+        ha_discovery: bool = True,
+        ha_discovery_prefix: str = HOMEASSISTANT,
+    ):
+        self._topic_prefix = topic_prefix
+        self._ha_discovery = ha_discovery
+        self._ha_discovery_prefix = ha_discovery_prefix
+
+    @property
+    def topic_prefix(self) -> str:
+        return self._topic_prefix
+
+    @property
+    def ha_discovery(self) -> bool:
+        return self._ha_discovery
+
+    @property
+    def ha_discovery_prefix(self) -> str:
+        return self._ha_discovery_prefix
+
+    @property
+    def cmd_topic_prefix(self) -> str:
+        return f"{self.topic_prefix}/cmd/"
+
+    @property
+    def subscribe_topic(self) -> str:
+        return f"{self.cmd_topic_prefix}+/+/#"

{boneio-0.3.0.dev3 → boneio-0.3.0.dev5}/boneio/helper/exceptions.py

@@ -15,3 +15,7 @@ class I2CError(BoneIOException):
 
 class ConfigurationException(BoneIOException):
     """Configuration yaml exception."""
+
+
+class CoverRelayException(BoneIOException):
+    """Cover configuration exception."""

{boneio-0.3.0.dev3 → boneio-0.3.0.dev5}/boneio/helper/loader.py

@@ -46,6 +46,7 @@ from boneio.helper import (
 from boneio.helper.ha_discovery import ha_cover_availabilty_message
 from boneio.helper.timeperiod import TimePeriod
 from boneio.input.gpio import GpioInputButton
+from boneio.helper.config import ConfigHelper
 
 # Typing imports that create a circular dependency
 if TYPE_CHECKING:
@@ -59,9 +60,7 @@ from busio import I2C
 _LOGGER = logging.getLogger(__name__)
 
 
-def create_adc(
-    manager: Manager, topic_prefix: str, ha_discovery_prefix: str, adc_list: list = []
-):
+def create_adc(manager: Manager, topic_prefix: str, adc_list: list = []):
     """Create ADC sensor."""
 
     initialize_adc()
@@ -85,7 +84,6 @@ def create_adc(
                     id=id,
                     name=name,
                     ha_type=SENSOR,
-                    ha_discovery_prefix=ha_discovery_prefix,
                     availability_msg_func=ha_adc_sensor_availabilty_message,
                 )
             manager.append_task(asyncio.create_task(adc.send_state()))
@@ -97,11 +95,9 @@ def create_adc(
 def create_temp_sensor(
     manager: Manager,
     topic_prefix: str,
-    ha_discovery_prefix: str,
     sensor_type: str,
     i2cbusio: I2C,
     temp_def: dict = {},
-    temp_sensors: list = [],
 ):
     """Create LM sensor in manager."""
     if sensor_type == LM75:
@@ -125,11 +121,10 @@ def create_temp_sensor(
             id=id,
             name=name,
             ha_type=SENSOR,
-            ha_discovery_prefix=ha_discovery_prefix,
             availability_msg_func=ha_sensor_temp_availabilty_message,
         )
         manager.append_task(asyncio.create_task(temp_sensor.send_state()))
-        temp_sensors.append(temp_sensor)
+        return temp_sensor
     except I2CError as err:
         _LOGGER.error("Can't configure Temp sensor. %s", err)
         pass
@@ -160,9 +155,7 @@ def create_mcp23017(
 
 def create_modbus_sensors(
     manager: Manager,
-    topic_prefix: str,
-    ha_discovery: bool,
-    ha_discovery_prefix: str,
+    config_helper: ConfigHelper,
     modbus: Modbus,
     sensors,
 ) -> None:
@@ -180,9 +173,7 @@ def create_modbus_sensors(
                 name=name,
                 model=sensor[MODEL],
                 send_message=manager.send_message,
-                topic_prefix=topic_prefix,
-                ha_discovery=ha_discovery,
-                ha_discovery_prefix=ha_discovery_prefix,
+                config_helper=config_helper,
                 update_interval=sensor.get(UPDATE_INTERVAL, TimePeriod(seconds=60)),
             )
             manager.append_task(asyncio.create_task(sdm.send_state()))
@@ -289,7 +280,6 @@ def configure_input(
     pin: str,
     press_callback: Callable,
     send_ha_autodiscovery: Callable,
-    ha_discovery_prefix: str,
 ) -> str:
     """Configure input sensor or button."""
     try:
@@ -309,7 +299,6 @@ def configure_input(
                 id=pin,
                 name=gpio.get(ID, pin),
                 ha_type=getattr(input, "ha_type"),
-                ha_discovery_prefix=ha_discovery_prefix,
                 availability_msg_func=getattr(input, "availability_msg_f"),
             )
         return pin
@@ -322,7 +311,6 @@ def configure_cover(
     manager: Manager,
     cover_id: str,
     state_manager: StateManager,
-    ha_discovery_prefix: str,
     send_ha_autodiscovery: Callable,
     config: dict,
     **kwargs,
@@ -352,7 +340,6 @@ def configure_cover(
             name=cover.name,
             ha_type=COVER,
             device_class=config.get(DEVICE_CLASS),
-            ha_discovery_prefix=ha_discovery_prefix,
             availability_msg_func=ha_cover_availabilty_message,
         )
     return cover

{boneio-0.3.0.dev3 → boneio-0.3.0.dev5}/boneio/helper/yaml_util.py

@@ -263,6 +263,7 @@ class CustomValidator(Validator):
             "milliseconds": "milliseconds",
             "s": "seconds",
             "sec": "seconds",
+            "secs": "seconds",
             "seconds": "seconds",
             "min": "minutes",
             "minutes": "minutes",

{boneio-0.3.0.dev3 → boneio-0.3.0.dev5}/boneio/manager.py

@@ -7,11 +7,9 @@ from busio import I2C
 
 from boneio.const import (
     ACTION,
-    BONEIO,
     BUTTON,
     CLOSE,
     COVER,
-    HOMEASSISTANT,
     ID,
     INPUT,
     LM75,
@@ -44,6 +42,8 @@ from boneio.helper import (
     ha_button_availabilty_message,
     host_stats,
 )
+
+from boneio.helper.config import ConfigHelper
 from boneio.helper.events import EventBus
 from boneio.helper.loader import (
     configure_cover,
@@ -68,14 +68,12 @@ class Manager:
         self,
         send_message: Callable[[str, Union[str, dict], bool], None],
         state_manager: StateManager,
+        config_helper: ConfigHelper,
         config_file_path: str,
         relay_pins: List = [],
         input_pins: List = [],
         sensors: dict = {},
-        topic_prefix: str = BONEIO,
         modbus: dict = None,
-        ha_discovery: bool = True,
-        ha_discovery_prefix: str = HOMEASSISTANT,
         mcp23017: Optional[List] = None,
         oled: dict = {},
         adc_list: Optional[List] = None,
@@ -83,17 +81,16 @@ class Manager:
     ) -> None:
         """Initialize the manager."""
         _LOGGER.info("Initializing manager module.")
+
         self._loop = asyncio.get_event_loop()
+        self._config_helper = config_helper
         self._host_data = None
-        self._ha_discovery = ha_discovery
         self._config_file_path = config_file_path
         self._state_manager = state_manager
         self._event_bus = EventBus(self._loop)
+        self._autodiscovery_messages = []
 
         self.send_message = send_message
-        self._topic_prefix = topic_prefix
-        self._command_topic_prefix = f"{topic_prefix}/cmd/"
-        self.subscribe_topic = f"{self._command_topic_prefix}+/+/#"
         self._input_pins = input_pins
         self._i2cbusio = I2C(SCL, SDA)
         self._mcp = {}
@@ -108,26 +105,25 @@ class Manager:
 
         for sensor_type in (LM75, MCP_TEMP_9808):
             if sensors.get(sensor_type):
-                create_temp_sensor(
-                    manager=self,
-                    topic_prefix=topic_prefix,
-                    ha_discovery_prefix=ha_discovery_prefix,
-                    sensor_type=sensor_type,
-                    temp_def=sensors.get(sensor_type),
-                    i2cbusio=self._i2cbusio,
-                    temp_sensors=self._temp_sensors,
-                )
+                for temp_def in sensors.get(sensor_type):
+                    temp_sensor = create_temp_sensor(
+                        manager=self,
+                        topic_prefix=self._config_helper.topic_prefix,
+                        sensor_type=sensor_type,
+                        temp_def=temp_def,
+                        i2cbusio=self._i2cbusio,
+                    )
+                    if temp_sensor:
+                        self._temp_sensors.append(temp_sensor)
 
         if sensors.get(MODBUS) and self._modbus:
             from boneio.helper.loader import create_modbus_sensors
 
             create_modbus_sensors(
                 manager=self,
-                topic_prefix=topic_prefix,
-                ha_discovery=ha_discovery,
-                ha_discovery_prefix=ha_discovery_prefix,
                 sensors=sensors.get(MODBUS),
                 modbus=self._modbus,
+                config_helper=self._config_helper,
             )
 
         self.grouped_outputs = create_mcp23017(
@@ -139,9 +135,8 @@ class Manager:
 
             create_adc(
                 manager=self,
-                topic_prefix=topic_prefix,
+                topic_prefix=self._config_helper.topic_prefix,
                 adc_list=adc_list,
-                ha_discovery_prefix=ha_discovery_prefix,
             )
 
         for _config in relay_pins:
@@ -149,7 +144,7 @@ class Manager:
             out = configure_relay(
                 manager=self,
                 state_manager=self._state_manager,
-                topic_prefix=topic_prefix,
+                topic_prefix=self._config_helper.topic_prefix,
                 relay_id=_id,
                 relay_callback=self._relay_callback,
                 config=_config,
@@ -162,7 +157,6 @@ class Manager:
                     id=out.id,
                     name=out.name,
                     ha_type=out.output_type,
-                    ha_discovery_prefix=ha_discovery_prefix,
                     availability_msg_func=ha_light_availabilty_message
                     if out.is_light
                     else ha_switch_availabilty_message,
@@ -177,6 +171,18 @@ class Manager:
             _id = _config[ID].replace(" ", "")
             open_relay = self._output.get(_config.get("open_relay"))
             close_relay = self._output.get(_config.get("close_relay"))
+            if not open_relay:
+                _LOGGER.error(
+                    "Can't configure cover %s. This relay doesn't exist.",
+                    _config.get("open_relay"),
+                )
+                continue
+            if not close_relay:
+                _LOGGER.error(
+                    "Can't configure cover %s. This relay doesn't exist.",
+                    _config.get("close_relay"),
+                )
+                continue
             if open_relay.output_type != NONE or close_relay.output_type != NONE:
                 _LOGGER.error(
                     "Can't configure cover %s. %s",
@@ -194,9 +200,8 @@ class Manager:
                 open_time=_config.get("open_time"),
                 close_time=_config.get("close_time"),
                 event_bus=self._event_bus,
-                ha_discovery_prefix=ha_discovery_prefix,
                 send_ha_autodiscovery=self.send_ha_autodiscovery,
-                topic_prefix=topic_prefix,
+                topic_prefix=self._config_helper.topic_prefix,
             )
 
         _LOGGER.info("Initializing inputs. This will take a while.")
@@ -211,7 +216,6 @@ class Manager:
                     gpio=gpio,
                     pin=pin,
                     press_callback=self.press_callback,
-                    ha_discovery_prefix=ha_discovery_prefix,
                     send_ha_autodiscovery=self.send_ha_autodiscovery,
                 )
             )
@@ -235,14 +239,15 @@ class Manager:
                 )
             except (GPIOInputException, I2CError) as err:
                 _LOGGER.error("Can't configure OLED display. %s", err)
-        self.prepare_button(ha_discovery_prefix=ha_discovery_prefix)
+        self.prepare_button()
 
         _LOGGER.info("BoneIO manager is ready.")
 
     async def reconnect_callback(self) -> None:
         """Function to invoke when connection to MQTT is (re-)established."""
         _LOGGER.info("Sending online state.")
-        self.send_message(topic=f"{self._topic_prefix}/{STATE}", payload=ONLINE)
+        topic = f"{self._config_helper.topic_prefix}/{STATE}"
+        self.send_message(topic=topic, payload=ONLINE, retain=True)
 
     def _relay_callback(
         self, relay_type: str, relay_id: str, restore_state: bool
@@ -275,13 +280,12 @@ class Manager:
         """Add task to run with asyncio loop."""
         self._tasks.append(task)
 
-    def prepare_button(self, ha_discovery_prefix: str) -> None:
+    def prepare_button(self) -> None:
         """Prepare buttons for reload."""
         self.send_ha_autodiscovery(
             id="Logger",
             name="Logger",
             ha_type=BUTTON,
-            ha_discovery_prefix=ha_discovery_prefix,
             availability_msg_func=ha_button_availabilty_message,
         )
 
@@ -295,7 +299,7 @@ class Manager:
     ) -> None:
         """Press callback to use in input gpio.
         If relay input map is provided also toggle action on relay or cover or mqtt."""
-        topic = f"{self._topic_prefix}/{input_type}/{inpin}"
+        topic = f"{self._config_helper.topic_prefix}/{input_type}/{inpin}"
         self.send_message(topic=topic, payload=x)
         for action_definition in actions:
             _LOGGER.debug("Executing action %s", action_definition)
@@ -328,41 +332,60 @@ class Manager:
         self,
         id: str,
         name: str,
-        ha_discovery_prefix: str,
         ha_type: str,
         availability_msg_func: Callable,
         topic_prefix: str = None,
         **kwargs,
     ) -> None:
         """Send HA autodiscovery information for each relay."""
-        if not self._ha_discovery:
+        if not self._config_helper.ha_discovery:
             return
-        if not topic_prefix:
-            topic_prefix = self._topic_prefix
+        topic_prefix = topic_prefix or self._config_helper.topic_prefix
         msg = availability_msg_func(topic=topic_prefix, id=id, name=name, **kwargs)
-        topic = f"{ha_discovery_prefix}/{ha_type}/{topic_prefix}/{id}/config"
+        topic = f"{self._config_helper.ha_discovery_prefix}/{ha_type}/{topic_prefix}/{id}/config"
         _LOGGER.debug("Sending HA discovery for %s, %s.", ha_type, name)
+        self._autodiscovery_messages.append({"topic": topic, "payload": msg})
         self.send_message(topic=topic, payload=msg, retain=True)
 
+    def resend_autodiscovery(self):
+        for msg in self._autodiscovery_messages:
+            self.send_message(**msg, retain=True)
+
     async def receive_message(self, topic: str, message: str) -> None:
         """Callback for receiving action from Mqtt."""
-        assert topic.startswith(self._command_topic_prefix)
-        topic_parts_raw = topic[len(self._command_topic_prefix) :].split("/")
+        _LOGGER.debug("Processing topic %s with message %s.", topic, message)
+        if topic.startswith(f"{self._config_helper.ha_discovery_prefix}/status"):
+            if message == ONLINE:
+                self.resend_autodiscovery()
+            return
+        assert topic.startswith(self._config_helper.cmd_topic_prefix)
+        topic_parts_raw = topic[len(self._config_helper.cmd_topic_prefix) :].split("/")
         topic_parts = deque(topic_parts_raw)
         try:
             msg_type = topic_parts.popleft()
             device_id = topic_parts.popleft()
             command = topic_parts.pop()
+            _LOGGER.debug(
+                "Divide topic to: msg_type: %s, device_id: %s, command: %s",
+                msg_type,
+                device_id,
+                command,
+            )
         except IndexError:
             _LOGGER.error("Part of topic is missing. Not invoking command.")
             return
 
         if msg_type == RELAY and command == "set":
             target_device = self._output.get(device_id)
+
             if target_device and target_device.output_type != NONE:
                 action_from_msg = relay_actions.get(message.upper())
                 if action_from_msg:
                     getattr(target_device, action_from_msg)()
+                else:
+                    _LOGGER.debug("Action not exist %s.", message.upper())
+            else:
+                _LOGGER.debug("Target device not found %s.", device_id)
         elif msg_type == COVER:
             cover = self._covers.get(device_id)
             if not cover:

{boneio-0.3.0.dev3 → boneio-0.3.0.dev5}/boneio/modbus.py

@@ -69,7 +69,7 @@ class Modbus:
 
     async def read_single_register(
         self, unit: int, address: int, count: int = 2, method: str = "input"
-    ) -> float:
+    ) -> float | None:
         """Call sync. pymodbus."""
         async with self._lock:
             if not self._pymodbus_connect():

{boneio-0.3.0.dev3 → boneio-0.3.0.dev5}/boneio/mqtt_client.py

@@ -7,16 +7,17 @@ import json
 import logging
 import uuid
 from contextlib import AsyncExitStack
-from typing import Any, Callable, Optional, Set, Union
+from typing import Any, Callable, Optional, Set, Tuple, Union
 
 import paho.mqtt.client as mqtt
-from asyncio_mqtt import Client as AsyncioClient
+from asyncio_mqtt import Client as AsyncioClient, Will
 from asyncio_mqtt import MqttError
 from paho.mqtt.properties import Properties
 from paho.mqtt.subscribeoptions import SubscribeOptions
 
-from boneio.const import PAHO
+from boneio.const import PAHO, STATE, ONLINE
 from boneio.helper import UniqueQueue
+from boneio.helper.config import ConfigHelper
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -27,12 +28,14 @@ class MQTTClient:
     def __init__(
         self,
         host: str,
+        config_helper: ConfigHelper,
         port: int = 1883,
         **client_options: Any,
     ) -> None:
         """Set up client."""
         self.host = host
         self.port = port
+        self._config_helper = config_helper
         client_options["client_id"] = mqtt.base62(uuid.uuid4().int, padding=22)
         client_options["logger"] = logging.getLogger(PAHO)
         client_options["clean_session"] = True
@@ -49,6 +52,12 @@ class MQTTClient:
         self.asyncio_client = AsyncioClient(
             self.host,
             self.port,
+            will=Will(
+                topic=f"{self._config_helper.topic_prefix}/{STATE}",
+                payload=ONLINE,
+                qos=0,
+                retain=False,
+            ),
             **self.client_options,
         )
 
@@ -76,7 +85,7 @@ class MQTTClient:
 
     async def subscribe(  # pylint:disable=too-many-arguments
         self,
-        topic: str,
+        topics: Tuple[str, str],
         qos: int = 0,
         options: Optional[SubscribeOptions] = None,
         properties: Optional[Properties] = None,
@@ -86,13 +95,17 @@ class MQTTClient:
 
         Can raise asyncio_mqtt.MqttError.
         """
-        params: dict = {"qos": qos, "timeout": timeout}
+        args = []
+        for topic in topics:
+            args.append((topic, qos))
+        params: dict = {"qos": qos}
         if options:
             params["options"] = options
         if properties:
             params["properties"] = properties
 
-        await self.asyncio_client.subscribe(topic, **params)
+        # e.g. subscribe([("my/topic", SubscribeOptions(qos=0), ("another/topic", SubscribeOptions(qos=2)])
+        await self.asyncio_client.subscribe(topic=args, **params, timeout=timeout)
 
     async def unsubscribe(
         self, topic: str, properties: Optional[Properties] = None, timeout: float = 10.0
@@ -169,7 +182,9 @@ class MQTTClient:
                 tasks.add(reconnect_task)
             tasks.add(messages_task)
 
-            await self.subscribe(manager.subscribe_topic)
+            await self.subscribe(
+                topics=(self._config_helper.subscribe_topic, "homeassistant/status")
+            )
 
             # Wait for everything to complete (or fail due to, e.g., network errors).
             await asyncio.gather(*tasks)

{boneio-0.3.0.dev3 → boneio-0.3.0.dev5}/boneio/relay/mcp.py

@@ -1,7 +1,7 @@
 """MCP23017 Relay module."""
 
 import logging
-from adafruit_mcp230xx.mcp23017 import MCP23017
+from adafruit_mcp230xx.mcp23017 import MCP23017, DigitalInOut
 from boneio.helper import callback
 from boneio.relay.basic import BasicRelay
 from boneio.const import SWITCH, NONE
@@ -23,7 +23,7 @@ class MCPRelay(BasicRelay):
         **kwargs
     ) -> None:
         """Initialize MCP relay."""
-        self._pin = mcp.get_pin(pin)
+        self._pin: DigitalInOut = mcp.get_pin(pin)
         self._pin.switch_to_output(value=True)
         if output_type == NONE:
             """Just in case to not restore state of covers etc."""

{boneio-0.3.0.dev3 → boneio-0.3.0.dev5}/boneio/runner.py

@@ -26,6 +26,7 @@ _LOGGER = logging.getLogger(__name__)
 from boneio.helper import StateManager
 from boneio.manager import Manager
 from boneio.mqtt_client import MQTTClient
+from boneio.helper.config import ConfigHelper
 
 
 async def async_run(
@@ -36,27 +37,32 @@ async def async_run(
 ):
     """Run BoneIO."""
 
+    _config_helper = ConfigHelper(
+        topic_prefix=config[MQTT].pop(TOPIC_PREFIX),
+        ha_discovery=config[MQTT][HA_DISCOVERY].pop(ENABLED),
+        ha_discovery_prefix=config[MQTT][HA_DISCOVERY].pop(TOPIC_PREFIX),
+    )
+
     client = MQTTClient(
         host=config[MQTT][HOST],
         username=config[MQTT].get(USERNAME, mqttusername),
         password=config[MQTT].get(PASSWORD, mqttpassword),
         port=config[MQTT].get(PORT, 1883),
+        config_helper=_config_helper,
     )
 
     manager = Manager(
         send_message=client.send_message,
-        topic_prefix=config[MQTT][TOPIC_PREFIX],
         relay_pins=config.get(OUTPUT, []),
         input_pins=config.get(INPUT, []),
         config_file_path=config_file,
         state_manager=StateManager(
             state_file=f"{os.path.split(config_file)[0]}state.json"
         ),
-        ha_discovery=config[MQTT][HA_DISCOVERY][ENABLED],
-        ha_discovery_prefix=config[MQTT][HA_DISCOVERY][TOPIC_PREFIX],
+        config_helper=_config_helper,
         sensors={
-            LM75: config.get(LM75),
-            MCP_TEMP_9808: config.get(MCP_TEMP_9808),
+            LM75: config.get(LM75, []),
+            MCP_TEMP_9808: config.get(MCP_TEMP_9808, []),
             MODBUS: config.get("modbus_sensors"),
         },
         mcp23017=config.get(MCP23017, []),

{boneio-0.3.0.dev3 → boneio-0.3.0.dev5}/boneio/sensor/modbus/__init__.py

@@ -1,3 +1,4 @@
+from distutils.command.config import config
 import logging
 import asyncio
 from datetime import datetime
@@ -20,6 +21,9 @@ from boneio.const import (
 from boneio.helper import BasicMqtt
 from boneio.helper.ha_discovery import modbus_sensor_availabilty_message
 from boneio.helper.timeperiod import TimePeriod
+from boneio.helper.config import ConfigHelper
+from boneio.modbus import Modbus
+
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -90,28 +94,27 @@ class ModbusSensor(BasicMqtt):
 
     def __init__(
         self,
-        modbus,
+        modbus: Modbus,
         address: str,
         model: str,
-        ha_discovery_prefix: str,
-        topic_prefix: str,
-        ha_discovery: bool = False,
+        config_helper: ConfigHelper,
         id: str = DefaultName,
         update_interval: TimePeriod = TimePeriod(seconds=60),
         **kwargs,
     ):
         """Initialize Modbus sensor class."""
         super().__init__(
-            id=id or address, topic_type=SENSOR, topic_prefix=topic_prefix, **kwargs
+            id=id or address,
+            topic_type=SENSOR,
+            topic_prefix=config_helper.topic_prefix,
+            **kwargs,
         )
-        self._topic_prefix = topic_prefix
+        self._config_helper = config_helper
         self._modbus = modbus
         self._db = open_json(model=model)
         self._model = self._db[MODEL]
         self._address = address
-        self._ha_discovery = ha_discovery
         self._discovery_sent = False
-        self._ha_discovery_prefix = ha_discovery_prefix
         self._update_interval = update_interval
 
     def _send_ha_autodiscovery(
@@ -121,11 +124,11 @@ class ModbusSensor(BasicMqtt):
         _LOGGER.debug("Sending HA discovery for sensor %s %s.", sdm_name, sensor_id)
         self._send_message(
             topic=(
-                f"{self._ha_discovery_prefix}/{SENSOR}/{self._topic_prefix}{id}"
+                f"{self._config_helper.ha_discovery_prefix}/{SENSOR}/{self._config_helper.topic_prefix}{id}"
                 f"/{id}{sensor_id.replace('_', '').replace(' ', '').lower()}/config"
             ),
             payload=modbus_sensor_availabilty_message(
-                topic=self._topic_prefix,
+                topic=self._config_helper.topic_prefix,
                 id=id,
                 name=sdm_name,
                 model=self._model,
@@ -166,7 +169,7 @@ class ModbusSensor(BasicMqtt):
         if (
             not self._discovery_sent
             or (datetime.now() - self._discovery_sent).seconds > 3600
-        ) and self._ha_discovery:
+        ) and self._config_helper.topic_prefix:
             self._discovery_sent = False
             first_register_base = self._db[REGISTERS_BASE][0]
             register_method = first_register_base.get("register_type", "input")
@@ -201,7 +204,7 @@ class ModbusSensor(BasicMqtt):
                     _LOGGER.info("Sending online payload about device.")
                     payload_online = ONLINE
                     self._send_message(
-                        topic=f"{self._topic_prefix}/{self._id}{STATE}",
+                        topic=f"{self._config_helper.topic_prefix}/{self._id}{STATE}",
                         payload=payload_online,
                     )
                 if not values:
@@ -212,7 +215,7 @@ class ModbusSensor(BasicMqtt):
                         # Let's assume device is offline.
                         payload_online = OFFLINE
                         self._send_message(
-                            topic=f"{self._topic_prefix}/{self._id}{STATE}",
+                            topic=f"{self._config_helper.topic_prefix}/{self._id}{STATE}",
                             payload=payload_online,
                         )
                     _LOGGER.warn(

boneio-0.3.0.dev5/boneio/version.py

@@ -0,0 +1,2 @@
+# flake8: noqa
+__version__ = "0.3.0.dev5"

{boneio-0.3.0.dev3 → boneio-0.3.0.dev5/boneio.egg-info}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: boneio
-Version: 0.3.0.dev3
+Version: 0.3.0.dev5
 Summary: Python App for BoneIO
 Home-page: https://github.com/boneIO-eu/app_bbb
-Download-URL: https://github.com/boneIO-eu/app_bbb/archive/0.3.0.dev3.zip
+Download-URL: https://github.com/boneIO-eu/app_bbb/archive/0.3.0.dev5.zip
 License: GNU General Public License v3.0
 Platform: UNKNOWN
 Classifier: Programming Language :: Python

{boneio-0.3.0.dev3 → boneio-0.3.0.dev5}/boneio.egg-info/SOURCES.txt

@@ -28,6 +28,7 @@ boneio/example_config/output24x16A.yaml
 boneio/example_config/output32x5A.yaml
 boneio/fonts/danube__.ttf
 boneio/helper/__init__.py
+boneio/helper/config.py
 boneio/helper/events.py
 boneio/helper/exceptions.py
 boneio/helper/gpio.py

boneio-0.3.0.dev3/boneio/version.py

@@ -1,2 +0,0 @@
-# flake8: noqa
-__version__ = "0.3.0.dev3"