boneIO 0.1.0.dev5__tar.gz → 0.1.0.dev7__tar.gz

{boneio-0.1.0.dev5 → boneio-0.1.0.dev7}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: boneio
-Version: 0.1.0.dev5
+Version: 0.1.0.dev7
 Summary: Python Helper for BoneIO
 Home-page: https://github.com/maciejk1984/boneIO
 License: GNU General Public License v3.0
-Download-URL: https://github.com/maciejk1984/boneIO/archive/0.1.0.dev5.zip
+Download-URL: https://github.com/maciejk1984/boneIO/archive/0.1.0.dev7.zip
 Platform: UNKNOWN
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.7

{boneio-0.1.0.dev5 → boneio-0.1.0.dev7}/boneio/bonecli.py

@@ -1,6 +1,7 @@
 from .helper import CustomValidator, load_yaml_file
 import click
 import logging
+from contextlib import AsyncExitStack
 from colorlog import ColoredFormatter
 from .mqtt_client import MQTTClient
 from .manager import Manager
@@ -136,7 +137,10 @@ async def run(ctx, debug: int, config: str, mqttpassword: str = ""):
         mcp23017=_config[MCP23017],
         oled=_config.get(OLED),
     )
-    await client.start_client(manager)
+    tasks = set()
+    tasks.add(client.start_client(manager))
+    tasks.update(manager.get_tasks())
+    await asyncio.gather(*tasks)
 
 
 if __name__ == "__main__":

{boneio-0.1.0.dev5 → boneio-0.1.0.dev7}/boneio/helper/stats.py

@@ -1,7 +1,19 @@
 import asyncio
 import psutil
 from math import floor
-from ..const import GIGABYTE, MEGABYTE, NETWORK, DISK, MEMORY, CPU, SWAP, UPTIME
+from ..const import (
+    GIGABYTE,
+    MEGABYTE,
+    NETWORK,
+    DISK,
+    MEMORY,
+    CPU,
+    SWAP,
+    UPTIME,
+    HOST,
+    OUTPUT,
+    OledDataTypes,
+)
 import time
 
 intervals = (
@@ -113,3 +125,38 @@ host_stats = {
     SWAP: get_swap_info,
     UPTIME: get_uptime,
 }
+
+import socket
+
+
+class HostData:
+    """Helper class to store host data."""
+
+    data = {UPTIME: {}, NETWORK: {}, CPU: {}, DISK: {}, MEMORY: {}, SWAP: {}}
+
+    def __init__(self, output: dict) -> None:
+        """Initialize HostData."""
+        self._hostname = socket.gethostname()
+        self.data[UPTIME] = {HOST: self._hostname, UPTIME: 0}
+        self._output = output
+
+    def write(self, type: str, data: dict) -> None:
+        """Write data of chosen type."""
+        self.data[type] = data
+
+    def write_uptime(self, uptime: str) -> None:
+        """Write uptime."""
+        self.data[UPTIME][UPTIME] = uptime
+
+    def get(self, type: OledDataTypes) -> dict:
+        """Get saved stats."""
+        if type == OUTPUT:
+            return self._get_output()
+        return self.data[type]
+
+    def _get_output(self) -> dict:
+        """Get stats for output."""
+        out = {}
+        for output in self._output.values():
+            out[output.id] = output.state
+        return out

{boneio-0.1.0.dev5 → boneio-0.1.0.dev7}/boneio/manager.py

@@ -1,8 +1,14 @@
 from .input import GpioInputButton
 from .relay import GpioRelay, MCPRelay
 from .oled import Oled
+from .helper.stats import host_stats, HostData
+from typing import Set
+import asyncio
+import logging
+
 from .const import (
     ACTION,
+    OUTPUT,
     ACTIONS,
     ADDRESS,
     GPIO,
@@ -64,9 +70,11 @@ class Manager:
         ha_discovery_prefix: str = "homeassistant",
         mcp23017: Optional[List] = None,
         oled: bool = False,
+        web: bool = False,
     ) -> None:
         """Initialize the manager."""
         loop = asyncio.get_event_loop()
+        self._host_data = None
 
         self.send_message = send_message
         self._topic_prefix = topic_prefix
@@ -75,6 +83,7 @@ class Manager:
         self._i2cbusio = I2C(SCL, SDA)
         self._mcp = {}
         self._oled = None
+        self._tasks: List[asyncio.Task] = []
 
         if mcp23017:
             for mcp in mcp23017:
@@ -127,15 +136,19 @@ class Manager:
             for gpio in self._input_pins
         ]
 
+        if oled or web:
+            self._host_data = HostData(output=self.output)
+            for f in host_stats.values():
+                self._tasks.append(asyncio.create_task(f(self._host_data)))
+
         if oled:
-            self._oled = Oled(self.output)
+            self._oled = Oled(self._host_data)
+            self._tasks.append(self._oled.get_task())
 
         self.send_message(topic=f"{topic_prefix}/{STATE}", payload=ONLINE)
 
-    def get_oled_tasks(self) -> any:
-        if not self._oled:
-            return []
-        return self._oled.get_tasks()
+    def get_tasks(self) -> Set[asyncio.Task]:
+        return self._tasks
 
     def press_callback(self, x: ClickTypes, inpin: str, actions: dict) -> None:
         """Press callback to use in input gpio.

{boneio-0.1.0.dev5 → boneio-0.1.0.dev7}/boneio/mqtt_client.py

@@ -144,7 +144,7 @@ class MQTTClient:
                 self.create_client()  # reset connect/reconnect futures
 
     async def _subscribe_manager(self, manager: any) -> None:
-        """Connect and subscribe to manager topics."""
+        """Connect and subscribe to manager topics + host stats."""
         async with AsyncExitStack() as stack:
             tasks: Set[asyncio.Task] = set()
 
@@ -166,8 +166,6 @@ class MQTTClient:
             )
             tasks.add(messages_task)
 
-            tasks.update(manager.get_oled_tasks())
-
             topic = f"{manager.relay_topic}"
             await self.subscribe(topic)
 

boneio-0.1.0.dev7/boneio/oled.py

@@ -0,0 +1,82 @@
+from .helper.gpio import setup_input, edge_detect
+from .helper.stats import HostData
+from .input.gpio import configure_pin
+from .const import (
+    OLED_PIN,
+    NETWORK,
+    CPU,
+    DISK,
+    MEMORY,
+    SWAP,
+    NUM_OF_SCREENS,
+    UPTIME,
+    OUTPUT,
+    WHITE,
+)
+import asyncio
+import os
+import logging
+
+from luma.core.interface.serial import i2c
+from luma.core.render import canvas
+from luma.oled.device import sh1106
+from PIL import ImageFont
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def make_font(name, size):
+    font_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "fonts", name))
+    return ImageFont.truetype(font_path, size)
+
+
+fontBig = make_font("DejaVuSans.ttf", 12)
+fontSmall = make_font("DejaVuSans.ttf", 10)
+
+screen_order = [UPTIME, NETWORK, CPU, DISK, MEMORY, SWAP, OUTPUT]
+lines = [17, 32, 47]
+
+
+class Oled:
+    """Oled display class."""
+
+    def __init__(self, host_data: HostData) -> None:
+        """Initialize OLED screen."""
+        self._screen_no = 0
+        self._loop = asyncio.get_running_loop()
+        self._host_data = host_data
+        configure_pin(OLED_PIN)
+        setup_input(OLED_PIN)
+        edge_detect(OLED_PIN, callback=self._handle_press, bounce=50)
+        serial = i2c(port=2, address=0x3C)
+        self._device = sh1106(serial)
+        _LOGGER.debug("Configuring OLED screen.")
+
+    def get_task(self) -> list:
+        """Periodically check for host statistics."""
+        return asyncio.create_task(self.render_display())
+
+    async def render_display(self):
+        while True:
+            screen = screen_order[self._screen_no]
+            data = self._host_data.get(screen)
+            if data:
+                with canvas(self._device) as draw:
+                    draw.text((1, 1), screen, font=fontBig, fill=WHITE)
+                    i = 0
+                    for k in data:
+                        draw.text(
+                            (3, lines[i]),
+                            f"{k} {data[k]}",
+                            font=fontSmall,
+                            fill=WHITE,
+                        )
+                        i += 1
+            await asyncio.sleep(0.5)
+
+    def _handle_press(self, pin: any) -> None:
+        """Handle press of PIN for OLED display."""
+        if self._screen_no < NUM_OF_SCREENS:
+            self._screen_no += 1
+        else:
+            self._screen_no = 0

boneio-0.1.0.dev7/boneio/version.py

@@ -0,0 +1,2 @@
+# flake8: noqa
+__version__ = "0.1.0.dev7"

{boneio-0.1.0.dev5 → boneio-0.1.0.dev7}/boneio.egg-info/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: boneio
-Version: 0.1.0.dev5
+Version: 0.1.0.dev7
 Summary: Python Helper for BoneIO
 Home-page: https://github.com/maciejk1984/boneIO
 License: GNU General Public License v3.0
-Download-URL: https://github.com/maciejk1984/boneIO/archive/0.1.0.dev5.zip
+Download-URL: https://github.com/maciejk1984/boneIO/archive/0.1.0.dev7.zip
 Platform: UNKNOWN
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.7

boneio-0.1.0.dev5/boneio/oled.py

@@ -1,120 +0,0 @@
-from .helper.gpio import setup_input, edge_detect
-from .helper.stats import host_stats
-from .input.gpio import configure_pin
-from .const import (
-    OLED_PIN,
-    NETWORK,
-    CPU,
-    DISK,
-    MEMORY,
-    SWAP,
-    NUM_OF_SCREENS,
-    UPTIME,
-    HOST,
-    OUTPUT,
-    WHITE,
-    OledDataTypes,
-)
-import asyncio
-import os
-import socket
-import logging
-
-from functools import partial
-from luma.core.interface.serial import i2c
-from luma.core.render import canvas
-from luma.oled.device import sh1106
-from PIL import ImageFont
-
-_LOGGER = logging.getLogger(__name__)
-
-
-def make_font(name, size):
-    font_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "fonts", name))
-    return ImageFont.truetype(font_path, size)
-
-
-fontBig = make_font("DejaVuSans.ttf", 12)
-fontSmall = make_font("DejaVuSans.ttf", 10)
-
-screen_order = [UPTIME, NETWORK, CPU, DISK, MEMORY, SWAP, OUTPUT]
-lines = [17, 32, 47]
-
-
-class HostData:
-    """Helper class to store host data."""
-
-    data = {UPTIME: {}, NETWORK: {}, CPU: {}, DISK: {}, MEMORY: {}, SWAP: {}}
-
-    def __init__(self, output: dict) -> None:
-        """Initialize HostData."""
-        self._hostname = socket.gethostname()
-        self.data[UPTIME] = {HOST: self._hostname, UPTIME: 0}
-        self._output = output
-
-    def write(self, type: str, data: dict) -> None:
-        """Write data of chosen type."""
-        self.data[type] = data
-
-    def write_uptime(self, uptime: str) -> None:
-        """Write uptime."""
-        self.data[UPTIME][UPTIME] = uptime
-
-    def get(self, type: OledDataTypes) -> dict:
-        """Get saved stats."""
-        if type == OUTPUT:
-            return self._get_output()
-        return self.data[type]
-
-    def _get_output(self) -> dict:
-        """Get stats for output."""
-        out = {}
-        for output in self._output.values():
-            out[output.id] = output.state
-        return out
-
-
-class Oled:
-    """Oled display class."""
-
-    def __init__(self, output: dict) -> None:
-        """Initialize OLED screen."""
-        self._screen_no = 0
-        self._loop = asyncio.get_running_loop()
-        self._host_data = HostData(output=output)
-        configure_pin(OLED_PIN)
-        setup_input(OLED_PIN)
-        edge_detect(OLED_PIN, callback=self._handle_press, bounce=50)
-        serial = i2c(port=2, address=0x3C)
-        self._device = sh1106(serial)
-        _LOGGER.debug("Configuring OLED screen.")
-
-    def get_tasks(self) -> list:
-        """Periodically check for host statistics."""
-        return [
-            asyncio.create_task(func(self._host_data)) for func in host_stats.values()
-        ]
-
-    def _handle_press(self, pin: any) -> None:
-        """Handle press of PIN for OLED display."""
-
-        def press_callback(screen_no):
-            screen = screen_order[screen_no]
-            data = self._host_data.get(screen)
-            with canvas(self._device) as draw:
-                draw.text((1, 1), screen, font=fontBig, fill=WHITE)
-                i = 0
-                for k in data:
-                    draw.text(
-                        (3, lines[i]),
-                        f"{k} {data[k]}",
-                        font=fontSmall,
-                        fill=WHITE,
-                    )
-                    i += 1
-
-        self._loop.call_soon_threadsafe(partial(press_callback, self._screen_no))
-        if self._screen_no < NUM_OF_SCREENS:
-            self._screen_no += 1
-        else:
-            self._screen_no = 0

boneio-0.1.0.dev5/boneio/version.py

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