boneIO 0.1.0__py3-none-any.whl

boneio/mqtt_client.py

@@ -0,0 +1,170 @@
+"""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
+
+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 boneio.const import PAHO
+from boneio.helper import UniqueQueue
+
+_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: UniqueQueue = UniqueQueue()
+
+    def create_client(self) -> None:
+        """Create the asyncio client."""
+        self.asyncio_client = AsyncioClient(
+            self.host,
+            self.port,
+            **self.client_options,
+        )
+
+    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 + host stats."""
+        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)
+
+            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/oled.py

@@ -0,0 +1,118 @@
+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 luma.core.error import DeviceNotFoundError
+from PIL import ImageDraw
+
+from boneio.const import CPU, DISK, MEMORY, NETWORK, OLED_PIN, SWAP, UPTIME, WHITE
+from boneio.helper import (
+    HostData,
+    configure_pin,
+    edge_detect,
+    make_font,
+    setup_input,
+    I2CError,
+)
+
+_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, 50, 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(pin=OLED_PIN, callback=self._handle_press, bounce=80)
+        try:
+            serial = i2c(port=2, address=0x3C)
+            self._device = sh1106(serial)
+        except DeviceNotFoundError as err:
+            raise I2CError(err)
+        _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/relay/__init__.py

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

boneio/relay/basic.py

@@ -0,0 +1,76 @@
+"""Basic Relay module."""
+
+import asyncio
+import logging
+from typing import Callable
+
+from boneio.const import OFF, ON, RELAY, STATE, SWITCH
+from boneio.helper import BasicMqtt
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class BasicRelay(BasicMqtt):
+    """Basic relay class."""
+
+    def __init__(
+        self, callback: Callable, id: str = None, ha_type=SWITCH, **kwargs
+    ) -> None:
+        """Initialize Basic relay."""
+        super().__init__(id=id, name=id, topic_type=RELAY, **kwargs)
+        self._ha_type = ha_type
+        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.
+        Has to be trimmed out of spaces because of MQTT handling in HA."""
+        return self._id or self._pin
+
+    @property
+    def name(self) -> bool:
+        """Not trimmed id."""
+        return self._name 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},
+        )
+        self._loop.call_soon_threadsafe(self._callback)
+
+    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/relay/gpio.py

@@ -0,0 +1,44 @@
+"""GPIO Relay module. 
+!!Not used in BoneIO. 
+Created just in case.
+"""
+
+import logging
+
+from boneio.helper import read_input, setup_output, write_output
+from boneio.relay.basic import BasicRelay
+from boneio.const import HIGH, LOW
+
+_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/relay/mcp.py

@@ -0,0 +1,56 @@
+"""MCP23017 Relay module."""
+
+import logging
+from adafruit_mcp230xx.mcp23017 import MCP23017
+from boneio.relay.basic import BasicRelay
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class MCPRelay(BasicRelay):
+    """Represents MCP Relay output"""
+
+    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."""
+        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)