boneIO 0.6.0dev4__py3-none-any.whl → 0.6.0dev5__py3-none-any.whl

{boneIO-0.6.0.dev4.dist-info → boneIO-0.6.0.dev5.dist-info}/METADATA

@@ -1,26 +1,26 @@
 Metadata-Version: 2.1
 Name: boneIO
-Version: 0.6.0dev4
+Version: 0.6.0dev5
 Summary: Python App for BoneIO
 License: GNU General Public License v3.0
 Author-email: Paweł Szafer <pszafer@gmail.com>
 Requires-Python: >=3.7
 Requires-Dist: Adafruit-BBIO>=1.2.0
-Requires-Dist: Adafruit-Blinka>=8.0.2
+Requires-Dist: Adafruit-Blinka>=8.19.0
 Requires-Dist: Cerberus>=1.3.4
 Requires-Dist: PyYAML>=6.0
-Requires-Dist: adafruit-circuitpython-ds18x20>=1.3.12
-Requires-Dist: adafruit-circuitpython-mcp230xx>=2.5.5
-Requires-Dist: adafruit-circuitpython-mcp9808>=3.3.14
+Requires-Dist: adafruit-circuitpython-ds18x20>=1.3.16
+Requires-Dist: adafruit-circuitpython-mcp230xx>=2.5.9
+Requires-Dist: adafruit-circuitpython-mcp9808>=3.3.19
 Requires-Dist: adafruit-circuitpython-onewire>=2.0.4
-Requires-Dist: adafruit-circuitpython-pca9685>=3.4.6
-Requires-Dist: adafruit-circuitpython-pct2075>=1.1.14
-Requires-Dist: asyncio-mqtt>=0.12.1
-Requires-Dist: colorlog>=6.6.0
-Requires-Dist: gpio>=0.3.0
-Requires-Dist: luma.core>=2.3.1
-Requires-Dist: luma.oled>=3.8.1
-Requires-Dist: psutil>=5.9.1
+Requires-Dist: adafruit-circuitpython-pca9685>=3.4.8
+Requires-Dist: adafruit-circuitpython-pct2075>=1.1.18
+Requires-Dist: asyncio-mqtt>=0.16.1
+Requires-Dist: colorlog>=6.7.0
+Requires-Dist: gpio>=1.0.0
+Requires-Dist: luma-core>=2.4.0
+Requires-Dist: luma-oled>=3.12.0
+Requires-Dist: psutil>=5.9.5
 Requires-Dist: pymodbus>=2.5.3
 Requires-Dist: pyserial-asyncio>=0.6
 Requires-Dist: w1thermsensor[async]>=2.0.0

{boneIO-0.6.0.dev4.dist-info → boneIO-0.6.0.dev5.dist-info}/RECORD

@@ -1,5 +1,5 @@
 boneio/__init__.py,sha256=hoLKnu6h1uEsiCHA9Ql2MMDC7VQS0E-s_2cxBS-CTOg,147
-boneio/bonecli.py,sha256=Wg3Wc2xZ9FjF_23PK6Ja3YzXUkYanzYyQ_QdtQbKESw,3155
+boneio/bonecli.py,sha256=VhY1BMt6OaZz-752UjhEexdn8fDJkJaDWcGQNhCmgN0,3341
 boneio/const.py,sha256=jowaP49OLdHOK2Bop2KDVPVKRVbqjBPHl_Fgl5aRzIg,2924
 boneio/cover.py,sha256=nr76ft5smAPdBB8Jytk-uFd6RWuqtcZiG6EE129OUjw,8454
 boneio/example_config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -14,15 +14,15 @@ boneio/fonts/danube__.ttf,sha256=KBRPUcGvmroCjrWC8zK4MulUb9lV8R0lXkOY7lNnQWc,193
 boneio/helper/__init__.py,sha256=r-9dubCtDlrs_HFF2OGPQEPmw1XREgb4qQF6I486Li4,2039
 boneio/helper/async_updater.py,sha256=BVh5mXFxgaZqoekjQbQSCTssfyVIdCQ80LCJny-rOo4,985
 boneio/helper/click_timer.py,sha256=blWofzFIwuYcF_yFfCGDtI8nGSMpSdXdl9qMLXlKdXc,1169
-boneio/helper/config.py,sha256=XeHG7OSMCMmEL43rCbWy6Ij0RcTNlrIpevWZ0UJyrlo,1311
+boneio/helper/config.py,sha256=hhM4KUNaAFVXgQ1ZX56Zu7XV0pjp636vrcBuwoTH18g,2233
 boneio/helper/events.py,sha256=EHYJy507RF1LikWQ2s4r990JRvR9rO4z7FkaJqt1Mrk,7494
-boneio/helper/exceptions.py,sha256=Tll3ZZPOo0JZskN67hkoAxxGJ4I5ZY4IjeXtKyveziI,637
+boneio/helper/exceptions.py,sha256=vyYSUojwB7OttOPUjbxeHFM7C_o5ZQmRUcZ_vYpxYYI,717
 boneio/helper/filter.py,sha256=UcjifjaC5wHDW2He7wmwCX2IjSSeLVhXyhrXHeT8RmA,885
 boneio/helper/gpio.py,sha256=v4QrJfwlhIOqRCcD1SCpwPVcY6zsTlm1tens0eLbazM,2718
-boneio/helper/ha_discovery.py,sha256=e2xjArXixpbVru3oD_8L8UKMgEkpbL5OV2ybZaNi-f0,6129
-boneio/helper/loader.py,sha256=8lWjNVLcV-uqIGGgD7bY3lGEK9dhEDB0wQppxFb_Vys,13488
+boneio/helper/ha_discovery.py,sha256=s80gwx1Fik2_vtq-6kqabUqPx4KwwZUt4G1Oy6RgGgU,6278
+boneio/helper/loader.py,sha256=dKlk42tI7RkyI_FmX6CneN3FIGnHQ55c20sfn11B_bk,13547
 boneio/helper/logger.py,sha256=zyF_Vk3o2eSHuXypJhNzK99eZgkWDWybuB5KcJgurDs,1801
-boneio/helper/mqtt.py,sha256=Aqf6Sx4-3GQsK5GjgJ5QxVMyCTdRcL5Zq_GTIDu7ne0,759
+boneio/helper/mqtt.py,sha256=UVa4KaxvVif6By_sVMdSMiYI_doZjiXF4LS9RFltxJk,765
 boneio/helper/oled.py,sha256=f0XYbaFstUbJ6ISmFe1vQCnmNVMctQWtnStNdROrblc,351
 boneio/helper/onewire/W1ThermSensor.py,sha256=Pu5Fp29pKbxjJqDbFs05Mjg3Vy-9z_DTVoBpSWM_byA,2430
 boneio/helper/onewire/__init__.py,sha256=4djH-uxiq5XhAiFTOxyqjvWVoJe0c8U8iN0BfmH8nSU,448
@@ -35,29 +35,29 @@ boneio/helper/timeperiod.py,sha256=xpg9oe30Z5WiLDQPq3EBKKScejOnN47NhcpeFvDd3bY,5
 boneio/helper/util.py,sha256=QfSoT3H3WnOQAKO5bFRIBCy62HT5NMa9Ek-FmfTW_rw,508
 boneio/helper/yaml_util.py,sha256=gAX7hCaHUlPgkhGCIQ4zjv0Vj9JmLzQsSyF51ZmSb9g,11304
 boneio/input/__init__.py,sha256=u9wuehuC_TNizL4tyn7EygZW5LaTFjSnFaZeZr3zZ1U,99
-boneio/input/gpio.py,sha256=oCJNJ7FYvznsNt2xwtmEGMOOeXCJj-3Ssh-xMYVXOfQ,2583
-boneio/manager.py,sha256=D_VT_VpGAZo3CVjoxDecYPlQwIbdEA-2rkABXUIDxW4,20273
+boneio/input/gpio.py,sha256=7teo2fDyDUarorCn9REF5sGFMIimRrWaKOqildYG8_Y,2597
+boneio/manager.py,sha256=cs2vy-26kvQROWHjHopACY2U1OLufcsu522RjShVXyQ,21023
 boneio/modbus.py,sha256=eA_sGnmdcIneXX75ZcXOI223-UkKN1UYmWFqiJBAhJo,4176
-boneio/mqtt_client.py,sha256=ioOBEmnbjpZjYrD5u8W5CrVsrNFRHDJ93fyk6XcWkeE,6983
+boneio/mqtt_client.py,sha256=NYvok8y_g8iRXDopVojzcDGVnDJEFqHBEYhOGy8m7T8,8331
 boneio/oled.py,sha256=d_ofDQHc7zr3j0qOR0B_L3C8TJhvRH85nnb9Le-88nk,5244
 boneio/relay/__init__.py,sha256=iLEUL8kxnEndCQtgDIJfHqUZOfyWfWmuOrqSYAUxb2w,181
-boneio/relay/basic.py,sha256=zOXf84yTGeArk3ghXt_WI2ul8L0RxyziOTD6U7-nCLM,2629
+boneio/relay/basic.py,sha256=QEWG8HodBqEqLpQxcQm29hdPIxO7c6ep0uDgfo3pcco,2623
 boneio/relay/gpio.py,sha256=s64FBf6zlxciF57xJ6nrvy0t5Rie0uiXlwos0HL3RKM,1163
 boneio/relay/mcp.py,sha256=DhgqZbFHB6TucL9hJaJiqdVAbkw4Rv5VPHm_khSBIFo,2669
 boneio/relay/pca.py,sha256=tCwXvMJcsxzFj48ZO2tPYyvElZfyIRTFmEMp7ENKvtk,4873
-boneio/runner.py,sha256=geT_ps_vo1SLoBszmhtcpkzk_LwWpG8OZYgUcQg3nKU,2287
+boneio/runner.py,sha256=eLRd3NtE8c5fqYu76B4Kz7vs5ftNDSZ_L-KHbipRu90,2569
 boneio/schema/actions.yaml,sha256=WD0LR9SxVPgwU12x10RvFaTeyDiCjdRiicfkrCGLNvc,1030
-boneio/schema/actions_sensor.yaml,sha256=LhXEsYsg6qs7iHqgQE6n-2jj-o-ZZRusDW_9nWIiZAY,129
-boneio/schema/actions_switch.yaml,sha256=qyooX0izkgl4wBEh8xUsYFEKMrvhbIAQYxOGTB5AROY,124
+boneio/schema/actions_sensor.yaml,sha256=U_VfdjqdorQZHYD6dZOzhlRKnOGwsnTJ3CDGiqrKxW8,124
+boneio/schema/actions_switch.yaml,sha256=sdqhwz0LrcfaiAN3-RfAR_xApxo5dh9RxXQubuKcsjk,129
 boneio/schema/filters.yaml,sha256=WopX1SmCZsSZXNiGccLoi7uMCsUpdbs0eVfsAjmbay4,286
 boneio/schema/filters_adc.yaml,sha256=3e0ts92MoFKOnfGOOn6WYIHxu0-tnZe9OjAjN9m7hiI,304
 boneio/schema/id.yaml,sha256=vHI_6dxkJwoiGp5ien_pPpyaWA1F06eirTgfWMyWa1E,75
-boneio/schema/schema.yaml,sha256=CbwRtUW1cn8H-q_FQSVoXyTsPYFKOrzxA5hW-JeXTK4,12551
+boneio/schema/schema.yaml,sha256=GHqcUaCUJypX2JD7tXVKoIZ3XO4rqLaoHW0ppWFWvzU,12988
 boneio/schema/temp_unit.yaml,sha256=m32VGz9RTW92Lz08l9n6RftkcVNZquOGPPr5mc3eZVc,65
 boneio/schema/update_interval.yaml,sha256=L_YLddAZdybcdO-T57Qhlv1GaWIVDwhvH-GadD1oOIo,133
 boneio/sensor/__init__.py,sha256=VjFBEQQv_U0T2ENkzefuBdzmqNvBTEv4M-gQKScc8o0,431
 boneio/sensor/adc.py,sha256=Yf5F8JcZJt0K4ijpPqI8do0BqDfLvfja_LE8_Zu3u7U,1281
-boneio/sensor/gpio.py,sha256=a4rn4cALZBPqqU-nlpzOjpPd8MjEAnxBTCS6pdJ0tpA,1289
+boneio/sensor/gpio.py,sha256=oAUYHGLX0_JK6AJMplmDBnLBIAZ2GaDJ7ts8AceljvQ,1303
 boneio/sensor/modbus/__init__.py,sha256=LEOnMqBACNxZmCN2adZtTsq76gPbsNba5JewMiUENBw,8500
 boneio/sensor/modbus/dts1964_3f.json,sha256=WABph_2X4OgMidSM28vw4dLd9ZByRoiUP-RqE0UMpR8,8810
 boneio/sensor/modbus/pt100.json,sha256=bzKNYDc3lMto94Ut8gutVIsHytQiMobwFCkonOiMegs,526
@@ -69,9 +69,9 @@ boneio/sensor/temp/__init__.py,sha256=h5rGbkC8K6y2GJSNHtm9f8EmoBS3wFlSNIFjcrRj47
 boneio/sensor/temp/dallas.py,sha256=xrvd1LNBh1fRcjz_yd_9S29Lv26ItVtLCmhZgVQWJos,2485
 boneio/sensor/temp/lm75.py,sha256=-mpOv78429plRPBp9s09Ljz1x2Bdxuagalqz40vlAKE,243
 boneio/sensor/temp/mcp9808.py,sha256=yAh5yJzZLGTqa39xV4fyqsruj7oy3niOZAUV2W6eyCM,271
-boneio/version.py,sha256=c4Y90PQyvZ4QIDtX6BiDOphICDX-64mrmDrLk75FXoU,41
-boneIO-0.6.0.dev4.dist-info/entry_points.txt,sha256=Igl1SMDEWwMg144bwRz28UOCb80hdxomC99QJ3u6qC0,46
-boneIO-0.6.0.dev4.dist-info/WHEEL,sha256=lsei1NEk3eJVaxXEuOSSqU002B_yCocFbsEPxBs2x2s,87
-boneIO-0.6.0.dev4.dist-info/METADATA,sha256=S4FUlkbD_kjqB7DboCk17eVjdIYKWoLk_8aSxXLVvTI,1696
-boneIO-0.6.0.dev4.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-boneIO-0.6.0.dev4.dist-info/RECORD,,
+boneio/version.py,sha256=MRoHBbiT0xKVNIGf8uc_weaaaOMvuoXa9HcssIlg3_0,41
+boneIO-0.6.0.dev5.dist-info/entry_points.txt,sha256=Igl1SMDEWwMg144bwRz28UOCb80hdxomC99QJ3u6qC0,46
+boneIO-0.6.0.dev5.dist-info/WHEEL,sha256=B19PGBCYhWaz2p_UjAoRVh767nYQfk14Sn4TpIZ-nfU,87
+boneIO-0.6.0.dev5.dist-info/METADATA,sha256=b5xgbS9_foPU_jVQq9CPRUDE1XV9Ceq_LlI0e6KBz9U,1698
+boneIO-0.6.0.dev5.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+boneIO-0.6.0.dev5.dist-info/RECORD,,

boneIO-0.6.0.dev5.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: pdm-pep517 1.1.4
+Root-Is-Purelib: true
+Tag: py3-none-any

boneio/bonecli.py

@@ -1,9 +1,11 @@
 """Bonecli script."""
+from __future__ import annotations
 import argparse
 import asyncio
 import logging
 import sys
 import os
+from typing import Any
 
 os.environ["W1THERMSENSOR_NO_KERNEL_MODULE"] = "1"
 
@@ -12,7 +14,7 @@ from yaml import MarkedYAMLError
 
 from boneio.const import ACTION
 from boneio.helper import load_config_from_file
-from boneio.helper.exceptions import ConfigurationException
+from boneio.helper.exceptions import ConfigurationException, RestartRequestException
 from boneio.helper.logger import configure_logger
 from boneio.runner import async_run
 from boneio.version import __version__
@@ -69,7 +71,7 @@ def get_arguments() -> argparse.Namespace:
     return arguments
 
 
-def run(config: str, debug: int, mqttusername: str = "", mqttpassword: str = ""):
+def run(config: str, debug: int, mqttusername: str = "", mqttpassword: str = "") -> int:
     """Run BoneIO."""
     _LOGGER.info("BoneIO %s starting.", __version__)
     try:
@@ -78,7 +80,7 @@ def run(config: str, debug: int, mqttusername: str = "", mqttpassword: str = "")
             _LOGGER.error("Config not loaded. Exiting.")
             return 1
         configure_logger(log_config=_config.get("logger"), debug=debug)
-        return asyncio.run(
+        asyncio.run(
             async_run(
                 config=_config,
                 config_file=config,
@@ -86,6 +88,10 @@ def run(config: str, debug: int, mqttusername: str = "", mqttpassword: str = "")
                 mqttpassword=mqttpassword,
             ),
         )
+        return 0
+    except RestartRequestException as err:
+        _LOGGER.info(err)
+        return 0
     except (ConfigurationException, MarkedYAMLError) as err:
         _LOGGER.error("Failed to load config. %s Exiting.", err)
         return 1

boneio/helper/config.py

@@ -1,9 +1,9 @@
 """
 Module to provide basic config options.
 """
+from __future__ import annotations
 from _collections_abc import dict_values
-
-from boneio.const import BONEIO, HOMEASSISTANT
+from boneio.const import BONEIO, HOMEASSISTANT, LIGHT, SENSOR, COVER, BUTTON, SWITCH, BINARY_SENSOR
 
 
 class ConfigHelper:
@@ -16,7 +16,16 @@ class ConfigHelper:
         self._topic_prefix = topic_prefix
         self._ha_discovery = ha_discovery
         self._ha_discovery_prefix = ha_discovery_prefix
-        self._autodiscovery_messages = {}
+        self._fetch_old_discovery = None
+        self._autodiscovery_messages = {
+            SWITCH: {},
+            LIGHT: {},
+            BINARY_SENSOR: {},
+            SENSOR: {},
+            COVER: {},
+            BUTTON: {}
+        }
+        self.manager_ready: bool = False
 
     @property
     def topic_prefix(self) -> str:
@@ -38,11 +47,28 @@ class ConfigHelper:
     def subscribe_topic(self) -> str:
         return f"{self.cmd_topic_prefix}+/+/#"
 
-    def add_autodiscovery_msg(self, topic: str, payload: str):
+    def add_autodiscovery_msg(self, ha_type: str, topic: str, payload: str):
         """Add autodiscovery message."""
-        self._autodiscovery_messages[topic] = {"topic": topic, "payload": payload}
+        self._autodiscovery_messages[ha_type][topic] = {"topic": topic, "payload": payload}
+
+    @property
+    def ha_types(self) -> list[str]:
+        return list(self._autodiscovery_messages.keys())
+
+    def is_topic_in_autodiscovery(self, topic: str) -> bool:
+        topic_parts_raw = topic[len(f"{self._ha_discovery_prefix}/") :].split("/")
+        ha_type = topic_parts_raw[0]
+        if ha_type in self._autodiscovery_messages:
+            if topic in self._autodiscovery_messages[ha_type]:
+                return True
+        return False
+
+
 
     @property
     def autodiscovery_msgs(self) -> dict_values:
         """Get autodiscovery messages"""
-        return self._autodiscovery_messages.values()
+        output = {}
+        for ha_type in self._autodiscovery_messages:
+            output.update(self._autodiscovery_messages[ha_type])
+        return output.values()

boneio/helper/exceptions.py

@@ -8,6 +8,7 @@ class BoneIOException(Exception):
 class GPIOInputException(BoneIOException):
     """GPIOInput Exception."""
 
+
 class GPIOOutputException(BoneIOException):
     """GPIOInput Exception."""
 
@@ -30,3 +31,7 @@ class CoverRelayException(BoneIOException):
 
 class ModbusUartException(BoneIOException):
     """Cover configuration exception."""
+
+
+class RestartRequestException(BoneIOException):
+    """Restart exception."""

boneio/helper/ha_discovery.py

@@ -51,6 +51,7 @@ def ha_light_availabilty_message(id: str, topic: str = "boneIO", **kwargs):
     msg["state_value_template"] = "{{ value_json.state }}"
     return msg
 
+
 def ha_led_availabilty_message(id: str, topic: str = "boneIO", **kwargs):
     """Create LED availability topic for HA."""
     msg = ha_availabilty_message(device_type=RELAY, topic=topic, id=id, **kwargs)
@@ -64,11 +65,14 @@ def ha_led_availabilty_message(id: str, topic: str = "boneIO", **kwargs):
     msg["brightness_value_template"] = "{{ value_json.brightness }}"
     return msg
 
-def ha_button_availabilty_message(id: str, topic: str = "boneIO", **kwargs):
+
+def ha_button_availabilty_message(
+    id: str, topic: str = "boneIO", payload_press: str = "reload", **kwargs
+):
     """Create BUTTON availability topic for HA."""
     msg = ha_availabilty_message(device_type="button", topic=topic, id=id, **kwargs)
     msg["command_topic"] = f"{topic}/cmd/button/{id}/set"
-    msg["payload_press"] = "reload"
+    msg["payload_press"] = payload_press
     return msg
 
 
@@ -102,9 +106,11 @@ def ha_sensor_availabilty_message(unit_of_measurement: str = None, **kwargs):
         return msg
 
 
-def ha_binary_sensor_availabilty_message(id: str, name: str, topic: str = "boneIO"):
+def ha_binary_sensor_availabilty_message(id: str, name: str, device_class: str, topic: str = "boneIO"):
     """Create availability topic for HA."""
+    kwargs = {"device_class": device_class} if device_class else {}
     return {
+        **kwargs,
         "availability": [{"topic": f"{topic}/{STATE}"}],
         "device": {
             "identifiers": [topic],

boneio/helper/loader.py

@@ -354,6 +354,7 @@ def configure_input(
                 id=pin,
                 name=gpio.get(ID, pin),
                 ha_type=getattr(input, "ha_type"),
+                device_class=gpio.get(DEVICE_CLASS, None),
                 availability_msg_func=getattr(input, "availability_msg_f"),
             )
         return pin

boneio/helper/mqtt.py

@@ -21,11 +21,11 @@ class BasicMqtt:
         self._send_topic = f"{topic_prefix}/{topic_type}/{self.id}"
 
     @property
-    def id(self) -> bool:
+    def id(self) -> str:
         """Id of the module."""
         return self._id
 
     @property
-    def name(self):
+    def name(self) -> str:
         """Return name of the sensor."""
         return self._name

boneio/input/gpio.py

@@ -53,7 +53,7 @@ class GpioInputButton(GpioBaseClass):
             self.check_state(state=self.is_pressed)
             await asyncio.sleep(self._bounce_time.total_in_seconds)
 
-    def check_state(self, state):
+    def check_state(self, state: bool) -> None:
         if state == self._state:
             return
         self._state = state

boneio/manager.py

@@ -1,7 +1,7 @@
 import asyncio
 import logging
 from collections import deque
-from typing import Callable, Coroutine, List, Optional, Set, Union
+from typing import Callable, Coroutine, List, Optional, Set, Union, Awaitable
 from board import SCL, SDA
 from busio import I2C
 
@@ -80,34 +80,35 @@ class Manager:
     def __init__(
         self,
         send_message: Callable[[str, Union[str, dict], bool], None],
+        stop_client: Callable[[], Awaitable[None]],
         state_manager: StateManager,
         config_helper: ConfigHelper,
         config_file_path: str,
         relay_pins: List = [],
         input_pins: List = [],
         sensors: dict = {},
-        modbus: dict = None,
-        pca9685: Optional[List] = None,
-        mcp23017: Optional[List] = None,
+        modbus: dict = {},
+        pca9685: list = [],
+        mcp23017: list = [],
         ds2482: Optional[List] = [],
         dallas: Optional[dict] = None,
         oled: dict = {},
-        adc_list: Optional[List] = None,
-        covers: Optional[List] = [],
+        adc: Optional[List] = None,
+        cover: list = [],
     ) -> None:
         """Initialize the manager."""
         _LOGGER.info("Initializing manager module.")
 
         self._loop = asyncio.get_event_loop()
-        used_pins = set()
+
         self._config_helper = config_helper
         self._host_data = None
         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.stop_client = stop_client
         self._input_pins = input_pins
         self._i2cbusio = I2C(SCL, SDA)
         self._mcp = {}
@@ -135,7 +136,7 @@ class Manager:
             create_pca9685(manager=self, pca9685=pca9685, i2cbusio=self._i2cbusio)
         )
 
-        self._configure_adc(adc_list=adc_list)
+        self._configure_adc(adc_list=adc)
 
         for _config in relay_pins:
             _id = _config[ID].replace(" ", "")
@@ -166,7 +167,7 @@ class Manager:
                 out.send_state,
             )
 
-        for _config in covers:
+        for _config in cover:
             _id = _config[ID].replace(" ", "")
             open_relay = self._output.get(_config.get("open_relay"))
             close_relay = self._output.get(_config.get("close_relay"))
@@ -204,24 +205,12 @@ class Manager:
             )
 
         _LOGGER.info("Initializing inputs. This will take a while.")
-        for gpio in self._input_pins:
-            pin = gpio.pop(PIN)
-            if pin in used_pins:
-                _LOGGER.warn("This PIN %s is already configured. Omitting it.", pin)
-                continue
-            used_pins.add(
-                configure_input(
-                    gpio=gpio,
-                    pin=pin,
-                    press_callback=self.press_callback,
-                    send_ha_autodiscovery=self.send_ha_autodiscovery,
-                )
-            )
+        self.configure_inputs(reload_config=False)
 
         if oled.get("enabled", False):
             from boneio.oled import Oled
 
-            screens = oled.get("screens")
+            screens = oled.get("screens", [])
 
             self._host_data = HostData(
                 manager=self,
@@ -240,9 +229,26 @@ class Manager:
             except (GPIOInputException, I2CError) as err:
                 _LOGGER.error("Can't configure OLED display. %s", err)
         self.prepare_ha_buttons()
-
         _LOGGER.info("BoneIO manager is ready.")
 
+    def configure_inputs(self, reload_config: bool = False):
+        used_pins = set()
+        if reload_config:
+            load_config_from_file(self._config_file_path)
+        for gpio in self._input_pins:
+            pin = gpio.pop(PIN)
+            if pin in used_pins:
+                _LOGGER.warn("This PIN %s is already configured. Omitting it.", pin)
+                continue
+            used_pins.add(
+                configure_input(
+                    gpio=gpio,
+                    pin=pin,
+                    press_callback=self.press_callback,
+                    send_ha_autodiscovery=self.send_ha_autodiscovery,
+                )
+            )
+
     def append_task(self, coro: Coroutine, name: str = "Unknown") -> asyncio.Future:
         """Add task to run with asyncio loop."""
         _LOGGER.debug("Appending update task for %s", name)
@@ -337,20 +343,22 @@ class Manager:
             )
 
     def _configure_modbus(self, modbus: dict) -> None:
-        if modbus and modbus.get(UART) in UARTS:
+        uart = modbus.get(UART)
+        if uart and uart in UARTS:
             try:
-                self._modbus = Modbus(UARTS[modbus.get(UART)])
+                self._modbus = Modbus(UARTS[uart])
             except ModbusUartException:
                 _LOGGER.error(
                     "This UART %s can't be used for modbus communication.",
-                    modbus.get(UART),
+                    uart,
                 )
                 self._modbus = None
 
     def _configure_temp_sensors(self, sensors: dict) -> None:
         for sensor_type in (LM75, MCP_TEMP_9808):
-            if sensors.get(sensor_type):
-                for temp_def in sensors.get(sensor_type):
+            sensor = sensors.get(sensor_type)
+            if sensor:
+                for temp_def in sensor:
                     temp_sensor = create_temp_sensor(
                         manager=self,
                         topic_prefix=self._config_helper.topic_prefix,
@@ -409,10 +417,19 @@ class Manager:
     def prepare_ha_buttons(self) -> None:
         """Prepare HA buttons for reload."""
         self.send_ha_autodiscovery(
-            id="Logger",
+            id="logger",
             name="Logger reload",
             ha_type=BUTTON,
             availability_msg_func=ha_button_availabilty_message,
+            entity_category="config",
+        )
+        self.send_ha_autodiscovery(
+            id="restart",
+            name="Restart boneIO",
+            ha_type=BUTTON,
+            payload_press="restart",
+            availability_msg_func=ha_button_availabilty_message,
+            entity_category="config",
         )
 
     @property
@@ -431,7 +448,7 @@ class Manager:
         """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._config_helper.topic_prefix}/{input_type}/{inpin}"
-        self.send_message(topic=topic, payload=x)
+        self.send_message(topic=topic, payload=x, retain=False)
         for action_definition in actions:
             _LOGGER.debug("Executing action %s", action_definition)
             if action_definition[ACTION] == OUTPUT:
@@ -480,13 +497,14 @@ class Manager:
         payload = availability_msg_func(topic=topic_prefix, id=id, name=name, **kwargs)
         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._config_helper.add_autodiscovery_msg(topic=topic, payload=payload)
+        self._config_helper.add_autodiscovery_msg(topic=topic, ha_type=ha_type, payload=payload)
         self.send_message(topic=topic, payload=payload, retain=True)
 
     def resend_autodiscovery(self) -> None:
         for msg in self._config_helper.autodiscovery_msgs:
             self.send_message(**msg, retain=True)
 
+
     async def receive_message(self, topic: str, message: str) -> None:
         """Callback for receiving action from Mqtt."""
         _LOGGER.debug("Processing topic %s with message %s.", topic, message)
@@ -558,6 +576,9 @@ class Manager:
             if device_id == "logger" and message == "reload":
                 _LOGGER.info("Reloading logger configuration.")
                 self._logger_reload()
+            elif device_id == "restart" and message == "restart":
+                _LOGGER.info("Exiting process. Systemd should restart it soon.")
+                await self.stop_client()
 
     @property
     def output(self) -> dict:

boneio/mqtt_client.py

@@ -2,12 +2,13 @@
 Provide an MQTT client for providing BoneIO MQTT broker.
 Code based on cgarwood/python-openzwave-mqtt.
 """
+from __future__ import annotations
 import asyncio
 import json
 import logging
 import uuid
 from contextlib import AsyncExitStack
-from typing import Any, Callable, Optional, Set, Tuple, Union
+from typing import Any, Callable, Optional, Set, Union, Awaitable
 
 import paho.mqtt.client as mqtt
 from asyncio_mqtt import Client as AsyncioClient
@@ -18,6 +19,8 @@ from paho.mqtt.subscribeoptions import SubscribeOptions
 from boneio.const import ONLINE, PAHO, STATE
 from boneio.helper import UniqueQueue
 from boneio.helper.config import ConfigHelper
+from boneio.manager import Manager
+from boneio.helper.exceptions import RestartRequestException
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -45,6 +48,8 @@ class MQTTClient:
         self.reconnect_interval = 1
         self._connection_established = False
         self.publish_queue: UniqueQueue = UniqueQueue()
+        self._discovery_topics = [f"{self._config_helper.ha_discovery_prefix}/{ha_type}/{self._config_helper.topic_prefix}/#" for ha_type in self._config_helper.ha_types] if self._config_helper.ha_discovery else []
+        self._topics = [self._config_helper.subscribe_topic, "homeassistant/status"]
 
     def create_client(self) -> None:
         """Create the asyncio client."""
@@ -85,7 +90,7 @@ class MQTTClient:
 
     async def subscribe(  # pylint:disable=too-many-arguments
         self,
-        topics: Tuple[str, str],
+        topics: list[str],
         qos: int = 0,
         options: Optional[SubscribeOptions] = None,
         properties: Optional[Properties] = None,
@@ -108,7 +113,10 @@ class MQTTClient:
         await self.asyncio_client.subscribe(topic=args, **params, timeout=timeout)
 
     async def unsubscribe(
-        self, topic: str, properties: Optional[Properties] = None, timeout: float = 10.0
+        self,
+        topics: list[str],
+        properties: Optional[Properties] = None,
+        timeout: float = 10.0,
     ) -> None:
         """Unsubscribe from topic.
 
@@ -118,10 +126,10 @@ class MQTTClient:
         if properties:
             params["properties"] = properties
 
-        await self.asyncio_client.unsubscribe(topic, **params)
+        await self.asyncio_client.unsubscribe(topic=topics, **params)
 
     def send_message(
-        self, topic: str, payload: Union[str, dict], retain: bool = False
+        self, topic: str, payload: Union[str, dict, None], retain: bool = False
     ) -> None:
         """Send a message from the manager options."""
         to_publish = (
@@ -138,7 +146,7 @@ class MQTTClient:
             await self.publish(*to_publish)
             self.publish_queue.task_done()
 
-    async def start_client(self, manager: any) -> None:
+    async def start_client(self, manager: Manager) -> None:
         """Start the client with the manager."""
         # Reconnect automatically until the client is stopped.
         while True:
@@ -155,7 +163,13 @@ class MQTTClient:
                 await asyncio.sleep(self.reconnect_interval)
                 self.create_client()  # reset connect/reconnect futures
 
-    async def _subscribe_manager(self, manager: any) -> None:
+    async def stop_client(self) -> None:
+        await self.unsubscribe(
+            topics=self._topics
+        )
+        raise RestartRequestException("Restart requested.")
+
+    async def _subscribe_manager(self, manager: Manager) -> None:
         """Connect and subscribe to manager topics + host stats."""
         async with AsyncExitStack() as stack:
             tasks: Set[asyncio.Task] = set()
@@ -170,11 +184,11 @@ class MQTTClient:
 
             # Messages that doesn't match a filter will get logged and handled here.
             messages = await stack.enter_async_context(
-                self.asyncio_client.unfiltered_messages()
+                self.asyncio_client.messages()
             )
 
             messages_task = asyncio.create_task(
-                handle_messages(messages, manager.receive_message)
+                self.handle_messages(messages, manager.receive_message)
             )
             if not self._connection_established:
                 self._connection_established = True
@@ -183,16 +197,28 @@ class MQTTClient:
             tasks.add(messages_task)
 
             await self.subscribe(
-                topics=(self._config_helper.subscribe_topic, "homeassistant/status")
+                topics=self._topics
+            )
+            await self.subscribe(
+                topics=self._discovery_topics
             )
 
             # Wait for everything to complete (or fail due to, e.g., network errors).
             await asyncio.gather(*tasks)
 
-
-async def handle_messages(messages: Any, callback: Callable[[str, str], None]) -> None:
-    """Handle messages with callback."""
-    async for message in messages:
-        payload = message.payload.decode()
-        _LOGGER.debug("Received message topic: %s, payload: %s", message.topic, payload)
-        await callback(message.topic, payload)
+    async def handle_messages(self, messages: Any, callback: Callable[[str, str], Awaitable[None]]):
+        """Handle messages with callback or remove osbolete HA discovery messages."""
+        async for message in messages:
+            payload = message.payload.decode()
+            callback_start = True
+            for discovery_topic in self._discovery_topics:
+                if message.topic.matches(discovery_topic):
+                    callback_start = False
+                    topic = str(message.topic)
+                    if message.payload and not self._config_helper.is_topic_in_autodiscovery(topic):
+                        _LOGGER.info("Removing unused discovery entity %s", topic)
+                        self.send_message(topic=topic, payload=None, retain=True)
+                    break
+            if callback_start:
+                _LOGGER.debug("Received message topic: %s, payload: %s", message.topic, payload)
+                await callback(str(message.topic), payload)

boneio/relay/basic.py

@@ -49,13 +49,13 @@ class BasicRelay(BasicMqtt):
         return self._output_type == LIGHT
 
     @property
-    def id(self) -> bool:
+    def id(self) -> str:
         """Id of the relay.
         Has to be trimmed out of spaces because of MQTT handling in HA."""
         return self._id or self._pin
 
     @property
-    def name(self) -> bool:
+    def name(self) -> str:
         """Not trimmed id."""
         return self._name or self._pin
 
@@ -70,8 +70,7 @@ class BasicRelay(BasicMqtt):
         self._state = state
         if self.output_type != NONE:
             self._send_message(
-                topic=self._send_topic,
-                payload={STATE: state},
+                topic=self._send_topic, payload={STATE: state}, retain=True
             )
         self._loop.call_soon_threadsafe(self._callback)
 

boneio/runner.py

@@ -1,7 +1,9 @@
 """Runner code for boneIO. Based on HA runner."""
+from __future__ import annotations
 import asyncio
 import logging
 import os
+from typing import Any
 
 from boneio.const import (
     ADC,
@@ -34,13 +36,24 @@ from boneio.mqtt_client import MQTTClient
 
 _LOGGER = logging.getLogger(__name__)
 
+config_modules = [
+    {"name": MCP23017, "default": []},
+    {"name": PCA9685, "default": []},
+    {"name": DS2482, "default": []},
+    {"name": ADC, "default": []},
+    {"name": COVER, "default": []},
+    {"name": MODBUS, "default": {}},
+    {"name": OLED, "default": {}},
+    {"name": DALLAS, "default": None},
+]
+
 
 async def async_run(
     config: dict,
     config_file: str,
     mqttusername: str = "",
     mqttpassword: str = "",
-):
+) -> list[Any]:
     """Run BoneIO."""
 
     _config_helper = ConfigHelper(
@@ -56,9 +69,14 @@ async def async_run(
         port=config[MQTT].get(PORT, 1883),
         config_helper=_config_helper,
     )
+    manager_kwargs = {
+        item["name"]: config.get(item["name"], item["default"])
+        for item in config_modules
+    }
 
     manager = Manager(
         send_message=client.send_message,
+        stop_client=client.stop_client,
         relay_pins=config.get(OUTPUT, []),
         input_pins=config.get(INPUT, []),
         config_file_path=config_file,
@@ -72,14 +90,7 @@ async def async_run(
             MODBUS: config.get("modbus_sensors"),
             ONEWIRE: config.get(SENSOR, []),
         },
-        mcp23017=config.get(MCP23017, []),
-        pca9685=config.get(PCA9685, []),
-        ds2482=config.get(DS2482, []),
-        dallas=config.get(DALLAS),
-        modbus=config.get(MODBUS),
-        oled=config.get(OLED),
-        adc_list=config.get(ADC, []),
-        covers=config.get(COVER, []),
+        **manager_kwargs,
     )
     tasks = set()
     tasks.update(manager.get_tasks())

boneio/schema/actions_sensor.yaml

@@ -1,6 +1,6 @@
 required: False
 type: list
-excludes: ["single", "double", "long"]
+excludes: ["pressed", "released"]
 dependencies:
   kind: ['sensor']
 schema: !include actions.yaml

boneio/schema/actions_switch.yaml

@@ -1,6 +1,6 @@
 required: False
 type: list
-excludes: ["pressed", "released"]
+excludes: ["single", "double", "long"]
 dependencies:
   kind: ['switch']
 schema: !include actions.yaml

boneio/schema/schema.yaml

@@ -376,6 +376,12 @@ input:
         required: True
         meta:
           label: Check if sensor type is inverted. Only aplicable for sensor kind.
+      device_class:
+        type: string
+        required: False
+        allowed: ["battery", "battery_charging", "carbon_monoxide", "cold", "connectivity", "door", "garage_door", "gas", "heat", "light", "lock", "moisture", "motion", "moving", "occupancy", "opening", "plug", "power", "presence", "problem", "running", "safety", "smoke", "sound", "tamper", "vibration", "window"]
+        meta:
+          label: Device class to use in HA
       actions:
         required: False
         type: dict

boneio/sensor/gpio.py

@@ -1,7 +1,7 @@
 """GPIOInputButton to receive signals."""
 import logging
 from functools import partial
-
+import asyncio
 from boneio.const import BOTH, PRESSED, RELEASED
 from boneio.helper import GpioBaseClass, edge_detect
 
@@ -14,24 +14,25 @@ class GpioInputSensor(GpioBaseClass):
     def __init__(self, **kwargs) -> None:
         """Setup GPIO Input Button"""
         super().__init__(**kwargs)
+        self._state = self.is_pressed
         self._click_type = (
             (RELEASED, PRESSED)
             if kwargs.get("inverted", False)
             else (PRESSED, RELEASED)
         )
-        edge_detect(
-            self._pin,
-            callback=self._handle_press,
-            bounce=self._bounce_time.total_milliseconds,
-            edge=BOTH,
-        )
-        self._loop.call_soon(self._handle_press, self._pin)
         _LOGGER.debug("Configured sensor pin %s", self._pin)
+        asyncio.create_task(self._run())
+
+    async def _run(self) -> None:
+        while True:
+            self.check_state(state=self.is_pressed)
+            await asyncio.sleep(self._bounce_time.total_in_seconds)
 
-    def _handle_press(self, pin: str) -> None:
-        """Handle the button press callback"""
-        # Ignore if we are in a long press
-        click_type = self._click_type[0] if self.is_pressed else self._click_type[1]
+    def check_state(self, state: bool) -> None:
+        if state == self._state:
+            return
+        self._state = state
+        click_type = self._click_type[0] if state else self._click_type[1]
         _LOGGER.debug("%s event on pin %s", click_type, self._pin)
         self._loop.call_soon_threadsafe(
             partial(self._press_callback, click_type, self._pin)

boneio/version.py

@@ -1,2 +1,2 @@
 # flake8: noqa
-__version__ = "0.6.0dev4"
+__version__ = "0.6.0dev5"

boneIO-0.6.0.dev4.dist-info/WHEEL

@@ -1,4 +0,0 @@
-Wheel-Version: 1.0
-Generator: pdm-pep517 1.1.3
-Root-Is-Purelib: True
-Tag: py3-none-any