boneIO 0.5.0__tar.gz → 0.5.0.dev1__tar.gz

{boneIO-0.5.0 → boneIO-0.5.0.dev1}/PKG-INFO

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

{boneIO-0.5.0 → boneIO-0.5.0.dev1}/boneio/bonecli.py

@@ -3,9 +3,6 @@ import argparse
 import asyncio
 import logging
 import sys
-import os
-
-os.environ["W1THERMSENSOR_NO_KERNEL_MODULE"] = "1"
 
 from colorlog import ColoredFormatter
 from yaml import MarkedYAMLError

{boneIO-0.5.0 → boneIO-0.5.0.dev1}/boneio/const.py

@@ -136,4 +136,3 @@ Gpio_Edges = Literal[BOTH, FALLING]
 InputTypes = Literal[INPUT, INPUT_SENSOR]
 DEVICE_CLASS = "device_class"
 DallasBusTypes = Literal[DS2482, DALLAS]
-FILTERS = "filters"

{boneIO-0.5.0 → boneIO-0.5.0.dev1}/boneio/cover.py

@@ -1,5 +1,4 @@
 """Cover module."""
-from __future__ import annotations
 import asyncio
 import logging
 from typing import Callable
@@ -109,24 +108,24 @@ class Cover(BasicMqtt):
         self._stop_cover(on_exit=True)
 
     @property
-    def cover_state(self) -> CLOSED | OPEN:
+    def cover_state(self):
         """Current state of cover."""
         return CLOSED if self._closed else OPEN
 
-    def stop(self) -> None:
+    def stop(self):
         """Public Stop cover graceful."""
         _LOGGER.info("Stopping cover %s.", self._id)
         if self._current_operation != IDLE:
             self._stop_cover(on_exit=False)
 
-    def send_state(self) -> None:
+    def send_state(self):
         """Send state of cover to mqtt."""
         self._send_message(topic=f"{self._send_topic}/state", payload=self.cover_state)
         pos = round(self._position, 0)
         self._send_message(topic=f"{self._send_topic}/pos", payload=str(pos))
         self._state_save(position=pos)
 
-    def _stop_cover(self, on_exit=False) -> None:
+    def _stop_cover(self, on_exit=False):
         """Stop cover."""
         self._open.relay.turn_off()
         self._close.relay.turn_off()
@@ -139,11 +138,11 @@ class Cover(BasicMqtt):
         self._current_operation = IDLE
 
     @property
-    def current_cover_position(self) -> int:
+    def current_cover_position(self):
         """Return the current position of the cover."""
         return round(self._position, 0)
 
-    def listen_cover(self, *args) -> None:
+    def listen_cover(self, *args):
         """Listen for change in cover."""
         if self._current_operation == IDLE:
             return
@@ -179,7 +178,7 @@ class Cover(BasicMqtt):
 
         self._closed = self.current_cover_position <= 0
 
-    async def close_cover(self) -> None:
+    async def close_cover(self):
         """Close cover."""
         if self._position == 0:
             return
@@ -194,7 +193,7 @@ class Cover(BasicMqtt):
             current_operation=CLOSING,
         )
 
-    async def open_cover(self) -> None:
+    async def open_cover(self):
         """Open cover."""
         if self._position == 100:
             return
@@ -209,7 +208,7 @@ class Cover(BasicMqtt):
             current_operation=OPENING,
         )
 
-    async def set_cover_position(self, position: int) -> None:
+    async def set_cover_position(self, position: int):
         """Move cover to a specific position."""
         set_position = round(position, -1)
         if self._position == position or set_position == self._set_position:
@@ -229,29 +228,29 @@ class Cover(BasicMqtt):
             current_operation=current_operation,
         )
 
-    def open(self) -> None:
+    def open(self):
         _LOGGER.debug("Opening cover %s.", self._id)
         asyncio.create_task(self.open_cover())
 
-    def close(self) -> None:
+    def close(self):
         _LOGGER.debug("Closing cover %s.", self._id)
         asyncio.create_task(self.close_cover())
 
-    def toggle(self) -> None:
+    def toggle(self):
         _LOGGER.debug("Toggle cover %s from input.", self._id)
         if self.cover_state == CLOSED:
             self.close()
         else:
             self.open()
 
-    def toggle_open(self) -> None:
+    def toggle_open(self):
         _LOGGER.debug("Toggle open cover %s from input.", self._id)
         if self._current_operation != IDLE:
             self.stop()
         else:
             self.open()
 
-    def toggle_close(self) -> None:
+    def toggle_close(self):
         _LOGGER.debug("Toggle close cover %s from input.", self._id)
         if self._current_operation != IDLE:
             self.stop()

{boneIO-0.5.0 → boneIO-0.5.0.dev1}/boneio/helper/gpio.py

@@ -90,8 +90,9 @@ class GpioBaseClass:
     ) -> None:
         """Setup GPIO Input Button"""
         self._pin = pin
-        gpio_mode = kwargs.get(GPIO_MODE, GPIO_STR)
-        self._bounce_time = kwargs.get("bounce_time", TimePeriod(milliseconds=10))
+        gpio = kwargs.get("rest_pin", {GPIO_MODE: GPIO_STR})
+        gpio_mode = gpio.get(GPIO_MODE, GPIO_STR)
+        self._bounce_time = gpio.get("bounce_time", TimePeriod(milliseconds=10))
         self._loop = asyncio.get_running_loop()
         self._press_callback = press_callback
         setup_input(pin=self._pin, pull_mode=gpio_mode)

{boneIO-0.5.0 → boneIO-0.5.0.dev1}/boneio/helper/ha_discovery.py

@@ -109,9 +109,7 @@ def ha_binary_sensor_availabilty_message(id: str, name: str, topic: str = "boneI
     }
 
 
-def ha_sensor_temp_availabilty_message(
-    id: str, name: str, topic: str = "boneIO", **kwargs
-):
+def ha_sensor_temp_availabilty_message(id: str, name: str, topic: str = "boneIO"):
     """Create availability topic for HA."""
     return {
         "availability": [{"topic": f"{topic}/{STATE}"}],
@@ -127,8 +125,8 @@ def ha_sensor_temp_availabilty_message(
         "unique_id": f"{topic}{SENSOR}{id}",
         "device_class": "temperature",
         "state_class": "measurement",
+        "unit_of_measurement": "°C",
         "value_template": "{{ value_json.state }}",
-        **kwargs,
     }
 
 
@@ -154,7 +152,7 @@ def modbus_sensor_availabilty_message(
         },
         "name": sensor_id,
         "state_topic": f"{topic}/{device_type}/{id}/{state_topic_base}",
-        "unique_id": f"{topic}{sensor_id.replace('_', '').lower()}{name.lower()}",
+        "unique_id": f"{topic}{sensor_id.replace('_', '').lower()}",
         **kwargs,
     }
 

{boneIO-0.5.0 → boneIO-0.5.0.dev1}/boneio/helper/loader.py

@@ -13,7 +13,6 @@ from boneio.const import (
     BINARY_SENSOR,
     COVER,
     DEVICE_CLASS,
-    FILTERS,
     GPIO,
     ID,
     INIT_SLEEP,
@@ -108,7 +107,7 @@ def create_temp_sensor(
     topic_prefix: str,
     sensor_type: str,
     i2cbusio: I2C,
-    config: dict = {},
+    temp_def: dict = {},
 ):
     """Create LM sensor in manager."""
     if sensor_type == LM75:
@@ -117,26 +116,23 @@ def create_temp_sensor(
         from boneio.sensor import MCP9808Sensor as TempSensor
     else:
         return
-    name = config.get(ID)
+    name = temp_def.get(ID)
     id = name.replace(" ", "")
     try:
         temp_sensor = TempSensor(
             id=id,
             name=name,
             i2c=i2cbusio,
-            address=config[ADDRESS],
-            manager=manager,
+            address=temp_def[ADDRESS],
             send_message=manager.send_message,
             topic_prefix=topic_prefix,
-            update_interval=config.get(UPDATE_INTERVAL, TimePeriod(seconds=60)),
-            filters=config.get(FILTERS, []),
+            update_interval=temp_def.get(UPDATE_INTERVAL, TimePeriod(seconds=60)),
         )
         manager.send_ha_autodiscovery(
             id=id,
             name=name,
             ha_type=SENSOR,
             availability_msg_func=ha_sensor_temp_availabilty_message,
-            unit_of_measurement=config.get("unit_of_measurement", "°C"),
         )
         return temp_sensor
     except I2CError as err:
@@ -397,7 +393,6 @@ def create_dallas_sensor(
         name=name,
         update_interval=config.get(UPDATE_INTERVAL, TimePeriod(seconds=60)),
         send_message=manager.send_message,
-        filters=config.get(FILTERS, []),
         **kwargs,
     )
     if config.get(SHOW_HA, True):
@@ -406,6 +401,5 @@ def create_dallas_sensor(
             name=sensor.name,
             ha_type=SENSOR,
             availability_msg_func=ha_sensor_temp_availabilty_message,
-            unit_of_measurement=config.get("unit_of_measurement", "°C"),
         )
     return sensor

{boneIO-0.5.0 → boneIO-0.5.0.dev1}/boneio/helper/stats.py

@@ -4,8 +4,7 @@ from datetime import datetime
 import socket
 import time
 from math import floor
-from typing import Callable, List
-from functools import partial
+from typing import Callable
 
 import psutil
 
@@ -118,32 +117,19 @@ def get_uptime():
 class HostSensor(AsyncUpdater):
     """Host sensor."""
 
-    def __init__(
-        self,
-        update_function: Callable,
-        manager_callback: Callable,
-        static_data: dict,
-        id: str,
-        type: str,
-        **kwargs,
-    ) -> None:
+    def __init__(self, update_function: Callable, static_data: dict, **kwargs) -> None:
         self._update_function = update_function
         self._static_data = static_data
         self._state = None
-        self._type = type
-        self._manager_callback = manager_callback
-        self._loop = asyncio.get_event_loop()
-        self.id = id
         super().__init__(**kwargs)
 
     async def async_update(self, time: datetime) -> None:
         self._state = self._update_function()
-        self._loop.call_soon_threadsafe(partial(self._manager_callback, self._type))
 
     @property
     def state(self) -> dict:
         if self._static_data:
-            return {**self._static_data, self._type: self._state}
+            return {**self._static_data, **self._state}
         return self._state
 
 
@@ -158,7 +144,6 @@ class HostData:
         callback: Callable,
         temp_sensor: Callable[[LM75Sensor, MCP9808Sensor], None],
         manager: Manager,
-        enabled_screens: List[str],
     ) -> None:
         """Initialize HostData."""
         self._hostname = socket.gethostname()
@@ -175,15 +160,10 @@ class HostData:
             },
         }
         for k, _v in host_stats.items():
-            if k not in enabled_screens:
-                continue
-            self.data[k] = HostSensor(
+            self._data[k] = HostSensor(
                 update_function=_v["f"],
                 static_data=_v.get("static"),
                 manager=manager,
-                manager_callback=callback,
-                id=f"{k}_hoststats",
-                type=k,
                 update_interval=_v["update_interval"],
             )
         self._temp_sensor = temp_sensor

{boneIO-0.5.0 → boneIO-0.5.0.dev1}/boneio/helper/yaml_util.py

@@ -135,8 +135,6 @@ def load_config_from_string(config_yaml: str):
     schema = load_yaml_file(schema_file)
     v = CustomValidator(schema, purge_unknown=True)
     v.validate(config_yaml)
-    if v.errors:
-        _LOGGER.error("There are errors in your config %s", v.errors)
     doc = v.normalized(v.document, always_return_document=True)
     # validated = v.validated(document=doc, normalize=True, always_return_document=True)
     # doc = v.normalized(validated, always_return_document=True)
@@ -255,6 +253,7 @@ class CustomValidator(Validator):
 
     def _normalize_coerce_positive_time_period(self, value) -> TimePeriod:
         """Validate and transform time period with time unit and integer value."""
+
         if isinstance(value, int):
             raise ConfigurationException(
                 f"Don't know what '{value}' means as it has no time *unit*! Did you mean '{value}s'?"

{boneIO-0.5.0 → boneIO-0.5.0.dev1}/boneio/manager.py

@@ -2,6 +2,7 @@ import asyncio
 import logging
 from collections import deque
 from typing import Callable, Coroutine, List, Optional, Set, Union
+
 from board import SCL, SDA
 from busio import I2C
 
@@ -59,8 +60,6 @@ from boneio.helper.logger import configure_logger
 from boneio.helper.yaml_util import load_config_from_file
 from boneio.modbus import Modbus
 
-from w1thermsensor.errors import KernelModuleLoadError
-
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -205,11 +204,8 @@ class Manager:
         if oled.get("enabled", False):
             from boneio.oled import Oled
 
-            screens = oled.get("screens")
-
             self._host_data = HostData(
                 manager=self,
-                enabled_screens=screens,
                 output=self.grouped_outputs,
                 temp_sensor=self._temp_sensors[0] if self._temp_sensors else None,
                 callback=self._host_data_callback,
@@ -217,13 +213,12 @@ class Manager:
             try:
                 self._oled = Oled(
                     host_data=self._host_data,
-                    screen_order=screens,
                     output_groups=list(self.grouped_outputs),
                     sleep_timeout=oled.get("screensaver_timeout", 60),
                 )
             except (GPIOInputException, I2CError) as err:
                 _LOGGER.error("Can't configure OLED display. %s", err)
-        self.prepare_ha_buttons()
+            self.prepare_button()
 
         _LOGGER.info("BoneIO manager is ready.")
 
@@ -254,7 +249,6 @@ class Manager:
             from boneio.helper.loader import (
                 configure_ds2482,
             )
-            from boneio.sensor import DallasSensorDS2482
 
             _ds_onewire_bus[_single_ds[ID]] = configure_ds2482(
                 i2cbusio=self._i2cbusio, address=_single_ds[ADDRESS]
@@ -270,35 +264,22 @@ class Manager:
             _LOGGER.debug("Preparing Dallas bus.")
             from boneio.helper.loader import configure_dallas
 
-            try:
-                from w1thermsensor.kernel import load_kernel_modules
-
-                load_kernel_modules()
-                from boneio.sensor.temp.dallas_w1 import DallasSensorW1
-
-                _one_wire_devices.update(
-                    find_onewire_devices(
-                        ow_bus=configure_dallas(),
-                        bus_id=dallas[ID],
-                        bus_type=DALLAS,
-                    )
+            _one_wire_devices.update(
+                find_onewire_devices(
+                    ow_bus=configure_dallas(),
+                    bus_id=dallas[ID],
+                    bus_type=DALLAS,
                 )
-            except KernelModuleLoadError as err:
-                _LOGGER.error("Can't configure Dallas W1 device %s", err)
-                pass
-
+            )
         for sensor in sensors:
             address = _one_wire_devices.get(sensor[ADDRESS])
             if not address:
                 continue
             ds2482_bus_id = sensor.get("bus_id")
             if ds2482_bus_id and ds2482_bus_id in _ds_onewire_bus:
-                kwargs = {
-                    "bus": _ds_onewire_bus[ds2482_bus_id],
-                    "cls": DallasSensorDS2482,
-                }
+                kwargs = {"bus": _ds_onewire_bus[ds2482_bus_id]}
             else:
-                kwargs = {"cls": DallasSensorW1}
+                kwargs = {}
             _LOGGER.debug("Configuring sensor %s for boneIO", address)
             self._temp_sensors.append(
                 create_dallas_sensor(
@@ -339,7 +320,7 @@ class Manager:
                         manager=self,
                         topic_prefix=self._config_helper.topic_prefix,
                         sensor_type=sensor_type,
-                        config=temp_def,
+                        temp_def=temp_def,
                         i2cbusio=self._i2cbusio,
                     )
                     if temp_sensor:
@@ -390,11 +371,11 @@ class Manager:
         """Retrieve asyncio tasks to run."""
         return self._tasks
 
-    def prepare_ha_buttons(self) -> None:
-        """Prepare HA buttons for reload."""
+    def prepare_button(self) -> None:
+        """Prepare buttons for reload."""
         self.send_ha_autodiscovery(
             id="Logger",
-            name="Logger reload",
+            name="Logger",
             ha_type=BUTTON,
             availability_msg_func=ha_button_availabilty_message,
         )
@@ -457,7 +438,7 @@ class Manager:
         self._config_helper.add_autodiscovery_msg(topic=topic, payload=payload)
         self.send_message(topic=topic, payload=payload, retain=True)
 
-    def resend_autodiscovery(self) -> None:
+    def resend_autodiscovery(self):
         for msg in self._config_helper.autodiscovery_msgs:
             self.send_message(**msg, retain=True)
 
@@ -519,10 +500,11 @@ class Manager:
                     _LOGGER.warn(
                         "Positon cannot be set. Not number between 0-100. %s", message
                     )
-        elif msg_type == BUTTON and command == "set":
-            if device_id == "logger" and message == "reload":
-                _LOGGER.info("Reloading logger configuration.")
-                self._logger_reload()
+        elif msg_type == BUTTON:
+            if device_id == "logger" and command == "set":
+                if message == "reload":
+                    _LOGGER.info("Reloading logger configuration.")
+                    self._logger_reload()
 
     @property
     def output(self) -> dict:

{boneIO-0.5.0 → boneIO-0.5.0.dev1}/boneio/modbus.py

@@ -77,7 +77,7 @@ class Modbus:
         """Call sync. pymodbus."""
         async with self._lock:
             if not self._pymodbus_connect():
-                _LOGGER.error("Can't connect to Modbus address %s.", address)
+                _LOGGER.error("Can't connect to Modbus.")
                 return None
             kwargs = {"unit": unit, "count": count} if unit else {}
             try:

{boneIO-0.5.0 → boneIO-0.5.0.dev1}/boneio/oled.py

@@ -28,7 +28,7 @@ fontSmall = make_font("DejaVuSans.ttf", 9)
 fontExtraSmall = make_font("DejaVuSans.ttf", 7)
 danube = make_font("danube__.ttf", 15, local=True)
 
-# screen_order = [UPTIME, NETWORK, CPU, DISK, MEMORY, SWAP]
+screen_order = [UPTIME, NETWORK, CPU, DISK, MEMORY, SWAP]
 
 STANDARD_ROWS = [17, 32, 47]
 UPTIME_ROWS = list(range(22, 60, 10))
@@ -40,32 +40,19 @@ class Oled:
     """Oled display class."""
 
     def __init__(
-        self,
-        host_data: HostData,
-        output_groups: List[str],
-        sleep_timeout: TimePeriod,
-        screen_order: List[str],
+        self, host_data: HostData, output_groups: List[str], sleep_timeout: TimePeriod
     ) -> None:
         """Initialize OLED screen."""
         self._loop = asyncio.get_running_loop()
-        self._output_groups = None
-        try:
-            _ind_screen = screen_order.index("outputs")
-            if not output_groups:
-                _LOGGER.debug("No outputs configured. Omitting in screen.")
-                screen_order.pop(_ind_screen)
-            screen_order[_ind_screen:_ind_screen] = output_groups
-            self._output_groups = output_groups
-        except ValueError:
-            pass
-        self._screen_order = cycle(screen_order)
+        self._screen_order = cycle(screen_order + output_groups)
+        self._output_groups = output_groups
         self._current_screen = next(self._screen_order)
         self._host_data = host_data
         self._sleep = False
         self._sleep_handle = None
         self._sleep_timeout = sleep_timeout
         setup_input(pin=OLED_PIN, pull_mode="gpio_pu")
-        edge_detect(pin=OLED_PIN, callback=self._handle_press, bounce=240)
+        edge_detect(pin=OLED_PIN, callback=self._handle_press, bounce=120)
         try:
             serial = i2c(port=2, address=0x3C)
             self._device = sh1106(serial)
@@ -125,7 +112,7 @@ class Oled:
         data = self._host_data.get(self._current_screen)
         if data:
             with canvas(self._device) as draw:
-                if self._output_groups and self._current_screen in self._output_groups:
+                if self._current_screen in self._output_groups:
                     self._draw_output(data, draw)
                 elif self._current_screen == UPTIME:
                     self._draw_uptime(data, draw)