boneIO 0.6.0__tar.gz → 0.6.0dev1__tar.gz

{boneIO-0.6.0 → boneIO-0.6.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: boneIO
-Version: 0.6.0
+Version: 0.6.0dev1
 Summary: Python App for BoneIO
 License: GNU General Public License v3.0
 Author-email: Paweł Szafer <pszafer@gmail.com>

{boneIO-0.6.0 → boneIO-0.6.0.dev1}/boneio/bonecli.py

@@ -1,11 +1,9 @@
 """Bonecli script."""
-from __future__ import annotations
 import argparse
 import asyncio
 import logging
 import sys
 import os
-from typing import Any
 
 os.environ["W1THERMSENSOR_NO_KERNEL_MODULE"] = "1"
 
@@ -14,7 +12,7 @@ from yaml import MarkedYAMLError
 
 from boneio.const import ACTION
 from boneio.helper import load_config_from_file
-from boneio.helper.exceptions import ConfigurationException, RestartRequestException
+from boneio.helper.exceptions import ConfigurationException
 from boneio.helper.logger import configure_logger
 from boneio.runner import async_run
 from boneio.version import __version__
@@ -71,7 +69,7 @@ def get_arguments() -> argparse.Namespace:
     return arguments
 
 
-def run(config: str, debug: int, mqttusername: str = "", mqttpassword: str = "") -> int:
+def run(config: str, debug: int, mqttusername: str = "", mqttpassword: str = ""):
     """Run BoneIO."""
     _LOGGER.info("BoneIO %s starting.", __version__)
     try:
@@ -80,7 +78,7 @@ def run(config: str, debug: int, mqttusername: str = "", mqttpassword: str = "")
             _LOGGER.error("Config not loaded. Exiting.")
             return 1
         configure_logger(log_config=_config.get("logger"), debug=debug)
-        asyncio.run(
+        return asyncio.run(
             async_run(
                 config=_config,
                 config_file=config,
@@ -88,10 +86,6 @@ def run(config: str, debug: int, mqttusername: str = "", mqttpassword: str = "")
                 mqttpassword=mqttpassword,
             ),
         )
-        return 0
-    except RestartRequestException as err:
-        _LOGGER.info(err)
-        return 0
     except (ConfigurationException, MarkedYAMLError) as err:
         _LOGGER.error("Failed to load config. %s Exiting.", err)
         return 1

{boneIO-0.6.0 → boneIO-0.6.0.dev1}/boneio/const.py

@@ -18,7 +18,6 @@ RELAY = "relay"
 LED = "led"
 ON = "ON"
 OFF = "OFF"
-TOGGLE = "TOGGLE"
 STATE = "state"
 BRIGHTNESS = "brightness"
 SET_BRIGHTNESS = "set_brightness"
@@ -56,7 +55,7 @@ UARTS = {
     "uart5": {ID: "/dev/ttyS5", TX: "P8.37", RX: "P8.38"},
 }
 
-relay_actions = {ON: "turn_on", OFF: "turn_off", TOGGLE: "toggle"}
+relay_actions = {ON: "turn_on", OFF: "turn_off", "TOGGLE": "toggle"}
 
 # HA CONSTS
 HOMEASSISTANT = "homeassistant"

{boneIO-0.6.0 → boneIO-0.6.0.dev1}/boneio/helper/__init__.py

@@ -1,7 +1,6 @@
 """Helper dir for BoneIO."""
 
 from boneio.helper.exceptions import GPIOInputException, GPIOOutputException, I2CError
-from boneio.helper.click_timer import ClickTimer
 from boneio.helper.gpio import (
     GpioBaseClass,
     configure_pin,
@@ -71,5 +70,4 @@ __all__ = [
     "TimePeriod",
     "callback",
     "is_callback",
-    "ClickTimer",
 ]

boneIO-0.6.0.dev1/boneio/helper/config.py

@@ -0,0 +1,48 @@
+"""
+Module to provide basic config options.
+"""
+from _collections_abc import dict_values
+
+from boneio.const import BONEIO, HOMEASSISTANT
+
+
+class ConfigHelper:
+    def __init__(
+        self,
+        topic_prefix: str = BONEIO,
+        ha_discovery: bool = True,
+        ha_discovery_prefix: str = HOMEASSISTANT,
+    ):
+        self._topic_prefix = topic_prefix
+        self._ha_discovery = ha_discovery
+        self._ha_discovery_prefix = ha_discovery_prefix
+        self._autodiscovery_messages = {}
+
+    @property
+    def topic_prefix(self) -> str:
+        return self._topic_prefix
+
+    @property
+    def ha_discovery(self) -> bool:
+        return self._ha_discovery
+
+    @property
+    def ha_discovery_prefix(self) -> str:
+        return self._ha_discovery_prefix
+
+    @property
+    def cmd_topic_prefix(self) -> str:
+        return f"{self.topic_prefix}/cmd/"
+
+    @property
+    def subscribe_topic(self) -> str:
+        return f"{self.cmd_topic_prefix}+/+/#"
+
+    def add_autodiscovery_msg(self, topic: str, payload: str):
+        """Add autodiscovery message."""
+        self._autodiscovery_messages[topic] = {"topic": topic, "payload": payload}
+
+    @property
+    def autodiscovery_msgs(self) -> dict_values:
+        """Get autodiscovery messages"""
+        return self._autodiscovery_messages.values()

{boneIO-0.6.0 → boneIO-0.6.0.dev1}/boneio/helper/events.py

@@ -21,9 +21,7 @@ def utcnow() -> dt.datetime:
 time_tracker_utcnow = utcnow
 
 
-def _async_create_timer(
-    loop: asyncio.AbstractEventLoop, event_callback
-) -> CALLBACK_TYPE:
+def _async_create_timer(loop: asyncio.AbstractEventLoop, event_callback) -> None:
     """Create a timer that will start on BoneIO start."""
     handle = None
 
@@ -151,50 +149,7 @@ def async_track_point_in_time(
     """Add a listener that fires once after a specific point in UTC time."""
     # Ensure point_in_time is UTC
     utc_point_in_time = as_utc(point_in_time)
-    expected_fire_timestamp = utc_point_in_time.timestamp()
-
-    # Since this is called once, we accept a so we can avoid
-    # having to figure out how to call the action every time its called.
-    cancel_callback: Optional[asyncio.TimerHandle] = None
-
-    @callback
-    def run_action(job) -> None:
-        """Call the action."""
-        nonlocal cancel_callback
-
-        # Depending on the available clock support (including timer hardware
-        # and the OS kernel) it can happen that we fire a little bit too early
-        # as measured by utcnow(). That is bad when callbacks have assumptions
-        # about the current time. Thus, we rearm the timer for the remaining
-        # time.
-        delta = expected_fire_timestamp - time.time()
-        if delta > 0:
-            _LOGGER.debug("Called %f seconds too early, rearming", delta)
-
-            cancel_callback = loop.call_later(delta, run_action, job)
-            return
-
-        loop.call_soon(job, utc_point_in_time)
-
-    delta = expected_fire_timestamp - time.time()
-    cancel_callback = loop.call_later(delta, run_action, action)
-
-    @callback
-    def unsub_point_in_time_listener() -> None:
-        """Cancel the call_later."""
-        assert cancel_callback is not None
-        cancel_callback.cancel()
-
-    return unsub_point_in_time_listener
 
-
-@callback
-def async_track_point_in_timestamp(
-    loop: asyncio.AbstractEventLoop,
-    action,
-    timestamp: float,
-) -> CALLBACK_TYPE:
-    """Add a listener that fires once after a specific point in UTC time."""
     # Since this is called once, we accept a so we can avoid
     # having to figure out how to call the action every time its called.
     cancel_callback: Optional[asyncio.TimerHandle] = None
@@ -204,24 +159,23 @@ def async_track_point_in_timestamp(
         """Call the action."""
         nonlocal cancel_callback
 
-        now = time.time()
+        now = time_tracker_utcnow()
 
         # Depending on the available clock support (including timer hardware
         # and the OS kernel) it can happen that we fire a little bit too early
         # as measured by utcnow(). That is bad when callbacks have assumptions
         # about the current time. Thus, we rearm the timer for the remaining
         # time.
-        delta = timestamp - now
+        delta = (utc_point_in_time - now).total_seconds()
         if delta > 0:
             _LOGGER.debug("Called %f seconds too early, rearming", delta)
 
             cancel_callback = loop.call_later(delta, run_action, job)
             return
 
-        loop.call_soon(job, timestamp)
+        loop.call_soon(job, utc_point_in_time)
 
-    now = time.time()
-    delta = timestamp - now
+    delta = utc_point_in_time.timestamp() - time.time()
     cancel_callback = loop.call_later(delta, run_action, action)
 
     @callback
@@ -231,17 +185,3 @@ def async_track_point_in_timestamp(
         cancel_callback.cancel()
 
     return unsub_point_in_time_listener
-
-
-@callback
-def async_call_later_miliseconds(
-    loop: asyncio.AbstractEventLoop,
-    action,
-    delay: float,
-) -> CALLBACK_TYPE:
-    """Add a listener that fires once after a specific point in UTC time."""
-    # Ensure point_in_time is UTC
-    expected_fire_timestamp = time.time() + (delay / 1000)
-    return async_track_point_in_timestamp(
-        loop=loop, action=action, timestamp=expected_fire_timestamp
-    )

{boneIO-0.6.0 → boneIO-0.6.0.dev1}/boneio/helper/exceptions.py

@@ -8,7 +8,6 @@ class BoneIOException(Exception):
 class GPIOInputException(BoneIOException):
     """GPIOInput Exception."""
 
-
 class GPIOOutputException(BoneIOException):
     """GPIOInput Exception."""
 
@@ -31,7 +30,3 @@ class CoverRelayException(BoneIOException):
 
 class ModbusUartException(BoneIOException):
     """Cover configuration exception."""
-
-
-class RestartRequestException(BoneIOException):
-    """Restart exception."""

{boneIO-0.6.0 → boneIO-0.6.0.dev1}/boneio/helper/gpio.py

@@ -67,7 +67,7 @@ def write_output(pin: str, value: str) -> None:
     GPIO.output(pin, value)
 
 
-def read_input(pin: str, on_state: Gpio_States = LOW) -> bool:
+def read_input(pin: str, on_state: Gpio_States = LOW) -> None:
     """Read a value from a GPIO."""
     return GPIO.input(pin) is on_state
 
@@ -97,6 +97,6 @@ class GpioBaseClass:
         setup_input(pin=self._pin, pull_mode=gpio_mode)
 
     @property
-    def is_pressed(self) -> bool:
+    def is_pressed(self):
         """Is button pressed."""
         return read_input(self._pin)

{boneIO-0.6.0 → boneIO-0.6.0.dev1}/boneio/helper/ha_discovery.py

@@ -51,7 +51,6 @@ def ha_light_availabilty_message(id: str, topic: str = "boneIO", **kwargs):
     msg["state_value_template"] = "{{ value_json.state }}"
     return msg
 
-
 def ha_led_availabilty_message(id: str, topic: str = "boneIO", **kwargs):
     """Create LED availability topic for HA."""
     msg = ha_availabilty_message(device_type=RELAY, topic=topic, id=id, **kwargs)
@@ -65,14 +64,11 @@ def ha_led_availabilty_message(id: str, topic: str = "boneIO", **kwargs):
     msg["brightness_value_template"] = "{{ value_json.brightness }}"
     return msg
 
-
-def ha_button_availabilty_message(
-    id: str, topic: str = "boneIO", payload_press: str = "reload", **kwargs
-):
+def ha_button_availabilty_message(id: str, topic: str = "boneIO", **kwargs):
     """Create BUTTON availability topic for HA."""
     msg = ha_availabilty_message(device_type="button", topic=topic, id=id, **kwargs)
     msg["command_topic"] = f"{topic}/cmd/button/{id}/set"
-    msg["payload_press"] = payload_press
+    msg["payload_press"] = "reload"
     return msg
 
 
@@ -106,11 +102,9 @@ def ha_sensor_availabilty_message(unit_of_measurement: str = None, **kwargs):
         return msg
 
 
-def ha_binary_sensor_availabilty_message(id: str, name: str, device_class: str, topic: str = "boneIO"):
+def ha_binary_sensor_availabilty_message(id: str, name: str, topic: str = "boneIO"):
     """Create availability topic for HA."""
-    kwargs = {"device_class": device_class} if device_class else {}
     return {
-        **kwargs,
         "availability": [{"topic": f"{topic}/{STATE}"}],
         "device": {
             "identifiers": [topic],

{boneIO-0.6.0 → boneIO-0.6.0.dev1}/boneio/helper/loader.py

@@ -354,7 +354,6 @@ def configure_input(
                 id=pin,
                 name=gpio.get(ID, pin),
                 ha_type=getattr(input, "ha_type"),
-                device_class=gpio.get(DEVICE_CLASS, None),
                 availability_msg_func=getattr(input, "availability_msg_f"),
             )
         return pin

{boneIO-0.6.0 → boneIO-0.6.0.dev1}/boneio/helper/mqtt.py

@@ -21,11 +21,11 @@ class BasicMqtt:
         self._send_topic = f"{topic_prefix}/{topic_type}/{self.id}"
 
     @property
-    def id(self) -> str:
+    def id(self) -> bool:
         """Id of the module."""
         return self._id
 
     @property
-    def name(self) -> str:
+    def name(self):
         """Return name of the sensor."""
         return self._name

{boneIO-0.6.0 → boneIO-0.6.0.dev1}/boneio/helper/yaml_util.py

@@ -8,7 +8,7 @@ from typing import Any, Tuple
 from cerberus import TypeDefinition, Validator
 from yaml import MarkedYAMLError, SafeLoader, YAMLError, load
 
-from boneio.const import COVER, ID, OUTPUT, TOGGLE
+from boneio.const import COVER, ID, OUTPUT
 from boneio.helper.exceptions import ConfigurationException
 from boneio.helper.timeperiod import TimePeriod
 
@@ -103,7 +103,9 @@ BoneIOLoader.add_constructor(
 BoneIOLoader.add_constructor(
     "!include_dir_merge_named", BoneIOLoader.construct_include_dir_merge_named
 )
-BoneIOLoader.add_constructor("!include_files", BoneIOLoader.construct_include_files)
+BoneIOLoader.add_constructor(
+    "!include_files", BoneIOLoader.construct_include_files
+)
 
 
 def filter_yaml_files(files):
@@ -244,7 +246,7 @@ class CustomValidator(Validator):
         return str(value).upper()
 
     def _normalize_coerce_actions_output(self, value):
-        return str(value).upper()
+        return str(value).lower()
 
     def _normalize_coerce_str(self, value):
         return str(value)
@@ -322,4 +324,4 @@ class CustomValidator(Validator):
 
         parent = get_parent()
         if parent["action"] == COVER:
-            return TOGGLE
+            return "toggle"

boneIO-0.6.0.dev1/boneio/input/gpio.py

@@ -0,0 +1,123 @@
+"""GPIOInputButton to receive signals."""
+import logging
+from datetime import datetime, timedelta
+from functools import partial
+
+from boneio.const import DOUBLE, LONG, SINGLE
+from boneio.helper import GpioBaseClass, edge_detect
+
+# TIMINGS FOR BUTTONS
+DEBOUNCE_DURATION = timedelta(microseconds=150000)
+LONG_PRESS_DURATION = timedelta(microseconds=700000)
+DELAY_DURATION = 0.08
+SECOND_DELAY_DURATION = 0.14
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class GpioInputButton(GpioBaseClass):
+    """Represent Gpio input switch."""
+
+    def __init__(self, **kwargs) -> None:
+        """Setup GPIO Input Button"""
+        super().__init__(**kwargs)
+        edge_detect(
+            self._pin,
+            callback=self._handle_press,
+            bounce=self._bounce_time.total_milliseconds,
+        )
+        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: str) -> 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,
+        )
+
+    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 on pin %s, call callback", self._pin)
+                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 on pin %s, diff %s",
+                        self._pin,
+                        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 on pin %s, call callback", self._pin)
+                    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