boneIO 0.2.2__tar.gz → 0.3.0.dev1__tar.gz

{boneio-0.2.2/boneio.egg-info → boneio-0.3.0.dev1}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: boneio
-Version: 0.2.2
+Version: 0.3.0.dev1
 Summary: Python App for BoneIO
 Home-page: https://github.com/boneIO-eu/app_bbb
-Download-URL: https://github.com/boneIO-eu/app_bbb/archive/0.2.2.zip
+Download-URL: https://github.com/boneIO-eu/app_bbb/archive/0.3.0.dev1.zip
 License: GNU General Public License v3.0
 Platform: UNKNOWN
 Classifier: Programming Language :: Python

{boneio-0.2.2 → boneio-0.3.0.dev1}/boneio/bonecli.py

@@ -8,9 +8,11 @@ from colorlog import ColoredFormatter
 
 from boneio.const import ACTION
 from boneio.helper import load_config_from_file
+from boneio.helper.exceptions import ConfigurationException
 from boneio.helper.logger import configure_logger
 from boneio.runner import async_run
 from boneio.version import __version__
+from yaml import MarkedYAMLError
 
 TASK_CANCELATION_TIMEOUT = 1
 
@@ -67,18 +69,23 @@ def get_arguments() -> argparse.Namespace:
 def run(config: str, debug: int, mqttusername: str = "", mqttpassword: str = ""):
     """Run BoneIO."""
     _LOGGER.info("BoneIO starting.")
-    _config = load_config_from_file(config_file=config)
-    if not _config:
-        return
-    configure_logger(log_config=_config.get("logger"), debug=debug)
-    return asyncio.run(
-        async_run(
-            config=_config,
-            config_file=config,
-            mqttusername=mqttusername,
-            mqttpassword=mqttpassword,
-        ),
-    )
+    try:
+        _config = load_config_from_file(config_file=config)
+        if not _config:
+            _LOGGER.error("Config not loaded. Exiting.")
+            return 1
+        configure_logger(log_config=_config.get("logger"), debug=debug)
+        return asyncio.run(
+            async_run(
+                config=_config,
+                config_file=config,
+                mqttusername=mqttusername,
+                mqttpassword=mqttpassword,
+            ),
+        )
+    except (ConfigurationException, MarkedYAMLError) as err:
+        _LOGGER.error("Failed to load config. %s Exiting.", err)
+        return 1
 
 
 def main() -> int:

{boneio-0.2.2 → boneio-0.3.0.dev1}/boneio/const.py

@@ -4,6 +4,10 @@ from datetime import timedelta
 try:
     from Adafruit_BBIO.GPIO import HIGH, LOW, BOTH, FALLING
 except ModuleNotFoundError:
+    HIGH = "high"
+    LOW = "low"
+    BOTH = "both"
+    FALLING = "falling"
     pass
 from typing_extensions import Literal
 

{boneio-0.2.2 → boneio-0.3.0.dev1}/boneio/helper/__init__.py

@@ -1,4 +1,6 @@
 """Helper dir for BoneIO."""
+from typing import Callable, TypeVar, Any
+
 from boneio.helper.gpio import (
     edge_detect,
     setup_input,
@@ -11,7 +13,7 @@ from boneio.helper.gpio import (
 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 (
+from boneio.helper.yaml_util import (
     CustomValidator,
     load_yaml_file,
     schema_file,
@@ -31,6 +33,21 @@ from boneio.helper.ha_discovery import (
 )
 from boneio.helper.exceptions import GPIOInputException, I2CError
 from boneio.helper.queue import UniqueQueue
+from boneio.helper.timeperiod import TimePeriod
+
+CALLABLE_T = TypeVar("CALLABLE_T", bound=Callable[..., Any])
+CALLBACK_TYPE = Callable[[], None]
+
+
+def callback(func: CALLABLE_T) -> CALLABLE_T:
+    """Annotation to mark method as safe to call from within the event loop."""
+    setattr(func, "_boneio_callback", True)
+    return func
+
+
+def is_callback(func: Callable[..., Any]) -> bool:
+    """Check if function is safe to be called in the event loop."""
+    return getattr(func, "_boneio_callback", False) is True
 
 
 __all__ = [
@@ -62,4 +79,5 @@ __all__ = [
     "schema_file",
     "load_config_from_string",
     "load_config_from_file",
+    "TimePeriod",
 ]

{boneio-0.2.2 → boneio-0.3.0.dev1}/boneio/helper/events.py

@@ -2,16 +2,24 @@ import asyncio
 import datetime as dt
 import signal
 import logging
+import time
+from typing import Callable
+from datetime import datetime
+from boneio.helper import callback
 
 _LOGGER = logging.getLogger(__name__)
 UTC = dt.timezone.utc
 EVENT_TIME_CHANGED = "event_time_changed"
+CALLBACK_TYPE = Callable[[], None]
 
 
-def utcnow():
+def utcnow() -> dt.datetime:
     return dt.datetime.now(UTC)
 
 
+time_tracker_utcnow = utcnow
+
+
 def _async_create_timer(loop: asyncio.AbstractEventLoop, event_callback) -> None:
     """Create a timer that will start on BoneIO start."""
     handle = None
@@ -19,7 +27,7 @@ def _async_create_timer(loop: asyncio.AbstractEventLoop, event_callback) -> None
     def schedule_tick(now: dt.datetime) -> None:
         """Schedule a timer tick when the next second rolls around."""
         nonlocal handle
-        slp_seconds = 1 - (now.microsecond / 10 ** 6)
+        slp_seconds = 1 - (now.microsecond / 10**6)
         handle = loop.call_later(slp_seconds, fire_time_event)
 
     def fire_time_event() -> None:
@@ -109,3 +117,60 @@ class EventBus:
         """Remove regular listener."""
         if name in self._listeners:
             del self._listeners[name]
+
+
+def as_utc(dattim: dt.datetime) -> dt.datetime:
+    """Return a datetime as UTC time.
+
+    Assumes datetime without tzinfo to be in the DEFAULT_TIME_ZONE.
+    """
+    if dattim.tzinfo == UTC:
+        return dattim
+    return dattim.astimezone(UTC)
+
+
+@callback
+def async_track_point_in_time(
+    loop: asyncio.AbstractEventLoop,
+    action,
+    point_in_time: datetime,
+) -> CALLBACK_TYPE:
+    """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)
+
+    # Since this is called once, we accept a HassJob so we can avoid
+    # having to figure out how to call the action every time its called.
+    cancel_callback: asyncio.TimerHandle | None = None
+
+    @callback
+    def run_action(job) -> None:
+        """Call the action."""
+        nonlocal cancel_callback
+
+        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 = (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, utc_point_in_time)
+
+    delta = utc_point_in_time.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

{boneio-0.2.2 → boneio-0.3.0.dev1}/boneio/helper/exceptions.py

@@ -11,3 +11,7 @@ class GPIOInputException(BoneIOException):
 
 class I2CError(BoneIOException):
     """I2C Exception."""
+
+
+class ConfigurationException(BoneIOException):
+    """Configuration yaml exception."""

{boneio-0.2.2 → boneio-0.3.0.dev1}/boneio/helper/gpio.py

@@ -1,9 +1,24 @@
 import asyncio
 import logging
-from Adafruit_BBIO import GPIO
+
+try:
+    from Adafruit_BBIO import GPIO
+except ModuleNotFoundError:
+
+    class GPIO:
+        PUD_OFF = "poff"
+        PUD_UP = "poff"
+        PUD_DOWN = "poff"
+
+        def __init__(self):
+            pass
+
+    pass
 
 from boneio.helper.exceptions import GPIOInputException
 from boneio.const import LOW, FALLING, Gpio_Edges, Gpio_States
+from boneio.helper.timeperiod import TimePeriod
+
 from typing import Callable
 import subprocess
 
@@ -34,10 +49,19 @@ def setup_output(pin: str) -> None:
     GPIO.setup(pin, GPIO.OUT, pull_up_down=GPIO.PUD_DOWN)
 
 
-def setup_input(pin: str, pull_mode: str = "UP") -> None:
+gpio_modes = {
+    "gpio": GPIO.PUD_OFF,
+    "gpio_pu": GPIO.PUD_UP,
+    "gpio_pd": GPIO.PUD_DOWN,
+    "gpio_input": GPIO.PUD_OFF,
+}
+
+
+def setup_input(pin: str, pull_mode: str = "gpio") -> None:
     """Set up a GPIO as input."""
+    gpio_mode = gpio_modes.get(pull_mode, GPIO.PUD_OFF)
     try:
-        GPIO.setup(pin, GPIO.IN, GPIO.PUD_DOWN if pull_mode == "DOWN" else GPIO.PUD_UP)
+        GPIO.setup(pin, GPIO.IN, gpio_mode)
     except (ValueError, SystemError) as err:
         raise GPIOInputException(err)
 
@@ -72,11 +96,12 @@ class GpioBaseClass:
         """Setup GPIO Input Button"""
         self._pin = pin
         gpio = kwargs.get("rest_pin", {GPIO_MODE: GPIO_STR})
-        self._bounce_time = gpio.get("bounce_time", 25)
-        configure_pin(pin=pin, mode=gpio.get(GPIO_MODE, GPIO_STR))
+        gpio_mode = gpio.get(GPIO_MODE, GPIO_STR)
+        self._bounce_time = gpio.get("bounce_time", TimePeriod(milliseconds=25))
+        configure_pin(pin=pin, mode=gpio_mode)
         self._loop = asyncio.get_running_loop()
         self._press_callback = press_callback
-        setup_input(pin=self._pin)
+        setup_input(pin=self._pin, pull_mode=gpio_mode)
 
     @property
     def is_pressed(self):

{boneio-0.2.2 → boneio-0.3.0.dev1}/boneio/helper/loader.py

@@ -192,6 +192,17 @@ def create_modbus_sensors(
             pass
 
 
+OutputEntry = namedtuple("OutputEntry", "OutputClass output_kind output_id")
+
+
+def output_chooser(output_kind: str, mcp_id: str | None):
+    """Get named tuple based on input."""
+    if output_kind == MCP:
+        return OutputEntry(MCPRelay, MCP, mcp_id)
+    else:
+        return OutputEntry(GpioRelay, GPIO, GPIO)
+
+
 def configure_relay(
     manager: Manager,
     state_manager: StateManager,
@@ -201,61 +212,55 @@ def configure_relay(
     config: dict,
 ) -> Any:
     """Configure kind of relay. Most common MCP."""
+    restore_state = config.pop(RESTORE_STATE, False)
+    output_type = config.pop(OUTPUT_TYPE)
     restored_state = (
         state_manager.get(attr_type=RELAY, attr=relay_id, default_value=False)
-        if config[RESTORE_STATE]
+        if restore_state
         else False
     )
-    if config[OUTPUT_TYPE] == NONE and state_manager.get(
-        attr_type=RELAY, attr=relay_id
-    ):
+    if output_type == NONE and state_manager.get(attr_type=RELAY, attr=relay_id):
         state_manager.del_attribute(attr_type=RELAY, attribute=relay_id)
         restored_state = False
 
-    if config[KIND] == MCP:
-        mcp_id = config.get(MCP_ID, "")
-        mcp = manager.mcp.get(mcp_id)
+    output = output_chooser(
+        output_kind=config.pop(KIND), mcp_id=config.pop(MCP_ID, None)
+    )
+
+    if getattr(output, "output_kind") == MCP:
+        mcp = manager.mcp.get(getattr(output, "output_id"))
         if not mcp:
             _LOGGER.error("No such MCP configured!")
-            return
-        mcp_relay = MCPRelay(
-            pin=int(config[PIN]),
-            id=config[ID],
-            send_message=manager.send_message,
-            topic_prefix=topic_prefix,
-            mcp=mcp,
-            mcp_id=mcp_id,
-            output_type=config[OUTPUT_TYPE].lower(),
-            restored_state=restored_state,
-            callback=lambda: relay_callback(
-                relay_type=mcp_id,
-                relay_id=relay_id,
-                restore_state=False
-                if config[OUTPUT_TYPE] == NONE
-                else config[RESTORE_STATE],
-            ),
-        )
-        manager.grouped_outputs[mcp_id][relay_id] = mcp_relay
-        return mcp_relay
-    elif config[KIND] == GPIO:
+            return None
+        kwargs = {
+            "pin": int(config.pop(PIN)),
+            "mcp": mcp,
+            "mcp_id": getattr(output, "output_id"),
+            "output_type": output_type,
+        }
+    elif getattr(output, "output_kind") == GPIO:
         if GPIO not in manager.grouped_outputs:
             manager.grouped_outputs[GPIO] = {}
-        gpio_relay = GpioRelay(
-            pin=config[PIN],
-            id=config[ID],
-            send_message=manager.send_message,
-            topic_prefix=topic_prefix,
-            restored_state=restored_state,
-            callback=lambda: relay_callback(
-                relay_type=GPIO,
-                relay_id=relay_id,
-                restore_state=False
-                if config[OUTPUT_TYPE] == NONE
-                else config[RESTORE_STATE],
-            ),
-        )
-        manager.grouped_outputs[GPIO][relay_id] = gpio_relay
-        return gpio_relay
+        kwargs = {
+            "pin": config.pop(PIN),
+        }
+    else:
+        return
+    relay = getattr(output, "OutputClass")(
+        send_message=manager.send_message,
+        topic_prefix=topic_prefix,
+        id=config.pop(ID),
+        restored_state=restored_state,
+        **config,
+        **kwargs,
+        callback=lambda: relay_callback(
+            relay_type=getattr(output, "output_id"),
+            relay_id=relay_id,
+            restore_state=False if output_type == NONE else restore_state,
+        ),
+    )
+    manager.grouped_outputs[getattr(output, "output_id")][relay_id] = relay
+    return relay
 
 
 InputEntry = namedtuple(

boneio-0.3.0.dev1/boneio/helper/timeperiod.py

@@ -0,0 +1,185 @@
+from collections import OrderedDict
+
+from datetime import timedelta
+import math
+
+
+def is_approximately_integer(value):
+    if isinstance(value, int):
+        return True
+    return abs(value - round(value)) < 0.001
+
+
+class TimePeriod:
+    def __init__(
+        self,
+        microseconds=None,
+        milliseconds=None,
+        seconds=None,
+        minutes=None,
+        hours=None,
+        days=None,
+    ) -> None:
+        if days is not None:
+            if not is_approximately_integer(days):
+                frac_days, days = math.modf(days)
+                hours = (hours or 0) + frac_days * 24
+            self.days = int(round(days))
+        else:
+            self.days = None
+
+        if hours is not None:
+            if not is_approximately_integer(hours):
+                frac_hours, hours = math.modf(hours)
+                minutes = (minutes or 0) + frac_hours * 60
+            self.hours = int(round(hours))
+        else:
+            self.hours = None
+
+        if minutes is not None:
+            if not is_approximately_integer(minutes):
+                frac_minutes, minutes = math.modf(minutes)
+                seconds = (seconds or 0) + frac_minutes * 60
+            self.minutes = int(round(minutes))
+        else:
+            self.minutes = None
+
+        if seconds is not None:
+            if not is_approximately_integer(seconds):
+                frac_seconds, seconds = math.modf(seconds)
+                milliseconds = (milliseconds or 0) + frac_seconds * 1000
+            self.seconds = int(round(seconds))
+        else:
+            self.seconds = None
+
+        if milliseconds is not None:
+            if not is_approximately_integer(milliseconds):
+                frac_milliseconds, milliseconds = math.modf(milliseconds)
+                microseconds = (microseconds or 0) + frac_milliseconds * 1000
+            self.milliseconds = int(round(milliseconds))
+        else:
+            self.milliseconds = None
+
+        if microseconds is not None:
+            if not is_approximately_integer(microseconds):
+                raise ValueError("Maximum precision is microseconds")
+            self.microseconds = int(round(microseconds))
+        else:
+            self.microseconds = None
+
+        self._timedelta = timedelta(
+            days=self.days or 0,
+            hours=self.hours or 0,
+            minutes=self.minutes or 0,
+            seconds=self.seconds or 0,
+            milliseconds=self.milliseconds or 0,
+            microseconds=self.microseconds or 0,
+        )
+
+    @property
+    def as_timedelta(self) -> timedelta:
+        return self._timedelta
+
+    def as_dict(self) -> OrderedDict:
+        out = OrderedDict()
+        if self.microseconds is not None:
+            out["microseconds"] = self.microseconds
+        if self.milliseconds is not None:
+            out["milliseconds"] = self.milliseconds
+        if self.seconds is not None:
+            out["seconds"] = self.seconds
+        if self.minutes is not None:
+            out["minutes"] = self.minutes
+        if self.hours is not None:
+            out["hours"] = self.hours
+        if self.days is not None:
+            out["days"] = self.days
+        return out
+
+    def __str__(self) -> str:
+        if self.microseconds is not None:
+            return f"{self.total_microseconds}us"
+        if self.milliseconds is not None:
+            return f"{self.total_milliseconds}ms"
+        if self.seconds is not None:
+            return f"{self.total_seconds}s"
+        if self.minutes is not None:
+            return f"{self.total_minutes}min"
+        if self.hours is not None:
+            return f"{self.total_hours}h"
+        if self.days is not None:
+            return f"{self.total_days}d"
+        return "0s"
+
+    def __repr__(self):
+        return f"TimePeriod<{self.total_microseconds}>"
+
+    @property
+    def total_microseconds(self):
+        return self.total_milliseconds * 1000 + (self.microseconds or 0)
+
+    @property
+    def total_milliseconds(self):
+        return self.total_seconds * 1000 + (self.milliseconds or 0)
+
+    @property
+    def total_seconds(self):
+        return self.total_minutes * 60 + (self.seconds or 0)
+
+    @property
+    def total_minutes(self):
+        return self.total_hours * 60 + (self.minutes or 0)
+
+    @property
+    def total_hours(self):
+        return self.total_days * 24 + (self.hours or 0)
+
+    @property
+    def total_days(self):
+        return self.days or 0
+
+    def __eq__(self, other):
+        if isinstance(other, TimePeriod):
+            return self.total_microseconds == other.total_microseconds
+        return NotImplemented
+
+    def __ne__(self, other):
+        if isinstance(other, TimePeriod):
+            return self.total_microseconds != other.total_microseconds
+        return NotImplemented
+
+    def __lt__(self, other):
+        if isinstance(other, TimePeriod):
+            return self.total_microseconds < other.total_microseconds
+        return NotImplemented
+
+    def __gt__(self, other):
+        if isinstance(other, TimePeriod):
+            return self.total_microseconds > other.total_microseconds
+        return NotImplemented
+
+    def __le__(self, other):
+        if isinstance(other, TimePeriod):
+            return self.total_microseconds <= other.total_microseconds
+        return NotImplemented
+
+    def __ge__(self, other):
+        if isinstance(other, TimePeriod):
+            return self.total_microseconds >= other.total_microseconds
+        return NotImplemented
+
+
+class TimePeriodMicroseconds(TimePeriod):
+    pass
+
+
+class TimePeriodMilliseconds(TimePeriod):
+    pass
+
+
+class TimePeriodSeconds(TimePeriod):
+    pass
+
+
+class TimePeriodMinutes(TimePeriod):
+    pass