boneIO 0.1.0.dev3__tar.gz → 0.1.0.dev4__tar.gz

{boneio-0.1.0.dev3 → boneio-0.1.0.dev4}/PKG-INFO

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

boneio-0.1.0.dev4/boneio/__init__.py

@@ -0,0 +1,11 @@
+"""Python library to control BoneIO."""
+
+from .version import __version__ as version
+
+name = "boneio"
+
+
+__all__ = [
+    "boneio",
+    "version",
+]

boneio-0.1.0.dev4/boneio/bonecli.py

@@ -0,0 +1,143 @@
+from .helper import CustomValidator, load_yaml_file
+import click
+import logging
+from colorlog import ColoredFormatter
+from .mqtt_client import MQTTClient
+from .manager import Manager
+from .const import (
+    ENABLED,
+    GPIO_INPUT,
+    HA_DISCOVERY,
+    MCP23017,
+    OLED,
+    OUTPUT,
+    PAHO,
+    MQTT,
+    HOST,
+    TOPIC_PREFIX,
+    USERNAME,
+    PASSWORD,
+)
+from .version import __version__
+import asyncio
+import os
+from functools import wraps
+
+_LOGGER = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+fmt = "%(asctime)s %(levelname)s (%(threadName)s) [%(name)s] %(message)s"
+datefmt = "%Y-%m-%d %H:%M:%S"
+colorfmt = f"%(log_color)s{fmt}%(reset)s"
+logging.getLogger().handlers[0].setFormatter(
+    ColoredFormatter(
+        colorfmt,
+        datefmt=datefmt,
+        reset=True,
+        log_colors={
+            "DEBUG": "cyan",
+            "INFO": "green",
+            "WARNING": "yellow",
+            "ERROR": "red",
+            "CRITICAL": "red",
+        },
+    )
+)
+
+MAINPATH = os.path.join(os.path.dirname(__file__))
+
+
+def add_options(options):
+    def _add_options(func):
+        for option in reversed(options):
+            func = option(func)
+        return func
+
+    return _add_options
+
+
+def coro(f):
+    @wraps(f)
+    def wrapper(*args, **kwargs):
+        return asyncio.run(f(*args, **kwargs))
+
+    return wrapper
+
+
+@click.group(no_args_is_help=True)
+@click.pass_context
+@click.version_option(__version__)
+@coro
+async def cli(ctx):
+    """A tool to run commands."""
+    pass
+
+
+_options = [
+    click.option(
+        "-d",
+        "--debug",
+        default=False,
+        count=True,
+        help="Set Debug mode. Single debug is debug of this lib. Second d is debug of aioxmpp as well.",
+    ),
+    click.option(
+        "--config",
+        "-c",
+        type=str,
+        default="./config.yaml",
+        help="Config yaml file. Default to ./config.yaml",
+    ),
+    click.option(
+        "--mqttpassword",
+        envvar="MQTTPASS",
+        type=str,
+        help="Mqtt password. To use as ENV named MQTTPASS",
+    ),
+]
+
+
+@cli.command()
+@add_options(_options)
+@click.pass_context
+@coro
+async def run(ctx, debug: int, config: str, mqttpassword: str = ""):
+    """Run BoneIO."""
+    if debug == 0:
+        logging.getLogger().setLevel(logging.INFO)
+    if debug > 0:
+        logging.getLogger().setLevel(logging.DEBUG)
+
+        _LOGGER.info("Debug mode active")
+        _LOGGER.debug(f"Lib version is {__version__}")
+    if debug > 1:
+        logging.getLogger(PAHO).setLevel(logging.DEBUG)
+    else:
+        logging.getLogger(PAHO).setLevel(logging.WARN)
+    schema = load_yaml_file(os.path.join(MAINPATH, "schema.yaml"))
+    v = CustomValidator(schema, purge_unknown=True)
+    config_yaml = load_yaml_file(config)
+    if not config_yaml:
+        _LOGGER.info("Missing file.")
+        return
+    _config = v.normalized(config_yaml)
+    client = MQTTClient(
+        host=_config[MQTT][HOST],
+        username=_config[MQTT].get(USERNAME),
+        password=_config[MQTT].get(PASSWORD, mqttpassword),
+    )
+
+    manager = Manager(
+        send_message=client.send_message,
+        topic_prefix=_config[MQTT][TOPIC_PREFIX],
+        relay_pins=_config[OUTPUT],
+        input_pins=_config[GPIO_INPUT],
+        ha_discovery=_config[MQTT][HA_DISCOVERY][ENABLED],
+        ha_discovery_prefix=_config[MQTT][HA_DISCOVERY][TOPIC_PREFIX],
+        mcp23017=_config[MCP23017],
+        oled=_config.get(OLED),
+    )
+    await client.start_client(manager)
+
+
+if __name__ == "__main__":
+    asyncio.get_event_loop().run_until_complete(cli())

boneio-0.1.0.dev4/boneio/const.py

@@ -0,0 +1,55 @@
+# from typing import Literal
+from typing_extensions import Literal
+from datetime import timedelta
+
+DEBOUNCE_DURATION = timedelta(seconds=0.2)
+LONG_PRESS_DURATION = timedelta(seconds=0.7)
+DELAY_DURATION = 0.1
+SECOND_DELAY_DURATION = 0.3
+RELAY = "relay"
+SINGLE = "single"
+DOUBLE = "double"
+LONG = "long"
+ONLINE = "online"
+ON = "ON"
+OFF = "OFF"
+STATE = "state"
+PAHO = "paho.mqtt.client"
+ClickTypes = Literal[SINGLE, DOUBLE, LONG]
+MQTT = "mqtt"
+HOST = "host"
+USERNAME = "username"
+PASSWORD = "password"
+TOPIC_PREFIX = "topic_prefix"
+HA_DISCOVERY = "ha_discovery"
+ENABLED = "enabled"
+GPIO_INPUT = "gpio_input"
+OUTPUT = "output"
+PIN = "pin"
+ID = "id"
+KIND = "kind"
+GPIO = "gpio"
+ACTIONS = "actions"
+ACTION = "action"
+OUTPUT = "output"
+ADDRESS = "address"
+MCP23017 = "mcp23017"
+SWITCH = "switch"
+CONFIG_PIN = "/usr/bin/config-pin"
+MCP = "mcp"
+MCP_ID = "mcp_id"
+HA_TYPE = "ha_type"
+GIGABYTE = 1073741824
+MEGABYTE = 1048576
+OLED_PIN = "P9_41"
+NUM_OF_SCREENS = 6
+WIDTH = 128
+UPTIME = "uptime"
+NETWORK = "network"
+CPU = "cpu"
+DISK = "disk"
+MEMORY = "memory"
+SWAP = "swap"
+WHITE = "white"
+OLED = "oled"
+OledDataTypes = Literal[UPTIME, NETWORK, CPU, DISK, MEMORY, SWAP, OUTPUT]

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

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

boneio-0.1.0.dev4/boneio/helper/gpio.py

@@ -0,0 +1,30 @@
+from Adafruit_BBIO import GPIO
+from Adafruit_BBIO.GPIO import HIGH, LOW
+
+
+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."""
+    GPIO.setup(pin, GPIO.IN, GPIO.PUD_DOWN if pull_mode == "DOWN" else GPIO.PUD_UP)
+
+
+def write_output(pin: str, value: str):
+    """Write a value to a GPIO."""
+
+    GPIO.output(pin, value)
+
+
+def read_input(pin: str, on_state=LOW):
+    """Read a value from a GPIO."""
+    return GPIO.input(pin) is on_state
+
+
+def edge_detect(pin, callback, bounce):
+    """Add detection for RISING and FALLING events."""
+
+    GPIO.add_event_detect(pin, GPIO.FALLING, callback=callback, bouncetime=bounce)

boneio-0.1.0.dev4/boneio/helper/stats.py

@@ -0,0 +1,115 @@
+import asyncio
+import psutil
+from math import floor
+from ..const import GIGABYTE, MEGABYTE, NETWORK, DISK, MEMORY, CPU, SWAP, UPTIME
+import time
+
+intervals = (
+    ("d", 86400),  # 60 * 60 * 24
+    ("h", 3600),  # 60 * 60
+    ("m", 60),
+    ("s", 1),
+)
+
+
+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."""
+    while True:
+        net = psutil.net_if_addrs()["eth0"]
+        host_data.write(
+            NETWORK,
+            {"ip": net[0].address, "mask": net[0].netmask, "mac": net[2].address},
+        )
+        await asyncio.sleep(30)
+
+
+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)}%",
+                "used": f"{floor(vm.used / MEGABYTE)}%",
+                "free": f"{floor(vm.available / MEGABYTE)}%",
+            },
+        )
+        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)}%",
+                "used": f"{floor(swap.used / MEGABYTE)}%",
+                "free": f"{floor(swap.free / MEGABYTE)}%",
+            },
+        )
+        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(10)
+
+
+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,
+}

boneio-0.1.0.dev4/boneio/helper/yaml.py

@@ -0,0 +1,46 @@
+from typing import Any
+import os
+from cerberus import Validator
+from ..const import ID, OLED, OUTPUT
+from yaml import load, YAMLError, SafeLoader
+
+
+class Loader(SafeLoader):
+    """Loader which support for include in yaml files."""
+
+    def __init__(self, stream):
+
+        self._root = os.path.split(stream.name)[0]
+
+        super(Loader, self).__init__(stream)
+
+    def include(self, node):
+
+        filename = os.path.join(self._root, self.construct_scalar(node))
+
+        with open(filename, "r") as f:
+            return load(f, Loader)
+
+
+Loader.add_constructor("!include", Loader.include)
+
+
+def load_yaml_file(filename: str) -> Any:
+    with open(filename, "r") as stream:
+        try:
+            return load(stream, Loader=Loader)
+        except YAMLError as exception:
+            raise exception
+
+
+class CustomValidator(Validator):
+    """Custom validator of cerberus"""
+
+    def _check_with_output_id_uniqueness(self, field, value):
+        """Check if outputs ids are unique."""
+        all_ids = [x[ID] for x in self.document[OUTPUT]]
+        if len(all_ids) != len(set(all_ids)):
+            self._error(field, "Output IDs are not unique.")
+
+    def _normalize_coerce_to_bool(self, value):
+        return True

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

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

boneio-0.1.0.dev4/boneio/input/gpio.py

@@ -0,0 +1,147 @@
+"""GPIOInputButton to receive signals."""
+from ..helper.gpio import setup_input, read_input, edge_detect
+import subprocess
+from functools import partial
+from typing import Callable, Any
+from datetime import datetime
+import logging
+import asyncio
+from ..const import (
+    CONFIG_PIN,
+    GPIO,
+    SINGLE,
+    DOUBLE,
+    LONG,
+    ClickTypes,
+    DEBOUNCE_DURATION,
+    LONG_PRESS_DURATION,
+    DELAY_DURATION,
+    SECOND_DELAY_DURATION,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def configure_pin(pin: str) -> None:
+    pin = f"{pin[0:3]}0{pin[3]}" if len(pin) == 4 else pin
+    _LOGGER.debug(f"Configuring pin for GPIO {pin}")
+    subprocess.run(
+        [CONFIG_PIN, pin, GPIO],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.STDOUT,
+    )
+
+
+class GpioInputButton:
+    """Represent Gpio input switch."""
+
+    def __init__(
+        self, pin: str, press_callback: Callable[[ClickTypes, str], None], rest_pin: Any
+    ) -> 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)
+        edge_detect(self._pin, callback=self._handle_press, bounce=25)
+        self._first_press_timestamp = None
+        self._is_long_press = False
+        self._second_press_timestamp = None
+        self._second_check = False
+        _LOGGER.debug("Configured listening for input pin %s", self._pin)
+
+    def _handle_press(self, pin) -> None:
+        """Handle the button press callback"""
+        # Ignore if we are in a long press
+        if self._is_long_press:
+            return
+        now = datetime.now()
+
+        # Debounce button
+        if (
+            self._first_press_timestamp is not None
+            and now - self._first_press_timestamp < DEBOUNCE_DURATION
+        ):
+            return
+
+        # Second click debounce. Just in case.
+        if (
+            self._second_press_timestamp is not None
+            and now - self._second_press_timestamp < DEBOUNCE_DURATION
+        ):
+            return
+
+        if not self._first_press_timestamp:
+            self._first_press_timestamp = now
+        elif not self._second_press_timestamp:
+            self._second_press_timestamp = now
+
+        self._loop.call_soon_threadsafe(
+            self._loop.call_later,
+            DELAY_DURATION,
+            self.check_press_length,
+        )
+
+    @property
+    def is_pressed(self):
+        """Is button pressed."""
+        return read_input(self._pin)
+
+    def check_press_length(self) -> None:
+        """Check if it's a single, double or long press"""
+        # Check if button is still pressed
+        if self.is_pressed:
+            # Schedule a new check
+            self._loop.call_soon_threadsafe(
+                self._loop.call_later,
+                DELAY_DURATION,
+                self.check_press_length,
+            )
+
+            # Handle edge case due to multiple clicks
+            if self._first_press_timestamp is None:
+                return
+
+            # Check if we reached a long press
+            diff = datetime.now() - self._first_press_timestamp
+            if not self._is_long_press and diff > LONG_PRESS_DURATION:
+                self._is_long_press = True
+                _LOGGER.debug("Long button press, call callback")
+                self._loop.call_soon_threadsafe(
+                    partial(self._press_callback, LONG, self._pin)
+                )
+            return
+
+        # Handle short press
+        if not self._is_long_press:
+            if not self._second_press_timestamp and not self._second_check:
+                # let's try to check if second click will atempt
+                self._second_check = True
+                self._loop.call_soon_threadsafe(
+                    self._loop.call_later,
+                    SECOND_DELAY_DURATION,
+                    self.check_press_length,
+                )
+                return
+            if self._second_check:
+                if self._second_press_timestamp:
+                    _LOGGER.debug(
+                        "Double click event, roznica %s",
+                        self._second_press_timestamp - self._first_press_timestamp,
+                    )
+                    self._loop.call_soon_threadsafe(
+                        partial(self._press_callback, DOUBLE, self._pin)
+                    )
+
+                elif self._first_press_timestamp:
+                    _LOGGER.debug("One click event, call callback")
+                    self._loop.call_soon_threadsafe(
+                        partial(self._press_callback, SINGLE, self._pin)
+                    )
+
+        # Clean state on button released
+        self._first_press_timestamp = None
+        self._second_press_timestamp = None
+        self._second_check = False
+        self._is_long_press = False

boneio-0.1.0.dev4/boneio/manager.py

@@ -0,0 +1,170 @@
+from .input import GpioInputButton
+from .relay import GpioRelay, MCPRelay
+from .oled import Oled
+from .const import (
+    ACTION,
+    ACTIONS,
+    ADDRESS,
+    GPIO,
+    HA_TYPE,
+    ID,
+    KIND,
+    MCP,
+    MCP_ID,
+    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
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def ha_availibilty_message(topic, relay_id):
+    """Create availability topic for HA."""
+    return {
+        "availability": [{"topic": f"{topic}/{STATE}"}],
+        "command_topic": f"{topic}/relay/{relay_id}/set",
+        "device": {
+            "identifiers": [topic],
+            "manufacturer": "BoneIO",
+            "model": "BoneIO Relay Board",
+            "name": f"BoneIO {topic}",
+            "sw_version": "0.0.1",
+        },
+        "name": f"Relay {relay_id}",
+        "payload_off": OFF,
+        "payload_on": ON,
+        "state_topic": f"{topic}/{RELAY}/{relay_id}",
+        "unique_id": f"{topic}{RELAY}{relay_id}",
+        "value_template": "{{ value_json.state }}",
+    }
+
+
+class Manager:
+    """Manager to communicate MQTT with GPIO inputs and outputs."""
+
+    def __init__(
+        self,
+        send_message: Callable[[str, Union[str, dict]], None],
+        topic_prefix: str,
+        relay_pins: List,
+        input_pins: List,
+        ha_discovery: bool = True,
+        ha_discovery_prefix: str = "homeassistant",
+        mcp23017: Optional[List] = None,
+        oled: bool = False,
+    ) -> None:
+        """Initialize the manager."""
+        loop = asyncio.get_event_loop()
+
+        self.send_message = send_message
+        self._topic_prefix = topic_prefix
+        self.relay_topic = f"{topic_prefix}/{RELAY}/+/set"
+        self._input_pins = input_pins
+        self._i2cbusio = I2C(SCL, SDA)
+        self._mcp = {}
+        self._oled = None
+
+        if mcp23017:
+            for mcp in mcp23017:
+                self._mcp[mcp[ID] or mcp[ADDRESS]] = MCP23017(
+                    i2c=self._i2cbusio, address=mcp[ADDRESS]
+                )
+
+        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, ""))
+                if not mcp:
+                    _LOGGER.error("No such MCP configured!")
+                    return
+                return MCPRelay(
+                    pin=int(gpio[PIN]),
+                    id=gpio[ID],
+                    send_message=self.send_message,
+                    topic_prefix=topic_prefix,
+                    mcp=mcp,
+                    ha_type=gpio[HA_TYPE],
+                )
+            elif gpio[KIND] == GPIO:
+                return GpioRelay(
+                    pin=gpio[PIN],
+                    id=gpio[ID],
+                    send_message=self.send_message,
+                    topic_prefix=topic_prefix,
+                )
+
+        self.output = {gpio[ID]: configure_relay(gpio) for gpio in relay_pins}
+        for out in self.output.values():
+            if ha_discovery:
+                _LOGGER.debug("Sending HA discovery.")
+                self.send_ha_autodiscovery(
+                    relay=out.id, ha_type=out.ha_type, prefix=ha_discovery_prefix
+                )
+            loop.call_soon_threadsafe(
+                loop.call_later,
+                0.5,
+                out.send_state,
+            )
+
+        self.buttons = [
+            GpioInputButton(
+                pin=gpio[PIN],
+                press_callback=lambda x, i: self.press_callback(x, i, gpio[ACTIONS]),
+                rest_pin=gpio,
+            )
+            for gpio in self._input_pins
+        ]
+
+        if oled:
+            self._oled = Oled(self.output)
+
+        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 press_callback(self, x: ClickTypes, inpin: str, actions: dict) -> None:
+        """Press callback to use in input gpio.
+        If relay input map is provided also toggle action on relay."""
+        self.send_message(topic=f"{self._topic_prefix}/input/{inpin}", payload=x)
+        action = actions.get(x)
+        if action:
+            if action[ACTION] == OUTPUT:
+                """For now only output type is supported"""
+                output_gpio = self.output.get(action[PIN])
+                if output_gpio:
+                    output_gpio.toggle()
+
+    def send_ha_autodiscovery(
+        self, relay: str, prefix: str, ha_type: str = "switch"
+    ) -> None:
+        """Send HA autodiscovery information for each relay."""
+        msg = ha_availibilty_message(self._topic_prefix, relay_id=relay)
+        topic = f"{prefix}/{ha_type}/{self._topic_prefix}/{ha_type}/config"
+        self.send_message(topic=topic, payload=msg)
+
+    def receive_message(self, topic: str, message: str) -> None:
+        """Callback for receiving action from Mqtt."""
+        extracted_relay = topic.replace(f"{self._topic_prefix}/{RELAY}/", "").replace(
+            "/set", ""
+        )
+        target_device = self.output.get(extracted_relay)
+        if target_device:
+            if message == ON:
+                target_device.turn_on()
+            elif message == OFF:
+                target_device.turn_off()

boneio-0.1.0.dev4/boneio/mqtt_client.py

@@ -0,0 +1,183 @@
+"""Provide an MQTT client for providing BoneIO MQTT broker."""
+import asyncio
+import json
+import logging
+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 paho.mqtt.properties import Properties
+from paho.mqtt.subscribeoptions import SubscribeOptions
+from .const import PAHO
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class MQTTClient:
+    """Represent an MQTT client."""
+
+    def __init__(
+        self,
+        host: str,
+        port: int = 1883,
+        **client_options: Any,
+    ) -> None:
+        """Set up client."""
+        self.host = host
+        self.port = port
+        if "client_id" not in client_options:
+            client_options["client_id"] = mqtt.base62(uuid.uuid4().int, padding=22)
+        if "logger" not in client_options:
+            client_options["logger"] = logging.getLogger(PAHO)
+        client_options["clean_session"] = True
+        self.client_options = client_options
+        self.asyncio_client: AsyncioClient = None
+        self.create_client()
+        self.reconnect_interval = 1
+        self.publish_queue: asyncio.Queue = asyncio.Queue()
+
+    def create_client(self) -> None:
+        """Create the asyncio client."""
+        self.asyncio_client = AsyncioClient(
+            self.host,
+            self.port,
+            **self.client_options,
+        )
+
+    async def connect(self, *, timeout: float = 10.0) -> None:
+        """Connect to the broker.
+
+        Can raise asyncio_mqtt.MqttError.
+        """
+        await self.asyncio_client.connect(timeout=timeout)
+
+    async def disconnect(self, *, timeout: float = 10.0) -> None:
+        """Disconnect from the broker.
+
+        Can raise asyncio_mqtt.MqttError.
+        """
+        await self.asyncio_client.disconnect(timeout=timeout)
+
+    async def publish(  # pylint:disable=too-many-arguments
+        self,
+        topic: str,
+        payload: Optional[str] = None,
+        qos: int = 0,
+        retain: bool = False,
+        properties: Optional[Properties] = None,
+        timeout: float = 10,
+    ) -> None:
+        """Publish to topic.
+
+        Can raise asyncio_mqtt.MqttError.
+        """
+        params: dict = {"qos": qos, "retain": retain, "timeout": timeout}
+        if payload:
+            params["payload"] = payload
+        if properties:
+            params["properties"] = properties
+
+        _LOGGER.debug("Sending message topic: %s, payload: %s", topic, payload)
+        await self.asyncio_client.publish(topic, **params)
+
+    async def subscribe(  # pylint:disable=too-many-arguments
+        self,
+        topic: str,
+        qos: int = 0,
+        options: Optional[SubscribeOptions] = None,
+        properties: Optional[Properties] = None,
+        timeout: float = 10.0,
+    ) -> None:
+        """Subscribe to topic.
+
+        Can raise asyncio_mqtt.MqttError.
+        """
+        params: dict = {"qos": qos, "timeout": timeout}
+        if options:
+            params["options"] = options
+        if properties:
+            params["properties"] = properties
+
+        await self.asyncio_client.subscribe(topic, **params)
+
+    async def unsubscribe(
+        self, topic: str, properties: Optional[Properties] = None, timeout: float = 10.0
+    ) -> None:
+        """Unsubscribe from topic.
+
+        Can raise asyncio_mqtt.MqttError.
+        """
+        params: dict = {"timeout": timeout}
+        if properties:
+            params["properties"] = properties
+
+        await self.asyncio_client.unsubscribe(topic, **params)
+
+    def send_message(self, topic: str, payload: Union[str, dict]) -> None:
+        """Send a message from the manager options."""
+        to_publish = (topic, json.dumps(payload) if type(payload) == dict else payload)
+        self.publish_queue.put_nowait(to_publish)
+
+    async def _handle_publish(self) -> None:
+        """Publish messages as they are put on the queue."""
+        while True:
+            to_publish: tuple = await self.publish_queue.get()
+            await self.publish(*to_publish)
+            self.publish_queue.task_done()
+
+    async def start_client(self, manager: any) -> None:
+        """Start the client with the manager."""
+        # Reconnect automatically until the client is stopped.
+        while True:
+            try:
+                await self._subscribe_manager(manager)
+            except MqttError as err:
+                self.reconnect_interval = min(self.reconnect_interval * 2, 900)
+                _LOGGER.error(
+                    "MQTT error: %s. Reconnecting in %s seconds",
+                    err,
+                    self.reconnect_interval,
+                )
+                await asyncio.sleep(self.reconnect_interval)
+                self.create_client()  # reset connect/reconnect futures
+
+    async def _subscribe_manager(self, manager: any) -> None:
+        """Connect and subscribe to manager topics."""
+        async with AsyncExitStack() as stack:
+            tasks: Set[asyncio.Task] = set()
+
+            # Connect to the MQTT broker.
+            await stack.enter_async_context(self.asyncio_client)
+            # Reset the reconnect interval after successful connection.
+            self.reconnect_interval = 1
+
+            publish_task = asyncio.create_task(self._handle_publish())
+            tasks.add(publish_task)
+
+            # Messages that doesn't match a filter will get logged and handled here.
+            messages = await stack.enter_async_context(
+                self.asyncio_client.unfiltered_messages()
+            )
+
+            messages_task = asyncio.create_task(
+                handle_messages(messages, manager.receive_message)
+            )
+            tasks.add(messages_task)
+
+            tasks.update(manager.get_oled_tasks())
+
+            topic = f"{manager.relay_topic}"
+            await self.subscribe(topic)
+
+            # Wait for everything to complete (or fail due to, e.g., network errors).
+            await asyncio.gather(*tasks)
+
+
+async def handle_messages(messages: Any, callback: Callable[[str, str], None]) -> None:
+    """Handle messages with callback."""
+    async for message in messages:
+        payload = message.payload.decode()
+        _LOGGER.debug("Received message topic: %s, payload: %s", message.topic, payload)
+        callback(message.topic, payload)

boneio-0.1.0.dev4/boneio/oled.py

@@ -0,0 +1,120 @@
+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.dev4/boneio/relay/__init__.py

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

boneio-0.1.0.dev4/boneio/relay/basic.py

@@ -0,0 +1,68 @@
+"""Basic Relay module."""
+
+import asyncio
+from typing import Callable, Union
+from ..const import STATE, RELAY, ON, OFF, SWITCH
+import logging
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class BasicRelay:
+    """Basic relay class."""
+
+    def __init__(
+        self,
+        send_message: Callable[[str, Union[str, dict]], None],
+        topic_prefix: str,
+        id: str = None,
+        ha_type=SWITCH,
+    ) -> None:
+        """Initialize Basic relay."""
+        self._id = id
+        self._ha_type = ha_type
+        self._send_message = send_message
+        self._relay_topic = f"{topic_prefix}/{RELAY}/"
+        self._send_topic = f"{self._relay_topic}{self.id}"
+        self._state = False
+        self._loop = asyncio.get_running_loop()
+
+    @property
+    def id(self) -> bool:
+        """Id of the relay."""
+        return self._id or self._pin
+
+    @property
+    def state(self) -> bool:
+        """Is relay active."""
+        return self._state
+
+    def send_state(self) -> None:
+        """Send state to Mqtt on action."""
+        state = ON if self.is_active else OFF
+        self._state = state
+        self._send_message(
+            topic=self._send_topic,
+            payload={STATE: state},
+        )
+
+    def toggle(self) -> None:
+        """Toggle relay."""
+        _LOGGER.debug("Toggle relay.")
+        if self.is_active:
+            self.turn_off()
+        else:
+            self.turn_on()
+
+    @property
+    def is_active(self) -> bool:
+        """Is active check."""
+        raise NotImplementedError
+
+    def turn_on(self) -> None:
+        """Call turn on action."""
+        raise NotImplementedError
+
+    def turn_off(self) -> None:
+        """Call turn off action."""
+        raise NotImplementedError

boneio-0.1.0.dev4/boneio/relay/gpio.py

@@ -0,0 +1,42 @@
+"""GPIO Relay module. 
+!!Not used in BoneIO. 
+Created just in case.
+"""
+
+from ..helper.gpio import setup_output, read_input, write_output, HIGH, LOW
+from .basic import BasicRelay
+import logging
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class GpioRelay(BasicRelay):
+    """Represents GPIO Relay output"""
+
+    def __init__(self, pin: str, **kwargs) -> None:
+        """Initialize Gpio relay."""
+        super().__init(**kwargs)
+        self._pin = pin
+        setup_output(self._pin)
+        write_output(self.pin, LOW)
+        _LOGGER.debug("Setup relay with pin %s", self._pin)
+
+    @property
+    def is_active(self) -> bool:
+        """Is relay active."""
+        return read_input(self.pin, on_state=HIGH)
+
+    @property
+    def pin(self) -> str:
+        """PIN of the relay"""
+        return self._pin
+
+    def turn_on(self) -> None:
+        """Call turn on action."""
+        write_output(self.pin, HIGH)
+        self._loop.call_soon_threadsafe(self.send_state)
+
+    def turn_off(self) -> None:
+        """Call turn off action."""
+        write_output(self.pin, LOW)
+        self._loop.call_soon_threadsafe(self.send_state)

boneio-0.1.0.dev4/boneio/relay/mcp.py

@@ -0,0 +1,45 @@
+"""MCP23017 Relay module."""
+
+from .basic import BasicRelay
+from adafruit_mcp230xx.mcp23017 import MCP23017
+import logging
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class MCPRelay(BasicRelay):
+    """Represents MCP Relay output"""
+
+    def __init__(self, pin: int, mcp: MCP23017, **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._pin.value = False
+        _LOGGER.debug("Setup MCP with pin %s", self._pin_id)
+
+    @property
+    def is_active(self) -> bool:
+        """Is relay active."""
+        return self.pin.value
+
+    @property
+    def pin(self) -> str:
+        """PIN of the relay"""
+        return self._pin
+
+    @property
+    def ha_type(self) -> str:
+        """HA type."""
+        return self._ha_type
+
+    def turn_on(self) -> None:
+        """Call turn on action."""
+        self.pin.value = True
+        self._loop.call_soon_threadsafe(self.send_state)
+
+    def turn_off(self) -> None:
+        """Call turn off action."""
+        self.pin.value = False
+        self._loop.call_soon_threadsafe(self.send_state)

boneio-0.1.0.dev4/boneio/version.py

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

{boneio-0.1.0.dev3 → boneio-0.1.0.dev4}/boneio.egg-info/PKG-INFO

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

boneio-0.1.0.dev4/boneio.egg-info/SOURCES.txt

@@ -0,0 +1,25 @@
+README.md
+setup.py
+boneio/__init__.py
+boneio/bonecli.py
+boneio/const.py
+boneio/manager.py
+boneio/mqtt_client.py
+boneio/oled.py
+boneio/version.py
+boneio.egg-info/PKG-INFO
+boneio.egg-info/SOURCES.txt
+boneio.egg-info/dependency_links.txt
+boneio.egg-info/entry_points.txt
+boneio.egg-info/requires.txt
+boneio.egg-info/top_level.txt
+boneio/helper/__init__.py
+boneio/helper/gpio.py
+boneio/helper/stats.py
+boneio/helper/yaml.py
+boneio/input/__init__.py
+boneio/input/gpio.py
+boneio/relay/__init__.py
+boneio/relay/basic.py
+boneio/relay/gpio.py
+boneio/relay/mcp.py

boneio-0.1.0.dev4/boneio.egg-info/top_level.txt

@@ -0,0 +1 @@
+boneio

boneio-0.1.0.dev3/boneio.egg-info/SOURCES.txt

@@ -1,8 +0,0 @@
-README.md
-setup.py
-boneio.egg-info/PKG-INFO
-boneio.egg-info/SOURCES.txt
-boneio.egg-info/dependency_links.txt
-boneio.egg-info/entry_points.txt
-boneio.egg-info/requires.txt
-boneio.egg-info/top_level.txt

boneio-0.1.0.dev3/boneio.egg-info/top_level.txt

@@ -1 +0,0 @@
-