boneIO 0.9.4__tar.gz → 0.9.4.dev2__tar.gz

{boneio-0.9.4 → boneio-0.9.4.dev2}/PKG-INFO

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

{boneio-0.9.4 → boneio-0.9.4.dev2}/boneio/example_config/config.yaml

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

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

@@ -0,0 +1,32 @@
+"""
+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 → boneio-0.9.4.dev2}/boneio/manager.py

@@ -778,17 +778,13 @@ class Manager:
         """Callback for receiving action from Mqtt."""
         _LOGGER.debug("Processing topic %s with message %s.", topic, message)
         if topic.startswith(
-            f"{self._config_helper.ha_discovery_prefix}/status"
+            f"{self._config_helper.topic_prefix}/status"
         ):
             if message == ONLINE:
                 self.resend_autodiscovery()
                 self._event_bus.signal_ha_online()
             return
-        try:
-            assert topic.startswith(self._config_helper.cmd_topic_prefix)
-        except AssertionError as err:
-            _LOGGER.error("Wrong topic %s. Error %s", topic, err)
-            return
+        assert topic.startswith(self._config_helper.cmd_topic_prefix)
         topic_parts_raw = topic[
             len(self._config_helper.cmd_topic_prefix) :
         ].split("/")

{boneio-0.9.4 → boneio-0.9.4.dev2}/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, 60
+                        self.reconnect_interval * 2, 600
                     )
                     _LOGGER.error(
                         "MQTT error: %s. Reconnecting in %s seconds",
@@ -182,7 +182,6 @@ 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):
@@ -195,20 +194,22 @@ 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:
-            await stack.enter_async_context(self.asyncio_client)
-            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()
 
+            # 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)
 

boneio-0.9.4.dev2/boneio/version.py

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

{boneio-0.9.4 → boneio-0.9.4.dev2}/pyproject.toml

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

boneio-0.9.4/boneio/example_config/all_binary_sensor.yaml

@@ -1,106 +0,0 @@
-- 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/boneio/helper/queue.py

@@ -1,58 +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
-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/boneio/version.py

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