boneio 0.9.4.dev3__tar.gz → 0.9.4.dev4__tar.gz

{boneio-0.9.4.dev3 → boneio-0.9.4.dev4}/PKG-INFO

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

boneio-0.9.4.dev4/boneio/example_config/all_binary_sensor.yaml

@@ -0,0 +1,106 @@
+- id: IN_01
+  boneio_input: IN_01
+  actions:
+    pressed:
+      - action: output
+        pin: OUT_01
+- id: IN_02
+  boneio_input: IN_02
+  actions:
+    pressed:
+      - action: output
+        pin: OUT_02
+# - id: IN_03
+#   boneio_input: IN_03
+# - id: IN_04
+#   boneio_input: IN_04
+# - id: IN_05
+#   boneio_input: IN_05
+# - id: IN_06
+#   boneio_input: IN_06
+# - id: IN_07
+#   boneio_input: IN_07
+# - id: IN_08
+#   boneio_input: IN_08
+# - id: IN_09
+#   boneio_input: IN_09
+# - id: IN_10
+#   boneio_input: IN_10
+# - id: IN_11
+#   boneio_input: IN_11
+# - id: IN_12
+#   boneio_input: IN_12
+# - id: IN_13
+#   boneio_input: IN_13
+# - id: IN_14
+#   boneio_input: IN_14
+# - id: IN_15
+#   boneio_input: IN_15
+# - id: IN_16
+#   boneio_input: IN_16
+# - id: IN_17
+#   boneio_input: IN_17
+# - id: IN_18
+#   boneio_input: IN_18
+# - id: IN_19
+#   boneio_input: IN_19
+# - id: IN_20
+#   boneio_input: IN_20
+# - id: IN_21
+#   boneio_input: IN_21
+# - id: IN_22
+#   boneio_input: IN_22
+# - id: IN_23
+#   boneio_input: IN_23
+# - id: IN_24
+#   boneio_input: IN_24
+# - id: IN_25
+#   boneio_input: IN_25
+# - id: IN_26
+#   boneio_input: IN_26
+# - id: IN_27
+#   boneio_input: IN_27
+# - id: IN_28
+#   boneio_input: IN_28
+# - id: IN_29
+#   boneio_input: IN_29
+# - id: IN_30
+#   boneio_input: IN_30
+# - id: IN_31
+#   boneio_input: IN_31
+# - id: IN_32
+#   boneio_input: IN_32
+# - id: IN_33
+#   boneio_input: IN_33
+# - id: IN_34
+#   boneio_input: IN_34
+# - id: IN_35
+#   boneio_input: IN_35
+# - id: IN_36
+#   boneio_input: IN_36
+# - id: IN_37
+#   boneio_input: IN_37
+# - id: IN_38
+#   boneio_input: IN_38
+# - id: IN_39
+#   boneio_input: IN_39
+# - id: IN_40
+#   boneio_input: IN_40
+# - id: IN_41
+#   boneio_input: IN_41
+# - id: IN_42
+#   boneio_input: IN_42
+# - id: IN_43
+#   boneio_input: IN_43
+# - id: IN_44
+#   boneio_input: IN_44
+# - id: IN_45
+#   boneio_input: IN_45
+# - id: IN_46
+#   boneio_input: IN_46
+# - id: IN_47
+#   boneio_input: IN_47
+# - id: IN_48
+#   boneio_input: IN_48
+# - id: IN_49
+#   boneio_input: IN_49

{boneio-0.9.4.dev3 → boneio-0.9.4.dev4}/boneio/example_config/config.yaml

@@ -15,7 +15,7 @@ lm75:
 event: !include event.yaml
 binary_sensor: !include binary_sensor.yaml
 
-output: !include output32x5A.yaml
+output: !include output32x10A_new.yaml
 
 boneio:
   name: "boneIO Black 32x10A"

boneio-0.9.4.dev4/boneio/helper/queue.py

@@ -0,0 +1,58 @@
+"""
+Special unique implementation of asyncio.Queue for boneIO.
+If MQTT is down then regular queue can append multiple ON/OFF for same topic.
+After re-connection it would send all messages. It's not necessary, last payload of same topic is enough.
+"""
+import asyncio
+from typing import Any, Dict, Tuple
+
+
+class UniqueQueue(asyncio.Queue):
+    """Unique implementation of asyncio.Queue that handles MQTT connection state."""
+
+    def __init__(self, maxsize: int = 0):
+        """Initialize the queue."""
+        super().__init__(maxsize=maxsize)
+        self._unique_items: Dict[str, Tuple[Any, ...]] = {}
+        self._is_connected = False
+
+    def set_connected(self, state: bool) -> None:
+        """Set the connection state."""
+        self._is_connected = state
+
+    def _init(self, maxsize: int) -> None:
+        """Initialize the internal queue storage."""
+        super()._init(maxsize=maxsize)
+        self._unique_items = {}
+
+    def _put(self, item: Tuple[str, Any, bool]) -> None:
+        """Put an item into the queue.
+        
+        If MQTT is not connected:
+            - If topic exists, replace the old message
+            - If topic doesn't exist, add new message
+        If MQTT is connected:
+            - Add all messages to queue
+        
+        Args:
+            item: Tuple of (topic, payload, retain)
+        """
+        topic = item[0]
+        
+        if not self._is_connected:
+            # When disconnected, replace existing messages for same topic
+            if topic in self._unique_items:
+                self._queue.remove(self._unique_items[topic])
+            super()._put(item)
+            self._unique_items[topic] = item
+        else:
+            # When connected, queue all messages
+            super()._put(item)
+            self._unique_items[topic] = item
+
+    def _get(self) -> Tuple[str, Any, bool]:
+        """Get an item from the queue and remove it from unique items tracking."""
+        item = super()._get()
+        if item[0] in self._unique_items:
+            del self._unique_items[item[0]]
+        return item

{boneio-0.9.4.dev3 → boneio-0.9.4.dev4}/boneio/mqtt_client.py

@@ -19,10 +19,10 @@ from paho.mqtt.properties import Properties
 from paho.mqtt.subscribeoptions import SubscribeOptions
 
 from boneio.const import OFFLINE, PAHO, STATE
-from boneio.helper import UniqueQueue
 from boneio.helper.config import ConfigHelper
 from boneio.helper.events import GracefulExit
 from boneio.helper.message_bus import MessageBus
+from boneio.helper.queue import UniqueQueue
 from boneio.manager import Manager
 
 _LOGGER = logging.getLogger(__name__)
@@ -174,7 +174,7 @@ class MQTTClient(MessageBus):
                     await self._subscribe_manager(self._manager)
                 except MqttError as err:
                     self.reconnect_interval = min(
-                        self.reconnect_interval * 2, 600
+                        self.reconnect_interval * 2, 60
                     )
                     _LOGGER.error(
                         "MQTT error: %s. Reconnecting in %s seconds",
@@ -182,6 +182,7 @@ class MQTTClient(MessageBus):
                         self.reconnect_interval,
                     )
                     self._connection_established = False
+                    self.publish_queue.set_connected(False)
                     await asyncio.sleep(self.reconnect_interval)
                     self.create_client()  # reset connect/reconnect futures
         except (asyncio.CancelledError, GracefulExit):
@@ -194,21 +195,19 @@ class MQTTClient(MessageBus):
 
     async def _subscribe_manager(self, manager: Manager) -> None:
         """Connect and subscribe to manager topics + host stats."""
-        # Create a new future for this run
-        self._cancel_future = asyncio.Future()
-        
-        async def wait_for_cancel():
-            await self._cancel_future
-            # When future completes, raise CancelledError to stop other tasks
-            raise asyncio.CancelledError("Stop requested")
-        
         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
+            self._connection_established = True
+            self.publish_queue.set_connected(True)
+            # Create a new future for this run
+            self._cancel_future = asyncio.Future()
+            
+            async def wait_for_cancel():
+                await self._cancel_future
+                # When future completes, raise CancelledError to stop other tasks
+                raise asyncio.CancelledError("Stop requested")
+            
+            tasks: Set[asyncio.Task] = set()
 
             publish_task = asyncio.create_task(self._handle_publish())
             tasks.add(publish_task)

boneio-0.9.4.dev4/boneio/version.py

@@ -0,0 +1,2 @@
+# flake8: noqa
+__version__ = "0.9.4dev4"

{boneio-0.9.4.dev3 → boneio-0.9.4.dev4}/pyproject.toml

@@ -35,7 +35,7 @@ dependencies = [
     "qrcode==7.4.2",
 ]
 requires-python = ">=3.7"
-version = "0.9.4.dev3"
+version = "0.9.4.dev4"
 
 [project.license]
 text = "GNU General Public License v3.0"

boneio-0.9.4.dev3/boneio/helper/queue.py

@@ -1,32 +0,0 @@
-"""
-Special unique implementation of asyncio.Queue for boneIO.
-If MQTT is down then regular queue can append multiple ON/OFF for same topic.
-After re-connection it would send all messages. It's not necessary, last payload of same topic is enough.
-"""
-import asyncio
-
-
-class UniqueQueue(asyncio.Queue):
-    """Unique implementation of asyncio.Queue."""
-
-    def _init(self, maxsize):
-        """Create unique dict of tuple[0]."""
-        super()._init(maxsize=maxsize)
-        self._unique_set = {}
-
-    def _put(self, item):
-        """If item does not exists add it.
-        If exists remove old one and put new one in the beginning of the queue."""
-        if item[0] not in self._unique_set:
-            super()._put(item)
-            self._unique_set[item[0]] = item
-        else:
-            self._queue.remove(self._unique_set[item[0]])
-            super()._put(item)
-            self._unique_set[item[0]] = item
-
-    def _get(self):
-        """Get item and remove it."""
-        item = super()._get()
-        del self._unique_set[item[0]]
-        return item

boneio-0.9.4.dev3/boneio/version.py

@@ -1,2 +0,0 @@
-# flake8: noqa
-__version__ = "0.9.4dev3"