boneIO 0.5.0.dev2__tar.gz → 0.5.0.dev4__tar.gz

{boneIO-0.5.0.dev2 → boneIO-0.5.0.dev4}/PKG-INFO

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

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

@@ -125,6 +125,7 @@ def create_temp_sensor(
             name=name,
             i2c=i2cbusio,
             address=config[ADDRESS],
+            manager=manager,
             send_message=manager.send_message,
             topic_prefix=topic_prefix,
             update_interval=config.get(UPDATE_INTERVAL, TimePeriod(seconds=60)),

{boneIO-0.5.0.dev2 → boneIO-0.5.0.dev4}/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
 
@@ -118,21 +119,31 @@ class HostSensor(AsyncUpdater):
     """Host sensor."""
 
     def __init__(
-        self, update_function: Callable, static_data: dict, id: str, **kwargs
+        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
 
 
@@ -147,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()
@@ -163,11 +175,15 @@ class HostData:
             },
         }
         for k, _v in host_stats.items():
+            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.dev2 → boneIO-0.5.0.dev4}/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,6 +216,7 @@ 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),
                 )

{boneIO-0.5.0.dev2 → boneIO-0.5.0.dev4}/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.dev2 → boneIO-0.5.0.dev4}/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

boneIO-0.5.0.dev4/boneio/version.py

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

{boneIO-0.5.0.dev2 → boneIO-0.5.0.dev4}/pyproject.toml

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

boneIO-0.5.0.dev2/boneio/version.py

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