boneIO 0.1.0.dev7__tar.gz → 0.1.0.dev8__tar.gz

{boneio-0.1.0.dev7 → boneio-0.1.0.dev8}/MANIFEST.in

@@ -2,3 +2,4 @@ include README.md
 include requirements.txt
 include LICENSE
 recursive-include boneio *.yaml
+recursive-include boneio *.ttf

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

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: boneio
-Version: 0.1.0.dev7
+Version: 0.1.0.dev8
 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.dev7.zip
+Download-URL: https://github.com/maciejk1984/boneIO/archive/0.1.0.dev8.zip
 Platform: UNKNOWN
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.7

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

@@ -1,28 +1,29 @@
-from .helper import CustomValidator, load_yaml_file
-import click
+import asyncio
 import logging
-from contextlib import AsyncExitStack
+import os
+from functools import wraps
+
+import click
 from colorlog import ColoredFormatter
-from .mqtt_client import MQTTClient
-from .manager import Manager
+
 from .const import (
     ENABLED,
     GPIO_INPUT,
     HA_DISCOVERY,
+    HOST,
     MCP23017,
+    MQTT,
     OLED,
     OUTPUT,
     PAHO,
-    MQTT,
-    HOST,
+    PASSWORD,
     TOPIC_PREFIX,
     USERNAME,
-    PASSWORD,
 )
+from .helper import CustomValidator, load_yaml_file
+from .manager import Manager
+from .mqtt_client import MQTTClient
 from .version import __version__
-import asyncio
-import os
-from functools import wraps
 
 _LOGGER = logging.getLogger(__name__)
 logging.basicConfig(level=logging.INFO)
@@ -103,6 +104,7 @@ _options = [
 @coro
 async def run(ctx, debug: int, config: str, mqttpassword: str = ""):
     """Run BoneIO."""
+    _LOGGER.info("BoneIO starting.")
     if debug == 0:
         logging.getLogger().setLevel(logging.INFO)
     if debug > 0:
@@ -121,6 +123,7 @@ async def run(ctx, debug: int, config: str, mqttpassword: str = ""):
         _LOGGER.info("Missing file.")
         return
     _config = v.normalized(config_yaml)
+    _LOGGER.info("Connecting to MQTT.")
     client = MQTTClient(
         host=_config[MQTT][HOST],
         username=_config[MQTT].get(USERNAME),
@@ -138,8 +141,8 @@ async def run(ctx, debug: int, config: str, mqttpassword: str = ""):
         oled=_config.get(OLED),
     )
     tasks = set()
-    tasks.add(client.start_client(manager))
     tasks.update(manager.get_tasks())
+    tasks.add(client.start_client(manager))
     await asyncio.gather(*tasks)
 
 

{boneio-0.1.0.dev7 → boneio-0.1.0.dev8}/boneio/const.py

@@ -1,7 +1,8 @@
 # from typing import Literal
-from typing_extensions import Literal
 from datetime import timedelta
 
+from typing_extensions import Literal
+
 DEBOUNCE_DURATION = timedelta(seconds=0.2)
 LONG_PRESS_DURATION = timedelta(seconds=0.7)
 DELAY_DURATION = 0.1
@@ -21,6 +22,7 @@ HOST = "host"
 USERNAME = "username"
 PASSWORD = "password"
 TOPIC_PREFIX = "topic_prefix"
+HOMEASSISTANT = "homeassistant"
 HA_DISCOVERY = "ha_discovery"
 ENABLED = "enabled"
 GPIO_INPUT = "gpio_input"
@@ -52,4 +54,6 @@ MEMORY = "memory"
 SWAP = "swap"
 WHITE = "white"
 OLED = "oled"
+FONTS = "fonts"
 OledDataTypes = Literal[UPTIME, NETWORK, CPU, DISK, MEMORY, SWAP, OUTPUT]
+INIT_SLEEP = "init_sleep"

boneio-0.1.0.dev8/boneio/helper/__init__.py

@@ -0,0 +1,14 @@
+"""Helper dir for BoneIO."""
+from .gpio import edge_detect, setup_input
+from .oled import make_font
+from .stats import HostData
+from .yaml import CustomValidator, load_yaml_file
+
+__all__ = [
+    "CustomValidator",
+    "load_yaml_file",
+    "HostData",
+    "setup_input",
+    "edge_detect",
+    "make_font",
+]

boneio-0.1.0.dev8/boneio/helper/oled.py

@@ -0,0 +1,15 @@
+import os
+
+from PIL import ImageFont
+
+from ..const import FONTS
+
+
+def make_font(name: str, size: int, local: bool = False):
+    """Prepare ImageFont for Oled screen."""
+    font_path = (
+        name
+        if not local
+        else os.path.join(os.path.dirname(__file__), "..", FONTS, name)
+    )
+    return ImageFont.truetype(font_path, size)

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

@@ -1,27 +1,15 @@
 import asyncio
-import psutil
-from math import floor
-from ..const import (
-    GIGABYTE,
-    MEGABYTE,
-    NETWORK,
-    DISK,
-    MEMORY,
-    CPU,
-    SWAP,
-    UPTIME,
-    HOST,
-    OUTPUT,
-    OledDataTypes,
-)
+import socket
 import time
+from functools import partial
+from math import floor
+from typing import Callable
+
+import psutil
+
+from ..const import CPU, DISK, GIGABYTE, HOST, MEGABYTE, MEMORY, NETWORK, SWAP, UPTIME
 
-intervals = (
-    ("d", 86400),  # 60 * 60 * 24
-    ("h", 3600),  # 60 * 60
-    ("m", 60),
-    ("s", 1),
-)
+intervals = (("d", 86400), ("h", 3600), ("m", 60))
 
 
 def display_time(seconds):
@@ -46,7 +34,7 @@ async def get_network_info(host_data):
             NETWORK,
             {"ip": net[0].address, "mask": net[0].netmask, "mac": net[2].address},
         )
-        await asyncio.sleep(30)
+        await asyncio.sleep(60)
 
 
 async def get_cpu_info(host_data):
@@ -114,7 +102,7 @@ async def get_uptime(host_data):
     while True:
         uptime = display_time(time.clock_gettime(time.CLOCK_BOOTTIME))
         host_data.write_uptime(uptime)
-        await asyncio.sleep(10)
+        await asyncio.sleep(30)
 
 
 host_stats = {
@@ -126,37 +114,39 @@ host_stats = {
     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:
+    def __init__(self, output: dict, callback: Callable) -> None:
         """Initialize HostData."""
         self._hostname = socket.gethostname()
         self.data[UPTIME] = {HOST: self._hostname, UPTIME: 0}
         self._output = output
+        self._callback = callback
+        self._loop = asyncio.get_running_loop()
 
     def write(self, type: str, data: dict) -> None:
         """Write data of chosen type."""
         self.data[type] = data
+        self._loop.call_soon_threadsafe(partial(self._callback, type))
 
     def write_uptime(self, uptime: str) -> None:
         """Write uptime."""
         self.data[UPTIME][UPTIME] = uptime
+        self._loop.call_soon_threadsafe(partial(self._callback, UPTIME))
 
-    def get(self, type: OledDataTypes) -> dict:
+    def get(self, type: str) -> dict:
         """Get saved stats."""
-        if type == OUTPUT:
-            return self._get_output()
+        if type in self._output:
+            return self._get_output(type)
         return self.data[type]
 
-    def _get_output(self) -> dict:
+    def _get_output(self, type: str) -> dict:
         """Get stats for output."""
         out = {}
-        for output in self._output.values():
+        for output in self._output[type].values():
             out[output.id] = output.state
         return out

boneio-0.1.0.dev8/boneio/input/__init__.py

@@ -0,0 +1,5 @@
+"""Input classes."""
+
+from .gpio import GpioInputButton, configure_pin
+
+__all__ = ["GpioInputButton", "configure_pin"]

{boneio-0.1.0.dev7 → boneio-0.1.0.dev8}/boneio/input/gpio.py

@@ -1,23 +1,24 @@
 """GPIOInputButton to receive signals."""
-from ..helper.gpio import setup_input, read_input, edge_detect
+import asyncio
+import logging
 import subprocess
-from functools import partial
-from typing import Callable, Any
 from datetime import datetime
-import logging
-import asyncio
+from functools import partial
+from typing import Any, Callable
+
 from ..const import (
     CONFIG_PIN,
-    GPIO,
-    SINGLE,
+    DEBOUNCE_DURATION,
+    DELAY_DURATION,
     DOUBLE,
+    GPIO,
     LONG,
-    ClickTypes,
-    DEBOUNCE_DURATION,
     LONG_PRESS_DURATION,
-    DELAY_DURATION,
     SECOND_DELAY_DURATION,
+    SINGLE,
+    ClickTypes,
 )
+from ..helper.gpio import edge_detect, read_input, setup_input
 
 _LOGGER = logging.getLogger(__name__)
 

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

@@ -1,37 +1,37 @@
-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
+import time
+from typing import Any, Callable, List, Optional, Set, Union
+
+from adafruit_mcp230xx.mcp23017 import MCP23017
+from board import SCL, SDA
+from busio import I2C
 
 from .const import (
     ACTION,
-    OUTPUT,
     ACTIONS,
     ADDRESS,
     GPIO,
     HA_TYPE,
+    HOMEASSISTANT,
     ID,
+    INIT_SLEEP,
     KIND,
     MCP,
     MCP_ID,
+    OFF,
+    ON,
+    ONLINE,
     OUTPUT,
     PIN,
     RELAY,
-    ON,
-    OFF,
-    ONLINE,
     STATE,
     ClickTypes,
 )
-from typing import Callable, Optional, Union, List, Any
-import logging
-import asyncio
-from busio import I2C
-from board import SCL, SDA
-from adafruit_mcp230xx.mcp23017 import MCP23017
+from .helper.stats import HostData, host_stats
+from .input import GpioInputButton
+from .oled import Oled
+from .relay import GpioRelay, MCPRelay
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -67,12 +67,13 @@ class Manager:
         relay_pins: List,
         input_pins: List,
         ha_discovery: bool = True,
-        ha_discovery_prefix: str = "homeassistant",
+        ha_discovery_prefix: str = HOMEASSISTANT,
         mcp23017: Optional[List] = None,
         oled: bool = False,
-        web: bool = False,
+        web: bool = True,
     ) -> None:
         """Initialize the manager."""
+        _LOGGER.info("Initializing manager module.")
         loop = asyncio.get_event_loop()
         self._host_data = None
 
@@ -82,37 +83,54 @@ class Manager:
         self._input_pins = input_pins
         self._i2cbusio = I2C(SCL, SDA)
         self._mcp = {}
+        self._grouped_outputs = {}
         self._oled = None
         self._tasks: List[asyncio.Task] = []
 
         if mcp23017:
             for mcp in mcp23017:
-                self._mcp[mcp[ID] or mcp[ADDRESS]] = MCP23017(
-                    i2c=self._i2cbusio, address=mcp[ADDRESS]
+                id = mcp[ID] or mcp[ADDRESS]
+                self._mcp[id] = MCP23017(i2c=self._i2cbusio, address=mcp[ADDRESS])
+                sleep_time = mcp.get(INIT_SLEEP, 0)
+                _LOGGER.debug(
+                    f"Sleeping for {sleep_time}s while MCP {id} is initializing."
                 )
+                time.sleep(sleep_time)
+                self._grouped_outputs[id] = {}
 
         def configure_relay(gpio: dict) -> Any:
             """Configure kind of relay. Most common MCP."""
             if gpio[KIND] == MCP:
-                mcp = self._mcp.get(gpio.get(MCP_ID, ""))
+                mcp_id = gpio.get(MCP_ID, "")
+                mcp = self._mcp.get(mcp_id)
                 if not mcp:
                     _LOGGER.error("No such MCP configured!")
                     return
-                return MCPRelay(
+                relay_id = gpio[ID]
+                mcp_relay = MCPRelay(
                     pin=int(gpio[PIN]),
-                    id=gpio[ID],
+                    id=relay_id,
                     send_message=self.send_message,
                     topic_prefix=topic_prefix,
                     mcp=mcp,
+                    mcp_id=mcp_id,
                     ha_type=gpio[HA_TYPE],
+                    callback=lambda: self._host_data_callback(mcp_id),
                 )
+                self._grouped_outputs[mcp_id][relay_id] = mcp_relay
+                return mcp_relay
             elif gpio[KIND] == GPIO:
-                return GpioRelay(
+                if not GPIO in self._grouped_outputs:
+                    self._grouped_outputs[GPIO] = {}
+                gpio_relay = GpioRelay(
                     pin=gpio[PIN],
                     id=gpio[ID],
                     send_message=self.send_message,
                     topic_prefix=topic_prefix,
+                    callback=lambda: self._host_data_callback(GPIO),
                 )
+                self._grouped_outputs[GPIO][gpio[ID]] = gpio_relay
+                return gpio_relay
 
         self.output = {gpio[ID]: configure_relay(gpio) for gpio in relay_pins}
         for out in self.output.values():
@@ -137,15 +155,24 @@ class Manager:
         ]
 
         if oled or web:
-            self._host_data = HostData(output=self.output)
+            self._host_data = HostData(
+                output=self._grouped_outputs, callback=self._host_data_callback
+            )
             for f in host_stats.values():
                 self._tasks.append(asyncio.create_task(f(self._host_data)))
+            _LOGGER.debug("Gathering host data enabled.")
 
         if oled:
-            self._oled = Oled(self._host_data)
-            self._tasks.append(self._oled.get_task())
+            self._oled = Oled(
+                host_data=self._host_data, output_groups=list(self._grouped_outputs)
+            )
 
         self.send_message(topic=f"{topic_prefix}/{STATE}", payload=ONLINE)
+        _LOGGER.info("BoneIO manager is ready.")
+
+    def _host_data_callback(self, type):
+        if self._oled:
+            self._oled.handle_data_update(type)
 
     def get_tasks(self) -> Set[asyncio.Task]:
         return self._tasks

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

@@ -6,10 +6,12 @@ import uuid
 from contextlib import AsyncExitStack
 from typing import Any, Callable, Optional, Set, Union
 
-from asyncio_mqtt import Client as AsyncioClient, MqttError
 import paho.mqtt.client as mqtt
+from asyncio_mqtt import Client as AsyncioClient
+from asyncio_mqtt import MqttError
 from paho.mqtt.properties import Properties
 from paho.mqtt.subscribeoptions import SubscribeOptions
+
 from .const import PAHO
 
 _LOGGER = logging.getLogger(__name__)

boneio-0.1.0.dev8/boneio/oled.py

@@ -0,0 +1,108 @@
+import logging
+from itertools import cycle
+from typing import List
+
+from luma.core.interface.serial import i2c
+from luma.core.render import canvas
+from luma.oled.device import sh1106
+from PIL import ImageDraw
+
+from .const import CPU, DISK, MEMORY, NETWORK, OLED_PIN, SWAP, UPTIME, WHITE
+from .helper import HostData, edge_detect, make_font, setup_input
+from .input import configure_pin
+
+_LOGGER = logging.getLogger(__name__)
+
+
+fontBig = make_font("DejaVuSans.ttf", 12)
+fontSmall = make_font("DejaVuSans.ttf", 10)
+fontExtraSmall = make_font("DejaVuSans.ttf", 7)
+danube = make_font("danube__.ttf", 15, local=True)
+
+screen_order = [UPTIME, NETWORK, CPU, DISK, MEMORY, SWAP]
+
+STANDARD_ROWS = [17, 32, 47]
+UPTIME_ROWS = list(range(25, 40, 10))
+OUTPUT_ROWS = list(range(14, 60, 6))
+OUTPUT_COLS = range(0, 101, 50)
+
+
+class Oled:
+    """Oled display class."""
+
+    def __init__(self, host_data: HostData, output_groups: List[str]) -> None:
+        """Initialize OLED screen."""
+        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
+        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 _draw_standard(self, data: dict, draw: ImageDraw) -> None:
+        """Draw standard information about host screen."""
+        draw.text((1, 1), self._current_screen, font=fontBig, fill=WHITE)
+        i = 0
+        for k in data:
+            draw.text(
+                (3, STANDARD_ROWS[i]),
+                f"{k} {data[k]}",
+                font=fontSmall,
+                fill=WHITE,
+            )
+            i += 1
+
+    def _draw_uptime(self, data: dict, draw: ImageDraw) -> None:
+        """Draw uptime screen with boneIO logo."""
+        draw.text((3, 5), "bone", font=danube, fill=WHITE)
+        draw.text((53, 5), "iO", font=danube, fill=WHITE)
+        i = 0
+        for k in data:
+            draw.text(
+                (3, UPTIME_ROWS[i]),
+                f"{k}: {data[k]}",
+                font=fontSmall,
+                fill=WHITE,
+            )
+            i += 1
+
+    def _draw_output(self, data: dict, draw: ImageDraw) -> None:
+        "Draw outputs of GPIO/MCP relays."
+        cols = cycle(OUTPUT_COLS)
+        draw.text((1, 1), f"Relay {self._current_screen}", font=fontSmall, fill=WHITE)
+        i = 0
+        j = next(cols)
+        for k in data:
+            if len(OUTPUT_ROWS) == i:
+                j = next(cols)
+                i = 0
+            draw.text(
+                (j, OUTPUT_ROWS[i]), f"{k} {data[k]}", font=fontExtraSmall, fill=WHITE
+            )
+            i += 1
+
+    def render_display(self) -> None:
+        """Render display."""
+        data = self._host_data.get(self._current_screen)
+        if data:
+            with canvas(self._device) as draw:
+                if self._current_screen in self._output_groups:
+                    self._draw_output(data, draw)
+                elif self._current_screen == UPTIME:
+                    self._draw_uptime(data, draw)
+                else:
+                    self._draw_standard(data, draw)
+
+    def handle_data_update(self, type: str):
+        """Callback to handle new data present into screen."""
+        if type == self._current_screen:
+            self.render_display()
+
+    def _handle_press(self, pin: any) -> None:
+        """Handle press of PIN for OLED display."""
+        self._current_screen = next(self._screen_order)
+        self.render_display()

{boneio-0.1.0.dev7 → boneio-0.1.0.dev8}/boneio/relay/basic.py

@@ -1,9 +1,10 @@
 """Basic Relay module."""
 
 import asyncio
-from typing import Callable, Union
-from ..const import STATE, RELAY, ON, OFF, SWITCH
 import logging
+from typing import Callable, Union
+
+from ..const import OFF, ON, RELAY, STATE, SWITCH
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -14,6 +15,7 @@ class BasicRelay:
     def __init__(
         self,
         send_message: Callable[[str, Union[str, dict]], None],
+        callback: Callable,
         topic_prefix: str,
         id: str = None,
         ha_type=SWITCH,
@@ -25,8 +27,14 @@ class BasicRelay:
         self._relay_topic = f"{topic_prefix}/{RELAY}/"
         self._send_topic = f"{self._relay_topic}{self.id}"
         self._state = False
+        self._callback = callback
         self._loop = asyncio.get_running_loop()
 
+    @property
+    def is_mcp_type(self) -> bool:
+        """Check if relay is mcp type."""
+        return False
+
     @property
     def id(self) -> bool:
         """Id of the relay."""
@@ -45,6 +53,7 @@ class BasicRelay:
             topic=self._send_topic,
             payload={STATE: state},
         )
+        self._loop.call_soon_threadsafe(self._callback)
 
     def toggle(self) -> None:
         """Toggle relay."""

{boneio-0.1.0.dev7 → boneio-0.1.0.dev8}/boneio/relay/gpio.py

@@ -3,10 +3,11 @@
 Created just in case.
 """
 
-from ..helper.gpio import setup_output, read_input, write_output, HIGH, LOW
-from .basic import BasicRelay
 import logging
 
+from ..helper.gpio import HIGH, LOW, read_input, setup_output, write_output
+from .basic import BasicRelay
+
 _LOGGER = logging.getLogger(__name__)
 
 

{boneio-0.1.0.dev7 → boneio-0.1.0.dev8}/boneio/relay/mcp.py

@@ -1,24 +1,37 @@
 """MCP23017 Relay module."""
 
-from .basic import BasicRelay
-from adafruit_mcp230xx.mcp23017 import MCP23017
 import logging
 
+from adafruit_mcp230xx.mcp23017 import MCP23017
+
+from .basic import BasicRelay
+
 _LOGGER = logging.getLogger(__name__)
 
 
 class MCPRelay(BasicRelay):
     """Represents MCP Relay output"""
 
-    def __init__(self, pin: int, mcp: MCP23017, **kwargs) -> None:
+    def __init__(self, pin: int, mcp: MCP23017, mcp_id: str, **kwargs) -> None:
         """Initialize MCP relay."""
         super().__init__(**kwargs)
         self._pin_id = pin
         self._pin = mcp.get_pin(pin)
         self._pin.switch_to_output(value=True)
+        self._mcp_id = mcp_id
         self._pin.value = False
         _LOGGER.debug("Setup MCP with pin %s", self._pin_id)
 
+    @property
+    def is_mcp_type(self) -> bool:
+        """Check if relay is mcp type."""
+        return True
+
+    @property
+    def mcp_id(self) -> str:
+        """Retrieve parent MCP ID."""
+        return self._mcp_id
+
     @property
     def is_active(self) -> bool:
         """Is relay active."""

{boneio-0.1.0.dev7 → boneio-0.1.0.dev8}/boneio/schema.yaml

@@ -69,7 +69,13 @@ mcp23017:
         type: string
         required: True
         meta:
-          label: GPIO of I2C SDA 
+          label: GPIO of I2C SDA
+      init_sleep:
+        type: integer
+        required: True
+        default: 0
+        meta:
+          label: How long to sleep for MCP to initialize.
 
 output:
   type: list

boneio-0.1.0.dev8/boneio/version.py

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

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

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: boneio
-Version: 0.1.0.dev7
+Version: 0.1.0.dev8
 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.dev7.zip
+Download-URL: https://github.com/maciejk1984/boneIO/archive/0.1.0.dev8.zip
 Platform: UNKNOWN
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.7

{boneio-0.1.0.dev7 → boneio-0.1.0.dev8}/boneio.egg-info/SOURCES.txt

@@ -18,8 +18,10 @@ boneio.egg-info/dependency_links.txt
 boneio.egg-info/entry_points.txt
 boneio.egg-info/requires.txt
 boneio.egg-info/top_level.txt
+boneio/fonts/danube__.ttf
 boneio/helper/__init__.py
 boneio/helper/gpio.py
+boneio/helper/oled.py
 boneio/helper/stats.py
 boneio/helper/yaml.py
 boneio/input/__init__.py

boneio-0.1.0.dev7/boneio/helper/__init__.py

@@ -1,4 +0,0 @@
-"""Helper dir for BoneIO."""
-from .yaml import CustomValidator, load_yaml_file
-
-__all__ = ["CustomValidator", "load_yaml_file"]

boneio-0.1.0.dev7/boneio/input/__init__.py

@@ -1,5 +0,0 @@
-"""Input classes."""
-
-from .gpio import GpioInputButton
-
-__all__ = ["GpioInputButton"]

boneio-0.1.0.dev7/boneio/oled.py

@@ -1,82 +0,0 @@
-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

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

{boneio-0.1.0.dev7 → boneio-0.1.0.dev8}/boneio/relay/__init__.py

@@ -1,5 +1,5 @@
 """Relay module."""
-from .mcp import MCPRelay
 from .gpio import GpioRelay
+from .mcp import MCPRelay
 
 __all__ = ["MCPRelay", "GpioRelay"]