boneIO 0.1.0.dev3__tar.gz → 0.1.0.dev5__tar.gz

boneio-0.1.0.dev5/MANIFEST.in

@@ -0,0 +1,4 @@
+include README.md
+include requirements.txt
+include LICENSE
+recursive-include boneio *.yaml

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

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: boneio
-Version: 0.1.0.dev3
+Version: 0.1.0.dev5
 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.0.dev5.zip
 Platform: UNKNOWN
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.7
@@ -12,5 +12,13 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Description-Content-Type: text/markdown
 
-Python Helper for BoneIO
+Example usage:
+boneio run -dd -c config.yaml
+
+Install needed:
+
+```
+sudo apt-get install libopenjp2-7-dev libatlas-base-dev
+```
+
 

boneio-0.1.0.dev5/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.dev5/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.dev5/boneio/config.example.yaml

@@ -0,0 +1,38 @@
+mqtt:
+  host: mqtt.hass
+  username: mqtt
+  password: pass
+  topic_prefix: boneiohome
+  ha_discovery:
+    enabled: yes
+
+i2c:
+  id: myb
+  sda: P9_18
+  scl: P9_17
+
+oled:
+
+mcp23017:
+  - id: mcp1
+    address: 0x20
+
+gpio_input:
+  - id: "one"
+    pin: P8_12
+  - id: "two"
+    pin: P8_7
+    actions:
+      single:
+        action: output
+        pin: myoutput
+
+output: !include output.yaml
+
+
+##OUTPUT.YAML
+- id: myoutput
+  kind: mcp
+  mcp_id: mcp1
+  pin: 0
+  ha_type: light

boneio-0.1.0.dev5/boneio/config.yaml

@@ -0,0 +1,20 @@
+mqtt:
+  host: mqtt.hass
+  username: mqtt
+  password: pass
+  # ha_discovery:
+  #   enabled: True
+
+# i2c:
+#   - id: myb
+#     sda: "P9_18"
+#     scl: "P9_17"
+
+gpio_input:
+  - id: "one"
+    pin: "P8_3"
+
+output:
+  - id: myinput
+    kind: gpio
+    pin: P9_17

boneio-0.1.0.dev5/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.dev5/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.dev5/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.dev5/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.dev5/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.dev5/boneio/input/__init__.py

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

boneio-0.1.0.dev5/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