boneIO 0.5.0.dev1__tar.gz → 0.5.0.dev3__tar.gz

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

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

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

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

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

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

boneIO-0.5.0.dev3/boneio/helper/filter.py

@@ -0,0 +1,26 @@
+"""Filter class to adjust sensor values."""
+from __future__ import annotations
+
+
+FILTERS = {
+    "offset": lambda x, y: x + y,
+    "round": lambda x, y: round(x, y),
+    "multiply": lambda x, y: x * y,
+    "filter_out": lambda x, y: None if x == y else x,
+    "filter_out_greater": lambda x, y: None if x > y else x,
+    "filter_out_lower": lambda x, y: None if x < y else x,
+}
+
+
+class Filter:
+    _filters = []
+
+    def _apply_filters(self, value: float) -> float | None:
+        for filter in self._filters:
+            for k, v in filter.items():
+                if k not in FILTERS:
+                    break
+                value = FILTERS[k](value, v)
+                if value is None:
+                    return None
+        return value

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

@@ -13,6 +13,7 @@ from boneio.const import (
     BINARY_SENSOR,
     COVER,
     DEVICE_CLASS,
+    FILTERS,
     GPIO,
     ID,
     INIT_SLEEP,
@@ -107,7 +108,7 @@ def create_temp_sensor(
     topic_prefix: str,
     sensor_type: str,
     i2cbusio: I2C,
-    temp_def: dict = {},
+    config: dict = {},
 ):
     """Create LM sensor in manager."""
     if sensor_type == LM75:
@@ -116,17 +117,18 @@ def create_temp_sensor(
         from boneio.sensor import MCP9808Sensor as TempSensor
     else:
         return
-    name = temp_def.get(ID)
+    name = config.get(ID)
     id = name.replace(" ", "")
     try:
         temp_sensor = TempSensor(
             id=id,
             name=name,
             i2c=i2cbusio,
-            address=temp_def[ADDRESS],
+            address=config[ADDRESS],
             send_message=manager.send_message,
             topic_prefix=topic_prefix,
-            update_interval=temp_def.get(UPDATE_INTERVAL, TimePeriod(seconds=60)),
+            update_interval=config.get(UPDATE_INTERVAL, TimePeriod(seconds=60)),
+            filters=config.get(FILTERS, []),
         )
         manager.send_ha_autodiscovery(
             id=id,
@@ -393,6 +395,7 @@ 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):

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

@@ -4,7 +4,8 @@ from datetime import datetime
 import socket
 import time
 from math import floor
-from typing import Callable
+from typing import Callable, List
+from functools import partial
 
 import psutil
 
@@ -117,19 +118,32 @@ def get_uptime():
 class HostSensor(AsyncUpdater):
     """Host sensor."""
 
-    def __init__(self, update_function: Callable, static_data: dict, **kwargs) -> None:
+    def __init__(
+        self,
+        update_function: Callable,
+        manager_callback: Callable,
+        static_data: dict,
+        id: str,
+        type: str,
+        **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._state}
+            return {**self._static_data, self._type: self._state}
         return self._state
 
 
@@ -144,6 +158,7 @@ class HostData:
         callback: Callable,
         temp_sensor: Callable[[LM75Sensor, MCP9808Sensor], None],
         manager: Manager,
+        enabled_screens: List[str],
     ) -> None:
         """Initialize HostData."""
         self._hostname = socket.gethostname()
@@ -160,10 +175,15 @@ class HostData:
             },
         }
         for k, _v in host_stats.items():
-            self._data[k] = HostSensor(
+            if k not in enabled_screens:
+                continue
+            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.dev1 → boneIO-0.5.0.dev3}/boneio/manager.py

@@ -204,8 +204,11 @@ 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,
@@ -213,12 +216,13 @@ 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_button()
+        self.prepare_ha_buttons()
 
         _LOGGER.info("BoneIO manager is ready.")
 
@@ -320,7 +324,7 @@ class Manager:
                         manager=self,
                         topic_prefix=self._config_helper.topic_prefix,
                         sensor_type=sensor_type,
-                        temp_def=temp_def,
+                        config=temp_def,
                         i2cbusio=self._i2cbusio,
                     )
                     if temp_sensor:
@@ -371,11 +375,11 @@ class Manager:
         """Retrieve asyncio tasks to run."""
         return self._tasks
 
-    def prepare_button(self) -> None:
-        """Prepare buttons for reload."""
+    def prepare_ha_buttons(self) -> None:
+        """Prepare HA buttons for reload."""
         self.send_ha_autodiscovery(
             id="Logger",
-            name="Logger",
+            name="Logger reload",
             ha_type=BUTTON,
             availability_msg_func=ha_button_availabilty_message,
         )
@@ -438,7 +442,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):
+    def resend_autodiscovery(self) -> None:
         for msg in self._config_helper.autodiscovery_msgs:
             self.send_message(**msg, retain=True)
 
@@ -500,11 +504,10 @@ class Manager:
                     _LOGGER.warn(
                         "Positon cannot be set. Not number between 0-100. %s", message
                     )
-        elif msg_type == BUTTON:
-            if device_id == "logger" and command == "set":
-                if message == "reload":
-                    _LOGGER.info("Reloading logger configuration.")
-                    self._logger_reload()
+        elif msg_type == BUTTON and command == "set":
+            if device_id == "logger" and message == "reload":
+                _LOGGER.info("Reloading logger configuration.")
+                self._logger_reload()
 
     @property
     def output(self) -> dict:

{boneIO-0.5.0.dev1 → boneIO-0.5.0.dev3}/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,19 +40,32 @@ class Oled:
     """Oled display class."""
 
     def __init__(
-        self, host_data: HostData, output_groups: List[str], sleep_timeout: TimePeriod
+        self,
+        host_data: HostData,
+        output_groups: List[str],
+        sleep_timeout: TimePeriod,
+        screen_order: List[str],
     ) -> None:
         """Initialize OLED screen."""
         self._loop = asyncio.get_running_loop()
-        self._screen_order = cycle(screen_order + output_groups)
-        self._output_groups = output_groups
+        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._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=120)
+        edge_detect(pin=OLED_PIN, callback=self._handle_press, bounce=240)
         try:
             serial = i2c(port=2, address=0x3C)
             self._device = sh1106(serial)
@@ -112,7 +125,7 @@ class Oled:
         data = self._host_data.get(self._current_screen)
         if data:
             with canvas(self._device) as draw:
-                if self._current_screen in self._output_groups:
+                if self._output_groups and self._current_screen in self._output_groups:
                     self._draw_output(data, draw)
                 elif self._current_screen == UPTIME:
                     self._draw_uptime(data, draw)

boneIO-0.5.0.dev3/boneio/schema/filters.yaml

@@ -0,0 +1,11 @@
+type: list
+required: False
+schema:
+  type: dict
+  keysrules:
+    type: string
+    allowed: ["offset", "round", "multiply", "filter_out", "filter_out_greater", "filter_out_lower"]
+default:
+  - round: 2
+meta:
+  label: List of filters to apply. Allowed filters visible in allowed section.

boneIO-0.5.0.dev3/boneio/schema/filters_adc.yaml

@@ -0,0 +1,12 @@
+type: list
+required: False
+schema:
+  type: dict
+  keysrules:
+    type: string
+    allowed: ["offset", "round", "multiply", "filter_out", "filter_out_greater", "filter_out_lower"]
+default:
+  - multiply: 1.8
+  - round: 2
+meta:
+  label: List of filters to apply. Allowed filters visible in allowed section.

{boneIO-0.5.0.dev1 → boneIO-0.5.0.dev3}/boneio/schema/schema.yaml

@@ -75,6 +75,18 @@ oled:
       default: False
       meta:
         label: Disable builtin screen.
+    screens:
+      type: list
+      required: True
+      allowed: ["uptime", "network", "cpu", "disk", "memory", "swap", "outputs"]
+      default:
+        - uptime
+        - network
+        - cpu
+        - disk
+        - memory
+        - swap
+        - outputs
     screensaver_timeout:
       type:
         - string
@@ -147,17 +159,8 @@ lm75:
       default: 0x48
       meta:
         label: Address of I2C
-    update_interval:
-      type:
-        - string
-        - timeperiod
-      coerce:
-        - str
-        - positive_time_period
-      required: True
-      default: 60s
-      meta:
-        label: Update interval.
+    update_interval: !include update_interval.yaml
+    filters: !include filters.yaml
 
 
 mcp9808:
@@ -175,17 +178,8 @@ mcp9808:
       default: 0x18
       meta:
         label: Address of I2C device
-    update_interval:
-      type:
-        - string
-        - timeperiod
-      coerce:
-        - str
-        - positive_time_period
-      required: True
-      default: 60s
-      meta:
-        label: Update interval.
+    update_interval: !include update_interval.yaml
+    filters: !include filters.yaml
 
 mcp23017:
   type: list
@@ -360,17 +354,7 @@ adc:
         allowed: ["P9_33", "P9_35", "P9_36", "P9_37", "P9_38", "P9_39", "P9_40"]
         meta:
           label: PIN to use.
-      update_interval:
-        required: True
-        type:
-          - string
-          - timeperiod
-        coerce:
-          - str
-          - positive_time_period
-        default: 60s
-        meta:
-          label: Update interval.
+      update_interval: !include update_interval.yaml
       show_in_ha:
         type: boolean
         required: True
@@ -483,17 +467,18 @@ sensor:
         required: False
         meta:
           label: Id to use in HA if needed. Default to address.
+      platform:
+        type: string
+        required: True
+        default: dallas
+        allowed: ["dallas"]
+        meta:
+          label: Platform of sensor to use. Currently only Dallas platform is supported.
       address:
         type: integer
         required: True
         meta:
           label: Address of Dallas device
-      via_ds2482:
-        type: boolean
-        required: True
-        default: False
-        meta:
-          label: Choose if sensor is connected via DS2482 bus.
       bus_id:
         type: string
         required: False
@@ -505,14 +490,5 @@ sensor:
         default: True
         meta:
           label: If you want you can disable discovering this input in HA.
-      update_interval:
-        type:
-          - string
-          - timeperiod
-        coerce:
-          - str
-          - positive_time_period
-        required: True
-        default: 60 s
-        meta:
-          label: Update interval.
+      filters: !include filters.yaml
+      update_interval: !include update_interval.yaml

boneIO-0.5.0.dev3/boneio/schema/update_interval.yaml

@@ -0,0 +1,10 @@
+type:
+  - string
+  - timeperiod
+coerce:
+  - str
+  - positive_time_period
+required: True
+default: 60s
+meta:
+  label: Update interval.

{boneIO-0.5.0.dev1 → boneIO-0.5.0.dev3}/boneio/sensor/adc.py

@@ -4,6 +4,7 @@ import logging
 
 from boneio.const import SENSOR
 from boneio.helper import BasicMqtt, AsyncUpdater
+from boneio.helper.filter import Filter
 
 try:
     import Adafruit_BBIO.ADC as ADC
@@ -22,23 +23,28 @@ def initialize_adc():
     ADC.setup()
 
 
-class GpioADCSensor(BasicMqtt, AsyncUpdater):
+class GpioADCSensor(BasicMqtt, AsyncUpdater, Filter):
     """Represent Gpio ADC sensor."""
 
     def __init__(self, pin: str, **kwargs) -> None:
         """Setup GPIO ADC Sensor"""
         super().__init__(topic_type=SENSOR, **kwargs)
         self._pin = pin
+        self._state = None
         AsyncUpdater.__init__(self, **kwargs)
         _LOGGER.debug("Configured sensor pin %s", self._pin)
 
     @property
-    def state(self):
+    def state(self) -> float:
         """Give rounded value of temperature."""
-        return round(ADC.read(self._pin) * 1.8, 2)
+        return self._state
 
     def update(self, time: datetime) -> None:
         """Fetch temperature periodically and send to MQTT."""
+        _state = self._apply_filters(value=ADC.read(self._pin))
+        if not _state:
+            return
+        self._state = _state
         self._send_message(
             topic=self._send_topic,
             payload=self.state,

{boneIO-0.5.0.dev1 → boneIO-0.5.0.dev3}/boneio/sensor/temp/__init__.py

@@ -6,18 +6,27 @@ from datetime import datetime
 from boneio.const import SENSOR, STATE, TEMPERATURE
 from boneio.helper import BasicMqtt, AsyncUpdater
 from boneio.helper.exceptions import I2CError
+from boneio.helper.filter import Filter
 
 
-class TempSensor(BasicMqtt, AsyncUpdater):
+class TempSensor(BasicMqtt, AsyncUpdater, Filter):
     """Represent Temp sensor in BoneIO."""
 
     SensorClass = None
     DefaultName = TEMPERATURE
 
-    def __init__(self, i2c, address: str, id: str = DefaultName, **kwargs):
+    def __init__(
+        self,
+        i2c,
+        address: str,
+        id: str = DefaultName,
+        filters: list = ["round(x, 2)"],
+        **kwargs
+    ):
         """Initialize Temp class."""
         super().__init__(id=id, topic_type=SENSOR, **kwargs)
         self._loop = asyncio.get_event_loop()
+        self._filters = filters
         try:
             self._pct = self.SensorClass(i2c_bus=i2c, address=address)
             self._state: float | None = None
@@ -32,7 +41,10 @@ class TempSensor(BasicMqtt, AsyncUpdater):
 
     def update(self, time: datetime) -> None:
         """Fetch temperature periodically and send to MQTT."""
-        self._state = round(self._pct.temperature, 2)
+        _temp = self._apply_filters(value=self._pct.temperature)
+        if not _temp:
+            return
+        self._state = _temp
         self._send_message(
             topic=self._send_topic,
             payload={STATE: self._state},

{boneIO-0.5.0.dev1 → boneIO-0.5.0.dev3}/boneio/sensor/temp/dallas.py

@@ -3,6 +3,7 @@
 import asyncio
 import logging
 from datetime import datetime
+from ast import literal_eval
 
 from adafruit_ds18x20 import DS18X20
 from w1thermsensor import SensorNotReadyError
@@ -47,11 +48,13 @@ class DallasSensorW1(TempSensor, AsyncUpdater):
         self,
         address: OneWireAddress,
         id: str = DefaultName,
+        filters: list = ["round(x, 2)"],
         **kwargs,
     ):
         """Initialize Temp class."""
         self._loop = asyncio.get_event_loop()
         BasicMqtt.__init__(self, id=id, topic_type=SENSOR, **kwargs)
+        self._filters = filters
         try:
             self._pct = AsyncBoneIOW1ThermSensor(sensor_id=address)
         except ValueError as err:
@@ -60,7 +63,12 @@ class DallasSensorW1(TempSensor, AsyncUpdater):
 
     async def async_update(self, time: datetime) -> None:
         try:
-            self._state = round(await self._pct.get_temperature(), 2)
+            _temp = await self._pct.get_temperature()
+            _LOGGER.debug("Fetched temperature %s. Applying filters.", _temp)
+            _temp = self._apply_filters(value=_temp)
+            if not _temp:
+                return
+            self._state = _temp
             self._send_message(
                 topic=self._send_topic,
                 payload={STATE: self._state},

boneIO-0.5.0.dev3/boneio/version.py

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

{boneIO-0.5.0.dev1 → boneIO-0.5.0.dev3}/pyproject.toml

@@ -27,7 +27,7 @@ dependencies = [
     "w1thermsensor[async]>=2.0.0",
 ]
 requires-python = ">=3.7"
-version = "0.5.0dev1"
+version = "0.5.0dev3"
 
 [project.license]
 text = "GNU General Public License v3.0"

boneIO-0.5.0.dev1/boneio/version.py

@@ -1,2 +0,0 @@
-# flake8: noqa
-__version__ = "0.5.0dev1"