boneIO 0.8.0.dev5__tar.gz → 0.8.0.dev7__tar.gz

{boneIO-0.8.0.dev5 → boneIO-0.8.0.dev7}/PKG-INFO

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

{boneIO-0.8.0.dev5 → boneIO-0.8.0.dev7}/boneio/group/output.py

@@ -1,4 +1,5 @@
 """Group output module."""
+
 from __future__ import annotations
 import asyncio
 from typing import List
@@ -13,26 +14,46 @@ class OutputGroup(BasicRelay):
         self,
         members: List[BasicRelay],
         output_type: str = SWITCH,
-        restored_state: bool = True,
+        restored_state: bool = False,
+        all_on_behaviour: bool = False,
         **kwargs,
     ) -> None:
         """Initialize cover class."""
         self._loop = asyncio.get_event_loop()
         super().__init__(
-            **kwargs, output_type=output_type, restored_state=restored_state, topic_type="group"
+            **kwargs,
+            output_type=output_type,
+            restored_state=False,
+            topic_type="group",
         )
+        self._all_on_behaviour = all_on_behaviour
         self._group_members = [x for x in members if x.output_type != COVER]
         self._timer_handle = None
+        self.check_state()
+
         for member in self._group_members:
-            self._event_bus.add_output_listener(member.id, self.event_listener)
+            self._event_bus.add_output_listener(
+                output_id=member.id,
+                group_id=self.id,
+                target=self.event_listener,
+            )
 
-    async def event_listener(self, relay_id=None) -> None:
-        """Listen for events called by children relays."""
-        state = OFF
+    def check_state(self) -> None:
         for x in self._group_members:
             if x.state == ON:
-                state = ON
-                break
+                self._state = ON
+                return
+
+    async def event_listener(self, relay_id=None) -> None:
+        """Listen for events called by children relays."""
+        if self._all_on_behaviour:
+            state = (
+                ON if all(x.state == ON for x in self._group_members) else OFF
+            )
+        else:
+            state = (
+                ON if any(x.state == ON for x in self._group_members) else OFF
+            )
         if state != self._state or not relay_id:
             self._state = state
             self._loop.call_soon_threadsafe(self.send_state)
@@ -40,13 +61,19 @@ class OutputGroup(BasicRelay):
     async def async_turn_on(self) -> None:
         """Call turn on action."""
         await asyncio.gather(
-            *[self._loop.run_in_executor(self.executor, x.turn_on) for x in self._group_members]
+            *[
+                self._loop.run_in_executor(self.executor, x.turn_on)
+                for x in self._group_members
+            ]
         )
 
     async def async_turn_off(self) -> None:
         """Call turn off action."""
         await asyncio.gather(
-            *[self._loop.run_in_executor(self.executor, x.turn_off) for x in self._group_members]
+            *[
+                self._loop.run_in_executor(self.executor, x.turn_off)
+                for x in self._group_members
+            ]
         )
 
     @property
@@ -56,4 +83,6 @@ class OutputGroup(BasicRelay):
 
     def send_state(self) -> None:
         """Send state to Mqtt on action."""
-        self._send_message(topic=self._send_topic, payload=self.payload(), retain=True)
+        self._send_message(
+            topic=self._send_topic, payload=self.payload(), retain=True
+        )

{boneIO-0.8.0.dev5 → boneIO-0.8.0.dev7}/boneio/helper/events.py

@@ -4,7 +4,7 @@ import logging
 import signal
 import time
 from datetime import datetime
-from typing import Any, Coroutine, List, Optional, Callable, Optional
+from typing import Any, Coroutine, List, Optional, Callable
 
 
 from boneio.helper.util import callback
@@ -85,7 +85,9 @@ class EventBus:
         self._output_listeners = {}
         self._sigterm_listeners = []
         self._haonline_listeners = []
-        self._timer_handle = _async_create_timer(self._loop, self._run_second_event)
+        self._timer_handle = _async_create_timer(
+            self._loop, self._run_second_event
+        )
         for signame in {"SIGINT", "SIGTERM"}:
             self._loop.add_signal_handler(
                 getattr(signal, signame),
@@ -121,17 +123,19 @@ class EventBus:
         """Add sigterm listener."""
         self._sigterm_listeners.append(target)
 
-    def add_output_listener(self, name, target):
+    def add_output_listener(self, output_id, group_id, target):
         """Add output listener."""
-        self._output_listeners[name] = ListenerJob(target=target)
-        return self._output_listeners[name]
-    
+        if output_id not in self._output_listeners:
+            self._output_listeners[output_id] = {}
+        self._output_listeners[output_id][group_id] = ListenerJob(target=target)
+        return self._output_listeners[output_id]
+
     def trigger_output_event(self, event):
         asyncio.create_task(self.async_trigger_output_event(event=event))
-    
+
     async def async_trigger_output_event(self, event):
-        listener = self._output_listeners.get(event)
-        if listener:
+        listeners = self._output_listeners.get(event, {})
+        for listener in listeners.values():
             await listener.target(event)
 
     def add_haonline_listener(self, target):

{boneIO-0.8.0.dev5 → boneIO-0.8.0.dev7}/boneio/helper/loader.py

@@ -15,7 +15,6 @@ from boneio.const import (
     DEVICE_CLASS,
     FILTERS,
     GPIO,
-    PCA,
     ID,
     INIT_SLEEP,
     INPUT,
@@ -135,6 +134,8 @@ def create_temp_sensor(
     else:
         return
     name = config.get(ID)
+    if not name:
+        return
     id = name.replace(" ", "")
     try:
         temp_sensor = TempSensor(

{boneIO-0.8.0.dev5 → boneIO-0.8.0.dev7}/boneio/helper/stats.py

@@ -63,7 +63,7 @@ def get_network_info():
         for addr in addrs:
             if addr.family == socket.AF_INET:
                 out["ip"] = addr.address
-                out["mask"] = addr.netmask
+                out["mask"] = addr.netmask if addr.netmask is not None else ""
             elif addr.family == psutil.AF_LINK:
                 out["mac"] = addr.address
         return out
@@ -139,7 +139,9 @@ class HostSensor(AsyncUpdater):
 
     async def async_update(self, time: datetime) -> None:
         self._state = self._update_function()
-        self._loop.call_soon_threadsafe(partial(self._manager_callback, self._type))
+        self._loop.call_soon_threadsafe(
+            partial(self._manager_callback, self._type)
+        )
 
     @property
     def state(self) -> dict:
@@ -155,7 +157,7 @@ class HostData:
         self,
         output: dict,
         callback: Callable,
-        temp_sensor: Callable[[LM75Sensor, MCP9808Sensor], None],
+        temp_sensor: Callable[[LM75Sensor, MCP9808Sensor], None] | None,
         ina219: INA219Class | None,
         manager: Manager,
         enabled_screens: List[str],
@@ -164,27 +166,68 @@ class HostData:
         self._hostname = socket.gethostname()
         self._temp_sensor = temp_sensor
         host_stats = {
-            NETWORK: {"f": get_network_info, "update_interval": TimePeriod(seconds=60)},
+            NETWORK: {
+                "f": get_network_info,
+                "update_interval": TimePeriod(seconds=60),
+            },
             CPU: {"f": get_cpu_info, "update_interval": TimePeriod(seconds=5)},
-            DISK: {"f": get_disk_info, "update_interval": TimePeriod(seconds=60)},
-            MEMORY: {"f": get_memory_info, "update_interval": TimePeriod(seconds=10)},
-            SWAP: {"f": get_swap_info, "update_interval": TimePeriod(seconds=60)},
+            DISK: {
+                "f": get_disk_info,
+                "update_interval": TimePeriod(seconds=60),
+            },
+            MEMORY: {
+                "f": get_memory_info,
+                "update_interval": TimePeriod(seconds=10),
+            },
+            SWAP: {
+                "f": get_swap_info,
+                "update_interval": TimePeriod(seconds=60),
+            },
             UPTIME: {
-                "f": lambda: {
-                    "uptime": {"data": get_uptime(), "fontSize": "small", "row": 2, "col": 3},
-                    "MQTT": {"data": "CONN" if manager.mqtt_state else "DOWN", "fontSize": "small", "row": 3, "col": 60},
-                    "T": {
-                        "data": f"{self._temp_sensor.state} C",
+                "f": lambda: (
+                    {
+                        "uptime": {
+                            "data": get_uptime(),
+                            "fontSize": "small",
+                            "row": 2,
+                            "col": 3,
+                        },
+                        "MQTT": {
+                            "data": "CONN" if manager.mqtt_state else "DOWN",
+                            "fontSize": "small",
+                            "row": 3,
+                            "col": 60,
+                        },
+                        "T": {
+                            "data": f"{self._temp_sensor.state} C",
+                            "fontSize": "small",
+                            "row": 3,
+                            "col": 3,
+                        },
+                    }
+                    if self._temp_sensor
+                    else {
+                        "uptime": {
+                            "data": get_uptime(),
+                            "fontSize": "small",
+                            "row": 2,
+                            "col": 3,
+                        }
+                    }
+                ),
+                "static": {
+                    HOST: {
+                        "data": self._hostname,
                         "fontSize": "small",
-                        "row": 3,
-                        "col": 3
+                        "row": 0,
+                        "col": 3,
+                    },
+                    "ver": {
+                        "data": __version__,
+                        "fontSize": "small",
+                        "row": 1,
+                        "col": 3,
                     },
-                }
-                if self._temp_sensor
-                else {"uptime": {"data": get_uptime(), "fontSize": "small", "row": 2, "col": 3}},
-                "static": {
-                    HOST: {"data": self._hostname, "fontSize": "small", "row": 0, "col": 3},
-                    "ver": {"data": __version__, "fontSize": "small", "row": 1, "col": 3},
                 },
                 "update_interval": TimePeriod(seconds=30),
             },
@@ -192,9 +235,12 @@ class HostData:
         if ina219 is not None:
             host_stats[INA219] = {
                 "f": lambda: {
-                    *{sensor.device_class: sensor.state for sensor in ina219.sensors}
+                    *{
+                        sensor.device_class: sensor.state
+                        for sensor in ina219.sensors.values()
+                    }
                 },
-                "update_interval": TimePeriod(seconds=60)
+                "update_interval": TimePeriod(seconds=60),
             }
         self._data = {}
         for k, _v in host_stats.items():

{boneIO-0.8.0.dev5 → boneIO-0.8.0.dev7}/boneio/input/gpio.py

@@ -1,4 +1,5 @@
 """GpioEventButton to receive signals."""
+
 from __future__ import annotations
 import logging
 import asyncio
@@ -39,6 +40,12 @@ class GpioEventButton(GpioBaseClass):
         self._is_waiting_for_second_click = False
         if not self._state and not self._timer_long.is_waiting():
             self.press_callback(click_type=SINGLE, duration=None)
+        else:
+            _LOGGER.error(
+                "Thats why it's not working %s %s",
+                self._state,
+                self._timer_long.is_waiting(),
+            )
 
     async def _run(self) -> None:
         while True:
@@ -49,7 +56,7 @@ class GpioEventButton(GpioBaseClass):
         if state == self._state:
             return
         self._state = state
-        if state: #is pressed?
+        if state:  # is pressed?
             self._timer_long.start_timer()
             if self._timer_double.is_waiting():
                 self._timer_double.reset()
@@ -59,8 +66,11 @@ class GpioEventButton(GpioBaseClass):
                 self._timer_double.start_timer()
                 self._is_waiting_for_second_click = True
 
-        else: #is released?
-            if not self._is_waiting_for_second_click and not self._double_click_ran:
+        else:  # is released?
+            if (
+                not self._is_waiting_for_second_click
+                and not self._double_click_ran
+            ):
                 if self._timer_long.is_waiting():
                     self.press_callback(click_type=SINGLE, duration=None)
             self._timer_long.reset()

{boneIO-0.8.0.dev5 → boneIO-0.8.0.dev7}/boneio/manager.py

@@ -299,7 +299,7 @@ class Manager:
                 if x in self._output:
                     output = self._output[x]
                     if output.output_type == COVER:
-                        _LOGGER.warn("You can't add cover output to group.")
+                        _LOGGER.warning("You can't add cover output to group.")
                     else:
                         outputs.append(output)
             return outputs

{boneIO-0.8.0.dev5 → boneIO-0.8.0.dev7}/boneio/modbus/client.py

@@ -101,51 +101,51 @@ class Modbus:
             _LOGGER.error(exception_error)
             return False
 
-    async def read_single_register(
+    async def read_and_decode(
         self,
         unit: int | str,
         address: int,
+        payload_type: str,
         count: int = 2,
         method: str = "input",
     ) -> float | None:
-        """Call sync. pymodbus."""
-        async with self._lock:
-            if not self._pymodbus_connect():
-                _LOGGER.error("Can't connect to Modbus address %s.", address)
-                return None
-            kwargs = {"unit": unit, "count": count} if unit else {}
-            try:
-                result: ReadInputRegistersResponse = self._read_methods[method](
-                    address, **kwargs
-                )
-            except (ModbusException, struct.error) as exception_error:
-                _LOGGER.error(exception_error)
-                return None
-            if not hasattr(result, REGISTERS):
-                _LOGGER.error(str(result))
-                return None
-            return BinaryPayloadDecoder.fromRegisters(
-                result.registers, byteorder=Endian.Big, wordorder=Endian.Big
-            ).decode_32bit_float()
+        """Call read_registers and decode."""
+        result = await self.read_registers(
+            unit=unit, address=address, count=count, method=method
+        )
+        if not result or result.isError():
+            return None
+        decoded_value = self.decode_value(
+            payload=result.registers, value_type=payload_type
+        )
+        return decoded_value
 
-    async def read_multiple_registers(
+    async def read_registers(
         self,
         unit: int | str,  # device address
         address: int,  # modbus register address
         count: int = 2,  # number of registers to read
         method: str = "input",  # type of register: input, holding
     ) -> ModbusResponse:
-        """Call sync. pymodbus."""
+        """Call async pymodbus."""
         async with self._lock:
             if not self._pymodbus_connect():
                 _LOGGER.error("Can't connect to Modbus.")
                 return None
             kwargs = {"unit": unit, "count": count} if unit else {}
             try:
-                result: ReadInputRegistersResponse = self._read_methods[method](
+                read_method = self._read_methods[method]
+                _LOGGER.debug(
+                    "Reading %s registers from %s with method %s from device %s.",
+                    count,
+                    address,
+                    method,
+                    unit,
+                )
+                result: ReadInputRegistersResponse = read_method(
                     address, **kwargs
                 )
-            except ModbusException as exception_error:
+            except (ModbusException, struct.error) as exception_error:
                 _LOGGER.error(exception_error)
                 return None
             if not hasattr(result, REGISTERS):

{boneIO-0.8.0.dev5 → boneIO-0.8.0.dev7}/boneio/modbus/modbuscli.py

@@ -53,7 +53,7 @@ class ModbusHelper:
             f"Checking connection {self._device_address}, address {address}."
         )
         count = 1 if value_type == "S_WORD" or value_type == "U_WORD" else 2
-        value = await self._modbus.read_multiple_registers(
+        value = await self._modbus.read_registers(
             unit=self._device_address,
             address=address,
             count=count,
@@ -180,7 +180,7 @@ async def async_run_modbus_get(
         parity=parity,
     )
     count = 1 if value_type == "S_WORD" or value_type == "U_WORD" else 2
-    value = await _modbus.read_multiple_registers(
+    value = await _modbus.read_registers(
         unit=device_address,
         address=register_address,
         count=count,

boneIO-0.8.0.dev7/boneio/modbus/orno-or-we-517.json

@@ -0,0 +1,36 @@
+{
+  "model": "orno-or-we-517",
+  "registers_base": [
+    {
+      "base": 14,
+      "length": 6,
+      "register_type": "holding",
+      "registers": [
+        {
+          "name": "Voltage_L1",
+          "address": 14,
+          "unit_of_measurement": "V",
+          "state_class": "measurement",
+          "device_class": "voltage",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Voltage_L2",
+          "address": 16,
+          "unit_of_measurement": "V",
+          "state_class": "measurement",
+          "device_class": "voltage",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Voltage_L3",
+          "address": 18,
+          "unit_of_measurement": "V",
+          "state_class": "measurement",
+          "device_class": "voltage",
+          "value_type": "FP32"
+        }
+      ]
+    }
+  ]
+}

{boneIO-0.8.0.dev5 → boneIO-0.8.0.dev7}/boneio/modbus/sensor.py

@@ -122,10 +122,13 @@ class ModbusSensor(BasicMqtt, AsyncUpdater):
             register_method = first_register_base.get("register_type", "input")
             # Let's try fetch register 2 times in case something wrong with initial packet.
             for _ in [0, 1]:
-                register = await self._modbus.read_single_register(
+                register = await self._modbus.read_and_decode(
                     unit=self._address,
                     address=first_register_base[REGISTERS][0][ADDRESS],
                     method=register_method,
+                    payload_type=first_register_base[REGISTERS][0].get(
+                        "value_type", "FP32"
+                    ),
                 )
                 if register is not None:
                     self._discovery_sent = (
@@ -144,7 +147,7 @@ class ModbusSensor(BasicMqtt, AsyncUpdater):
         update_interval = self._update_interval.total_in_seconds
         await self.check_availability()
         for data in self._db[REGISTERS_BASE]:
-            values = await self._modbus.read_multiple_registers(
+            values = await self._modbus.read_registers(
                 unit=self._address,
                 address=data[BASE],
                 count=data[LENGTH],

{boneIO-0.8.0.dev5 → boneIO-0.8.0.dev7}/boneio/schema/schema.yaml

@@ -432,6 +432,12 @@ output_group:
         required: True
         meta:
           label: List of outputs.
+      all_on_behaviour:
+        type: boolean
+        required: True
+        default: False
+        meta:
+          label: Behaviour if set true toggle when all outputs are on, otherwise if any is on then group is on.
       output_type:
         type: string
         required: True

{boneIO-0.8.0.dev5 → boneIO-0.8.0.dev7}/boneio/sensor/ina219.py

@@ -1,4 +1,5 @@
 """INA219 Black sensor."""
+
 from __future__ import annotations
 from datetime import datetime
 import logging
@@ -10,24 +11,24 @@ from boneio.helper.sensor.ina_219_smbus import INA219_I2C
 
 _LOGGER = logging.getLogger(__name__)
 
-unit_converter = {
-    "current": "A",
-    "power": "W",
-    "voltage": "V"
-}
+unit_converter = {"current": "A", "power": "W", "voltage": "V"}
 
 
 class INA219Sensor(BasicMqtt, Filter):
     """Represent singel value from INA219 as sensor."""
 
-    def __init__(self, device_class: str, filters: list, state: float | None, **kwargs) -> None:
+    def __init__(
+        self, device_class: str, filters: list, state: float | None, **kwargs
+    ) -> None:
         super().__init__(topic_type=SENSOR, **kwargs)
         self._unit_of_measurement = unit_converter[device_class]
         self._device_class = device_class
         self._filters = filters
         self._raw_state = state
         self._state = (
-            self._apply_filters(value=self._raw_state) if self._raw_state else None
+            self._apply_filters(value=self._raw_state)
+            if self._raw_state
+            else None
         )
 
     @property
@@ -41,18 +42,22 @@ class INA219Sensor(BasicMqtt, Filter):
     @property
     def state(self) -> float | None:
         return self._state
-    
+
     @property
     def device_class(self) -> str:
         return self._device_class
-    
+
     @property
     def unit_of_measurement(self) -> str:
         return self._unit_of_measurement
 
     def update(self, time: datetime) -> None:
         """Fetch temperature periodically and send to MQTT."""
-        _state = self._apply_filters(value=self._raw_state) if self._raw_state else None
+        _state = (
+            self._apply_filters(value=self._raw_state)
+            if self._raw_state
+            else None
+        )
         if not _state:
             return
         self._state = _state
@@ -65,7 +70,9 @@ class INA219Sensor(BasicMqtt, Filter):
 class INA219(AsyncUpdater, Filter):
     """Represent INA219 sensors."""
 
-    def __init__(self, address: int, id: str, sensors: list[dict] = [], **kwargs) -> None:
+    def __init__(
+        self, address: int, id: str, sensors: list[dict] = [], **kwargs
+    ) -> None:
         """Setup GPIO ADC Sensor"""
         self._loop = asyncio.get_event_loop()
         self._ina_219 = INA219_I2C(address=address)

boneIO-0.8.0.dev7/boneio/version.py

@@ -0,0 +1,2 @@
+# flake8: noqa
+__version__ = "0.8.0dev7"

{boneIO-0.8.0.dev5 → boneIO-0.8.0.dev7}/pyproject.toml

@@ -30,7 +30,7 @@ dependencies = [
     "Adafruit-BBIO>=1.2.0",
 ]
 requires-python = ">=3.7"
-version = "0.8.0.dev5"
+version = "0.8.0.dev7"
 
 [project.license]
 text = "GNU General Public License v3.0"

boneIO-0.8.0.dev5/boneio/modbus/orno-or-we-517.json

@@ -1,20 +0,0 @@
-{
-    "model": "orno-or-we-517",
-    "registers_base": [
-        {
-            "base": 14,
-            "length": 4,
-	    "register_type": "holding",
-	    "registers": [
-                {
-                    "name": "Napiecie_L1",
-                    "address": 14,
-                    "unit_of_measurement": "V",
-                    "state_class": "measurement",
-                    "device_class": "voltage",
-                    "return_type": "float32"
-                }
-            ]
-        }
-    ]
-}

boneIO-0.8.0.dev5/boneio/version.py

@@ -1,2 +0,0 @@
-# flake8: noqa
-__version__ = "0.8.0dev5"