boneIO 0.1.0__py3-none-any.whl

boneio/example_config/output32x5A.yaml

@@ -0,0 +1,160 @@
+- id: light 1
+  kind: mcp
+  mcp_id: mcp1
+  pin: 0
+  ha_type: light
+- id: light 2
+  kind: mcp
+  mcp_id: mcp1
+  pin: 1
+  ha_type: light
+- id: light 3
+  kind: mcp
+  mcp_id: mcp1
+  pin: 2
+  ha_type: light
+- id: light 4
+  kind: mcp
+  mcp_id: mcp1
+  pin: 3
+  ha_type: light
+- id: light 5
+  kind: mcp
+  mcp_id: mcp1
+  pin: 4
+  ha_type: light
+- id: light 6
+  kind: mcp
+  mcp_id: mcp1
+  pin: 5
+  ha_type: light
+- id: light 7
+  kind: mcp
+  mcp_id: mcp1
+  pin: 6
+  ha_type: light
+- id: light 8
+  kind: mcp
+  mcp_id: mcp1
+  pin: 7
+  ha_type: light
+- id: light 9
+  kind: mcp
+  mcp_id: mcp1
+  pin: 8
+  ha_type: light
+- id: light 10
+  kind: mcp
+  mcp_id: mcp1
+  pin: 9
+  ha_type: light
+- id: light 11
+  kind: mcp
+  mcp_id: mcp1
+  pin: 10
+  ha_type: light
+- id: light 12
+  kind: mcp
+  mcp_id: mcp1
+  pin: 11
+  ha_type: light
+- id: light 13
+  kind: mcp
+  mcp_id: mcp1
+  pin: 12
+  ha_type: light
+- id: light 14
+  kind: mcp
+  mcp_id: mcp1
+  pin: 13
+  ha_type: light
+- id: light 15
+  kind: mcp
+  mcp_id: mcp1
+  pin: 14
+  ha_type: light
+- id: light 16
+  kind: mcp
+  mcp_id: mcp1
+  pin: 15
+  ha_type: light
+- id: switch 1
+  kind: mcp
+  mcp_id: mcp2
+  pin: 0
+  ha_type: switch
+- id: switch 2
+  kind: mcp
+  mcp_id: mcp2
+  pin: 1
+  ha_type: switch
+- id: switch 3
+  kind: mcp
+  mcp_id: mcp2
+  pin: 2
+  ha_type: switch
+- id: switch 4
+  kind: mcp
+  mcp_id: mcp2
+  pin: 3
+  ha_type: switch
+- id: switch 5
+  kind: mcp
+  mcp_id: mcp2
+  pin: 4
+  ha_type: switch
+- id: switch 6
+  kind: mcp
+  mcp_id: mcp2
+  pin: 5
+  ha_type: switch
+- id: switch 7
+  kind: mcp
+  mcp_id: mcp2
+  pin: 6
+  ha_type: switch
+- id: switch 8
+  kind: mcp
+  mcp_id: mcp2
+  pin: 7
+  ha_type: switch
+- id: switch 9
+  kind: mcp
+  mcp_id: mcp2
+  pin: 8
+  ha_type: switch
+- id: switch 10
+  kind: mcp
+  mcp_id: mcp2
+  pin: 9
+  ha_type: switch
+- id: switch 11
+  kind: mcp
+  mcp_id: mcp2
+  pin: 10
+  ha_type: switch
+- id: switch 12
+  kind: mcp
+  mcp_id: mcp2
+  pin: 11
+  ha_type: switch
+- id: switch 13
+  kind: mcp
+  mcp_id: mcp2
+  pin: 12
+  ha_type: switch
+- id: switch 14
+  kind: mcp
+  mcp_id: mcp2
+  pin: 13
+  ha_type: switch
+- id: switch 15
+  kind: mcp
+  mcp_id: mcp2
+  pin: 14
+  ha_type: switch
+- id: switch 16
+  kind: mcp
+  mcp_id: mcp2
+  pin: 15
+  ha_type: switch

boneio/helper/__init__.py

@@ -0,0 +1,50 @@
+"""Helper dir for BoneIO."""
+from boneio.helper.gpio import (
+    edge_detect,
+    setup_input,
+    setup_output,
+    read_input,
+    write_output,
+    GpioBaseClass,
+    configure_pin,
+)
+from boneio.helper.oled import make_font
+from boneio.helper.mqtt import BasicMqtt
+from boneio.helper.stats import HostData, host_stats
+from boneio.helper.yaml import CustomValidator, load_yaml_file
+from boneio.helper.ha_discovery import (
+    ha_relay_availabilty_message,
+    ha_sensor_temp_availabilty_message,
+    ha_binary_sensor_availabilty_message,
+    ha_input_availabilty_message,
+    ha_sensor_availabilty_message,
+    ha_adc_sensor_availabilty_message,
+)
+from boneio.helper.exceptions import GPIOInputException, I2CError
+from boneio.helper.queue import UniqueQueue
+
+
+__all__ = [
+    "CustomValidator",
+    "load_yaml_file",
+    "HostData",
+    "host_stats",
+    "setup_input",
+    "setup_output",
+    "edge_detect",
+    "read_input",
+    "write_output",
+    "make_font",
+    "ha_relay_availabilty_message",
+    "ha_sensor_availabilty_message",
+    "ha_adc_sensor_availabilty_message",
+    "ha_sensor_temp_availabilty_message",
+    "ha_binary_sensor_availabilty_message",
+    "ha_input_availabilty_message",
+    "GPIOInputException",
+    "I2CError",
+    "GpioBaseClass",
+    "configure_pin",
+    "BasicMqtt",
+    "UniqueQueue",
+]

boneio/helper/exceptions.py

@@ -0,0 +1,13 @@
+"""BoneIO Errors"""
+
+
+class BoneIOException(Exception):
+    """BoneIO standard exception."""
+
+
+class GPIOInputException(BoneIOException):
+    """GPIOInput Exception."""
+
+
+class I2CError(BoneIOException):
+    """I2C Exception."""

boneio/helper/gpio.py

@@ -0,0 +1,81 @@
+import asyncio
+import logging
+from Adafruit_BBIO import GPIO
+
+from boneio.helper.exceptions import GPIOInputException
+from boneio.const import LOW, FALLING, Gpio_Edges, Gpio_States
+from typing import Callable
+import subprocess
+
+from boneio.const import (
+    CONFIG_PIN,
+    GPIO as GPIO_STR,
+    ClickTypes,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def configure_pin(pin: str, mode: str = GPIO_STR) -> None:
+    pin = f"{pin[0:3]}0{pin[3]}" if len(pin) == 4 else pin
+    _LOGGER.debug(f"Configuring pin {pin} for mode {mode}.")
+    subprocess.run(
+        [CONFIG_PIN, pin, mode],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.STDOUT,
+        timeout=1,
+    )
+
+
+def setup_output(pin: str):
+    """Set up a GPIO as output."""
+
+    GPIO.setup(pin, GPIO.OUT, pull_up_down=GPIO.PUD_DOWN)
+
+
+def setup_input(pin: str, pull_mode: str = "UP"):
+    """Set up a GPIO as input."""
+    try:
+        GPIO.setup(pin, GPIO.IN, GPIO.PUD_DOWN if pull_mode == "DOWN" else GPIO.PUD_UP)
+    except (ValueError, SystemError) as err:
+        raise GPIOInputException(err)
+
+
+def write_output(pin: str, value: str):
+    """Write a value to a GPIO."""
+
+    GPIO.output(pin, value)
+
+
+def read_input(pin: str, on_state: Gpio_States = LOW):
+    """Read a value from a GPIO."""
+    return GPIO.input(pin) is on_state
+
+
+def edge_detect(
+    pin: str, callback: Callable, bounce: int = 0, edge: Gpio_Edges = FALLING
+):
+    """Add detection for RISING and FALLING events."""
+    try:
+        GPIO.add_event_detect(gpio=pin, edge=edge, callback=callback, bouncetime=bounce)
+    except RuntimeError as err:
+        raise GPIOInputException(err)
+
+
+class GpioBaseClass:
+    """Base class for initialize GPIO"""
+
+    def __init__(
+        self, pin: str, press_callback: Callable[[ClickTypes, str], None], **kwargs
+    ) -> None:
+        """Setup GPIO Input Button"""
+        self._pin = pin
+        configure_pin(pin)
+        self._loop = asyncio.get_running_loop()
+        self._press_callback = press_callback
+        setup_input(self._pin)
+
+    @property
+    def is_pressed(self):
+        """Is button pressed."""
+        return read_input(self._pin)

boneio/helper/ha_discovery.py

@@ -0,0 +1,128 @@
+from boneio.version import __version__
+
+
+from boneio.const import INPUT, OFF, ON, RELAY, STATE, SENSOR, INPUT_SENSOR
+
+
+def ha_relay_availabilty_message(id: str, name: str, topic: str = "boneio"):
+    """Create availability topic for HA."""
+    return {
+        "availability": [{"topic": f"{topic}/{STATE}"}],
+        "command_topic": f"{topic}/relay/{id}/set",
+        "device": {
+            "identifiers": [topic],
+            "manufacturer": "BoneIO",
+            "model": "BoneIO Relay Board",
+            "name": f"BoneIO {topic}",
+            "sw_version": __version__,
+        },
+        "name": name,
+        "payload_off": OFF,
+        "payload_on": ON,
+        "state_topic": f"{topic}/{RELAY}/{id}",
+        "unique_id": f"{topic}{RELAY}{id}",
+        "value_template": "{{ value_json.state }}",
+    }
+
+
+def ha_availabilty_message(
+    id: str, name: str, topic: str = "boneio", sensor_type: str = INPUT
+):
+    """Create availability topic for HA."""
+    return {
+        "availability": [{"topic": f"{topic}/{STATE}"}],
+        "device": {
+            "identifiers": [topic],
+            "manufacturer": "BoneIO",
+            "model": "BoneIO Relay Board",
+            "name": f"BoneIO {topic}",
+            "sw_version": __version__,
+        },
+        "icon": "mdi:gesture-double-tap",
+        "name": name,
+        "state_topic": f"{topic}/{sensor_type}/{id}",
+        "unique_id": f"{topic}{sensor_type}{id}",
+    }
+
+
+def ha_input_availabilty_message(**kwargs):
+    return ha_availabilty_message(sensor_type=INPUT, **kwargs)
+
+
+def ha_adc_sensor_availabilty_message(**kwargs):
+    msg = ha_availabilty_message(sensor_type=SENSOR, **kwargs)
+    msg["unit_of_measurement"] = "V"
+    msg["device_class"] = "voltage"
+    msg["state_class"] = "measurement"
+    return msg
+
+
+def ha_sensor_availabilty_message(unit_of_measurement: str = None, **kwargs):
+    msg = ha_availabilty_message(sensor_type=SENSOR, **kwargs)
+    if not unit_of_measurement:
+        return msg
+
+
+def ha_binary_sensor_availabilty_message(id: str, name: str, topic: str = "boneio"):
+    """Create availability topic for HA."""
+    return {
+        "availability": [{"topic": f"{topic}/{STATE}"}],
+        "device": {
+            "identifiers": [topic],
+            "manufacturer": "BoneIO",
+            "model": "BoneIO Relay Board",
+            "name": f"BoneIO {topic}",
+            "sw_version": __version__,
+        },
+        "payload_on": "pressed",
+        "payload_off": "released",
+        "name": name,
+        "state_topic": f"{topic}/{INPUT_SENSOR}/{id}",
+        "unique_id": f"{topic}{INPUT_SENSOR}{id}",
+    }
+
+
+def ha_sensor_temp_availabilty_message(id: str, name: str, topic: str = "boneio"):
+    """Create availability topic for HA."""
+    return {
+        "availability": [{"topic": f"{topic}/{STATE}"}],
+        "device": {
+            "identifiers": [topic],
+            "manufacturer": "BoneIO",
+            "model": "BoneIO Relay Board",
+            "name": f"BoneIO {topic}",
+            "sw_version": __version__,
+        },
+        "name": name,
+        "state_topic": f"{topic}/{SENSOR}/{id}",
+        "unique_id": f"{topic}{SENSOR}{id}",
+        "device_class": "temperature",
+        "state_class": "measurement",
+        "unit_of_measurement": "°C",
+        "value_template": "{{ value_json.state }}",
+    }
+
+
+def sdm630_availabilty_message(
+    id: str,
+    sensor_id: str,
+    name: str,
+    topic: str = "sdm630",
+    sensor_type: str = SENSOR,
+    **kwargs,
+):
+    """Create SDM630 availability topic for HA."""
+    return {
+        "availability": [{"topic": f"{topic}/{id}{STATE}"}],
+        "device": {
+            "identifiers": [topic, id],
+            "manufacturer": "BoneIO",
+            "model": "SDM630",
+            "name": f"BoneIO {name.upper()}",
+            "sw_version": __version__,
+        },
+        "name": sensor_id,
+        "state_topic": f"{topic}/{sensor_type}/{id}/{sensor_id}",
+        "unique_id": f"{topic}{sensor_id.replace('_', '').lower()}",
+        **kwargs,
+    }

boneio/helper/mqtt.py

@@ -0,0 +1,30 @@
+"""Class to help initialize classes which uses mqtt send."""
+from typing import Callable, Union
+
+
+class BasicMqtt:
+    """Basic MQTT class."""
+
+    def __init__(
+        self,
+        id: str,
+        topic_prefix: str,
+        name: str,
+        send_message: Callable[[str, Union[str, dict]], None],
+        topic_type: str,
+    ):
+        """Initialize module."""
+        self._id = id.replace(" ", "")
+        self._name = name
+        self._send_message = send_message
+        self._send_topic = f"{topic_prefix}/{topic_type}/{self.id}"
+
+    @property
+    def id(self) -> bool:
+        """Id of the module."""
+        return self._id
+
+    @property
+    def name(self):
+        """Return name of the sensor."""
+        return self._name

boneio/helper/oled.py

@@ -0,0 +1,15 @@
+import os
+
+from PIL import ImageFont
+
+from boneio.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/helper/queue.py

@@ -0,0 +1,32 @@
+"""
+Special unique implementation of asyncio.Queue for boneIO.
+If MQTT is down then regular queue can append multiple ON/OFF for same topic.
+After re-connection it would send all messages. It's not necessary, last payload of same topic is enough.
+"""
+import asyncio
+
+
+class UniqueQueue(asyncio.Queue):
+    """Unique implementation of asyncio.Queue."""
+
+    def _init(self, maxsize):
+        """Create unique dict of tuple[0]."""
+        super()._init(maxsize=maxsize)
+        self._unique_set = {}
+
+    def _put(self, item):
+        """If item does not exists add it.
+        If exists remove old one and put new one in the beginning of the queue."""
+        if item[0] not in self._unique_set:
+            super()._put(item)
+            self._unique_set[item[0]] = item
+        else:
+            self._queue.remove(self._unique_set[item[0]])
+            super()._put(item)
+            self._unique_set[item[0]] = item
+
+    def _get(self):
+        """Get item and remove it."""
+        item = super()._get()
+        del self._unique_set[item[0]]
+        return item

boneio/helper/stats.py

@@ -0,0 +1,185 @@
+import asyncio
+import socket
+import time
+from functools import partial
+from math import floor
+from typing import Callable
+
+import psutil
+
+from boneio.const import (
+    CPU,
+    DISK,
+    GIGABYTE,
+    HOST,
+    MEGABYTE,
+    MEMORY,
+    NETWORK,
+    SWAP,
+    UPTIME,
+    IP,
+    MASK,
+    MAC,
+    NONE,
+)
+from boneio.sensor import LM75Sensor, MCP9808Sensor
+
+
+intervals = (("d", 86400), ("h", 3600), ("m", 60))
+
+
+def display_time(seconds):
+    """Strf time."""
+    result = []
+
+    for name, count in intervals:
+        value = seconds // count
+        if value:
+            seconds -= value * count
+            if value == 1:
+                name = name.rstrip("s")
+            result.append(f"{int(value)}{name}")
+    return "".join(result)
+
+
+async def get_network_info(host_data):
+    """Fetch network info."""
+
+    def retrieve_from_psutil():
+        addrs = psutil.net_if_addrs()["eth0"]
+        out = {IP: NONE, MASK: NONE, MAC: NONE}
+        for addr in addrs:
+            if addr.family == socket.AF_INET:
+                out["ip"] = addr.address
+                out["mask"] = addr.netmask
+            elif addr.family == psutil.AF_LINK:
+                out["mac"] = addr.address
+        return out
+
+    while True:
+        data = retrieve_from_psutil()
+        host_data.write(NETWORK, data)
+        await asyncio.sleep(60)
+
+
+async def get_cpu_info(host_data):
+    """Fetch CPU info."""
+    while True:
+        cpu = psutil.cpu_times_percent()
+        host_data.write(
+            CPU,
+            {
+                "total": f"{int(100 - cpu.idle)}%",
+                "user": f"{cpu.user}%",
+                "system": f"{cpu.system}%",
+            },
+        )
+        await asyncio.sleep(5)
+
+
+async def get_disk_info(host_data):
+    """Fetch disk info."""
+    while True:
+        disk = psutil.disk_usage("/")
+        host_data.write(
+            DISK,
+            {
+                "total": f"{floor(disk.total / GIGABYTE)}GB",
+                "used": f"{floor(disk.used / GIGABYTE)}GB",
+                "free": f"{floor(disk.free / GIGABYTE)}GB",
+            },
+        )
+        await asyncio.sleep(60)
+
+
+async def get_memory_info(host_data):
+    """Fetch memory info."""
+    while True:
+        vm = psutil.virtual_memory()
+        host_data.write(
+            MEMORY,
+            {
+                "total": f"{floor(vm.total / MEGABYTE)}MB",
+                "used": f"{floor(vm.used / MEGABYTE)}MB",
+                "free": f"{floor(vm.available / MEGABYTE)}MB",
+            },
+        )
+        await asyncio.sleep(10)
+
+
+async def get_swap_info(host_data):
+    """Fetch swap info."""
+    while True:
+        swap = psutil.swap_memory()
+        host_data.write(
+            SWAP,
+            {
+                "total": f"{floor(swap.total / MEGABYTE)}MB",
+                "used": f"{floor(swap.used / MEGABYTE)}MB",
+                "free": f"{floor(swap.free / MEGABYTE)}MB",
+            },
+        )
+        await asyncio.sleep(10)
+
+
+async def get_uptime(host_data):
+    """Fetch uptime info."""
+    while True:
+        uptime = display_time(time.clock_gettime(time.CLOCK_BOOTTIME))
+        host_data.write_uptime(uptime)
+        await asyncio.sleep(30)
+
+
+host_stats = {
+    NETWORK: get_network_info,
+    CPU: get_cpu_info,
+    DISK: get_disk_info,
+    MEMORY: get_memory_info,
+    SWAP: get_swap_info,
+    UPTIME: get_uptime,
+}
+
+
+class HostData:
+    """Helper class to store host data."""
+
+    data = {UPTIME: {}, NETWORK: {}, CPU: {}, DISK: {}, MEMORY: {}, SWAP: {}}
+
+    def __init__(
+        self,
+        output: dict,
+        callback: Callable,
+        temp_sensor: Callable[[LM75Sensor, MCP9808Sensor], None],
+    ) -> None:
+        """Initialize HostData."""
+        self._hostname = socket.gethostname()
+        self.data[UPTIME] = {HOST: self._hostname, UPTIME: 0}
+        self._temp_sensor = temp_sensor
+        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
+        if self._temp_sensor:
+            self.data[UPTIME][self._temp_sensor.name] = self._temp_sensor.state
+        self._loop.call_soon_threadsafe(partial(self._callback, UPTIME))
+
+    def get(self, type: str) -> dict:
+        """Get saved stats."""
+        if type in self._output:
+            return self._get_output(type)
+        return self.data[type]
+
+    def _get_output(self, type: str) -> dict:
+        """Get stats for output."""
+        out = {}
+        for output in self._output[type].values():
+            out[output.id] = output.state
+        return out