dashio 3.6.2__tar.gz → 3.7.0__tar.gz

{dashio-3.6.2 → dashio-3.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dashio
-Version: 3.6.2
+Version: 3.7.0
 Summary: DashIO interface library
 Author-email: James Boulton <james@dashio.com>
 License-Expression: MIT

{dashio-3.6.2 → dashio-3.7.0}/dashio/__init__.py

@@ -70,19 +70,15 @@ from .load_config import (decode_cfg64, encode_cfg64, generate_cfg64,
                           get_control_dict_from_config,
                           get_control_from_config,
                           load_all_controls_from_config)
-from .lte_767x_connection import Lte767xConnection
 from .schedular import Schedular
 from .tcp_connection import TCPConnection
 from .zmq_connection import ZMQConnection
-from .quectel_EG800Q import EG800Q
 
 __all__ = [
     'Device',
     'TCPConnection',
     'ZMQConnection',
     'DashConnection',
-    'Lte767xConnection',
-    'EG800Q',
     'ConnectionState',
     'DashIOCommsModuleConnection',
     'Schedular',

{dashio-3.6.2 → dashio-3.7.0}/dashio/dash_connection.py

@@ -31,6 +31,8 @@ import time
 from socket import gaierror
 
 import paho.mqtt.client as mqtt
+from paho.mqtt.packettypes import PacketTypes
+from paho.mqtt.properties import Properties
 import shortuuid
 import zmq
 
@@ -148,6 +150,8 @@ class DashConnection(threading.Thread):
             for device_id in self._device_id_rx_list:
                 data_topic = f"{self.username}/{device_id}/data"
                 result, mid = self._dash_c.subscribe(data_topic, 0)
+            for device_id in self._device_id_list:
+                self._send_online_state(device_id, "ONLINE")
             self._disconnect_timeout = 1.0
             logger.debug("connected OK")
         else:
@@ -192,6 +196,7 @@ class DashConnection(threading.Thread):
                 result, mid = self._dash_c.subscribe(control_topic, 0)
                 if result == mqtt.MQTT_ERR_SUCCESS:
                     self._subscribing_topics[mid] = control_topic
+                self._send_online_state(device.device_id, "ONLINE")
 
     def _add_device_rx(self, msg_dict):
         """Connect to another device"""
@@ -219,11 +224,38 @@ class DashConnection(threading.Thread):
         logger.debug("DASH SEND ANNOUNCE: %s", msg)
         self.tx_zmq_pub.send_multipart([b"COMMAND", json.dumps(msg).encode()])
 
+    def _send_online_state(self, device_id: str, state: str):
+        """Publish ONLINE or OFFLINE for device_id to its data topic."""
+        return self._dash_c.publish(f"{self.username}/{device_id}/data", f"\t{device_id}\t{state}\n", qos=1)
+
+    def _set_will(self):
+        """Set the MQTT Last Will and Testament: the Dash server publishes OFFLINE if the connection is lost.
+
+        An MQTT connection has a single will on a single topic, so it is for the first device on the connection.
+        The will is fixed when connecting, so devices added later aren't included. close() sends OFFLINE for
+        every device.
+        """
+        if not self._device_id_list:
+            self._dash_c.will_clear()
+            return
+        device_id = self._device_id_list[0]
+        properties = None
+        if self.offline_delay > 0:
+            properties = Properties(PacketTypes.WILLMESSAGE)
+            properties.WillDelayInterval = self.offline_delay
+        self._dash_c.will_set(f"{self.username}/{device_id}/data", f"\t{device_id}\tOFFLINE\n", qos=1, retain=False, properties=properties)
+
     def connect(self):
         """Connect to the server."""
         logger.debug("Connecting..")
+        self._set_will()
+        properties = None
+        if self.offline_delay > 0:
+            # The server only waits the will delay if it keeps the session that long.
+            properties = Properties(PacketTypes.CONNECT)
+            properties.SessionExpiryInterval = self.offline_delay
         try:
-            self._dash_c.connect(self.host, self.port)
+            self._dash_c.connect(self.host, self.port, properties=properties)
             self.connection_state = ConnectionState.CONNECTING
             # Start the network loop only once a host is set, otherwise paho's thread dies with "Invalid host".
             self._dash_c.loop_start()
@@ -251,7 +283,8 @@ class DashConnection(threading.Thread):
         host='dash.dashio.io',
         port=8883,
         use_ssl=True,
-        context: zmq.Context | None = None
+        context: zmq.Context | None = None,
+        offline_delay: int = 10
     ):
         """
         Setups and manages a connection thread to the Dash Server.
@@ -268,6 +301,11 @@ class DashConnection(threading.Thread):
                 password for the dash connection.
             use_ssl : Boolean
                 Defaults to True.
+            context : zmq.Context, optional
+                ZMQ context. Defaults to the shared zmq.Context.instance().
+            offline_delay : int, optional
+                If the connection is lost, the Dash server publishes OFFLINE for the first device after this many
+                seconds, unless the connection is restored first. 0 publishes it straight away. Defaults to 10.
         """
 
         threading.Thread.__init__(self, daemon=True)
@@ -279,7 +317,7 @@ class DashConnection(threading.Thread):
         self._device_id_list = []
         self._device_id_rx_list = []
         self._subscribing_topics = {}
-        # self.LWD = "OFFLINE"
+        self.offline_delay = offline_delay
         self.running = True
         self.username = username
         self.password = password
@@ -305,18 +343,24 @@ class DashConnection(threading.Thread):
             self._dash_c.tls_insecure_set(False)
 
         self._dash_c.username_pw_set(self.username, self.password)
-        # self.dash_c.on_log = self.__on_log
-        # self._dash_c.will_set(self.data_topic, self.LWD, qos=1, retain=False)
-        # Connect
-        if username and password:
-            self.connect()
+        # The connection thread connects, a moment after it starts, so the devices added straight after creating
+        # the connection are included in the will.
         # Start subscribe, with QoS level 0
         self.rx_zmq_sub = self.context.socket(zmq.SUB)
         self._disconnect_timeout = 1.0
         self.start()
 
     def close(self):
-        """Close the connection."""
+        """Send OFFLINE for every device, then close the connection."""
+        if self.connection_state == ConnectionState.CONNECTED:
+            messages = [self._send_online_state(device_id, "OFFLINE") for device_id in self._device_id_list]
+            for message in messages:
+                try:
+                    message.wait_for_publish(timeout=2.0)
+                except (RuntimeError, ValueError) as error:
+                    logger.debug("OFFLINE not sent: %s", error)
+            # A normal disconnect, so the server doesn't also publish the will.
+            self._dash_c.disconnect()
         self.running = False
 
     def _dash_command(self, msg_dict: dict):

{dashio-3.6.2 → dashio-3.7.0}/dashio/iotcontrol/event.py

@@ -70,11 +70,17 @@ class Event:
             raise ValueError("Handler is not handling this event, so cannot unhandle it.") from not_in_set
         return self
 
-    def fire(self, *args, **kargs):
+    def fire(self, *args, **kargs) -> str:
         """Runs all the handlers
+
+        Returns
+        -------
+        str
+            The strings returned by the handlers joined together, e.g. replies to send to the **Dash** app.
+            Handlers that return anything else are ignored.
         """
-        for handler in self.handlers:
-            handler(*args, **kargs)
+        replies = [handler(*args, **kargs) for handler in self.handlers]
+        return "".join(reply for reply in replies if isinstance(reply, str))
 
     def get_handler_count(self):
         """Returns the number of handlers

{dashio-3.6.2 → dashio-3.7.0}/dashio/iotcontrol/event_log.py

@@ -143,15 +143,12 @@ class EventLog(Control):
             from_date = dateutil.parser.isoparse(msg[4])
         except (IndexError, ValueError):
             return ""
-        data_str += self._control_hdr_str + dashboard_id
-        has_data = False
         for log in self.log.get():
             if log.timestamp > from_date:
                 data_str += "\t" + log.to_json()
-                has_data = True
-        if has_data:
-            data_str += "\n"
-        return data_str
+        if not data_str:
+            return ""
+        return self._control_hdr_str + dashboard_id + data_str + "\n"
 
     def add_event_data(self, data: EventData):
         """Add a data point to the log and send it to any connected **Dash** app

{dashio-3.6.2 → dashio-3.7.0}/dashio/iotcontrol/map.py

@@ -126,7 +126,7 @@ class MapTrack:
         """
         reply = f"\t{self.track_id}\t{self.text}\t{self.color.value}"
         for loc in self.locations:
-            reply += f"\t{loc.map_to_json()}"
+            reply += f"\t{loc.to_json()}"
         return reply
 
     def get_last_location(self) -> str:
@@ -199,10 +199,10 @@ class Map(Control):
         try:
             dashboard_id = msg[3]
             from_timestamp = parser.isoparse(msg[4])
-        except IndexError:
+        except (IndexError, ValueError):
             return ""
         if self.tracks:
-            for _, value in self.tracks:
+            for value in self.tracks.values():
                 if value.track_start_time > from_timestamp:
                     reply += self._control_hdr_str + dashboard_id + value.get_track() + "\n"
         return reply
@@ -219,7 +219,7 @@ class Map(Control):
         if track_id in self.tracks:
             self.tracks[track_id].add_location(location)
         else:
-            self.tracks[track_id] = MapTrack("track_id")
+            self.tracks[track_id] = MapTrack(track_id)
             self.tracks[track_id].add_location(location)
         self.send_location(location, track_id)
 

{dashio-3.6.2 → dashio-3.7.0}/dashio.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dashio
-Version: 3.6.2
+Version: 3.7.0
 Summary: DashIO interface library
 Author-email: James Boulton <james@dashio.com>
 License-Expression: MIT

{dashio-3.6.2 → dashio-3.7.0}/dashio.egg-info/SOURCES.txt

@@ -92,6 +92,7 @@ tests/test_device_view.py
 tests/test_dial.py
 tests/test_direction.py
 tests/test_event_log.py
+tests/test_history_replies.py
 tests/test_knob.py
 tests/test_label.py
 tests/test_map.py

{dashio-3.6.2 → dashio-3.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dashio"
-version = "3.6.2"
+version = "3.7.0"
 description = "DashIO interface library"
 readme = "README.md"
 authors = [{ name = "James Boulton", email = "james@dashio.com" }]

dashio-3.7.0/tests/test_dashconnection.py

@@ -0,0 +1,63 @@
+import json
+import unittest
+
+import zmq
+
+from dashio import DashConnection, Device, decode_cfg64
+from dashio.dash_connection import DashControl
+
+
+class TestDashConnection(unittest.TestCase):
+    def _get_cfg_dict(self, cfg_str):
+        json_str = cfg_str.rpartition('\t')[2]
+        return json.loads(json_str)
+
+    def test_dash_connection_username(self):
+        # Connect to localhost so the test doesn't contact the Dash server.
+        test_connection = DashConnection("USERNAME", "PASSWORD", host="localhost")
+        self.assertEqual(test_connection.username, 'USERNAME', "username type should be USERNAME")
+        test_connection.close()
+
+    def test_dash_control_cfg_in_device(self):
+        device = Device("DEVICETYPE", "DEVICEID", "DEVICENAME", context=zmq.Context())
+        self.assertTrue(device.add_control(DashControl("DASH1", "USERNAME", "dash.dashio.io")))
+        reply = device._make_cfg64(["", "DEVICEID", "DASHID", "1"])
+        device.close()
+        cfg = decode_cfg64(reply.rstrip("\n").rpartition("\t")[2])
+        self.assertEqual(cfg["DASHIO"], {"controlID": "DASH1", "userName": "USERNAME", "hostURL": "dash.dashio.io"})
+
+    def test_will_is_offline_for_first_device(self):
+        # Connect to localhost so the test doesn't contact the Dash server.
+        test_connection = DashConnection("USERNAME", "PASSWORD", host="localhost", offline_delay=7)
+        first = Device("DEVICETYPE", "DEVICEID1", "DEVICENAME", context=zmq.Context())
+        second = Device("DEVICETYPE", "DEVICEID2", "DEVICENAME", context=zmq.Context())
+        test_connection.add_device(first)
+        test_connection.add_device(second)
+        test_connection._set_will()
+        client = test_connection._dash_c
+        self.assertEqual(client._will_topic, b"USERNAME/DEVICEID1/data", "The will should be on the first device's data topic")
+        self.assertEqual(client._will_payload, b"\tDEVICEID1\tOFFLINE\n")
+        self.assertEqual((client._will_qos, client._will_retain), (1, False))
+        self.assertEqual(client._will_properties.WillDelayInterval, 7)
+        test_connection.close()
+        first.close()
+        second.close()
+
+    def test_no_will_without_devices(self):
+        test_connection = DashConnection("USERNAME", "PASSWORD", host="localhost")
+        test_connection._set_will()
+        self.assertFalse(test_connection._dash_c._will, "There should be no will without a device")
+        test_connection.close()
+
+    def test_offline_delay_zero_has_no_will_delay(self):
+        test_connection = DashConnection("USERNAME", "PASSWORD", host="localhost", offline_delay=0)
+        device = Device("DEVICETYPE", "DEVICEID1", "DEVICENAME", context=zmq.Context())
+        test_connection.add_device(device)
+        test_connection._set_will()
+        self.assertIsNone(test_connection._dash_c._will_properties, "offline_delay=0 should publish the will straight away")
+        test_connection.close()
+        device.close()
+
+
+if __name__ == '__main__':
+    unittest.main()

dashio-3.7.0/tests/test_history_replies.py

@@ -0,0 +1,87 @@
+import datetime
+import json
+import unittest
+
+import dashio
+from dashio.iotcontrol.event import Event
+
+
+def since(hours: float) -> str:
+    return (datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(hours=hours)).isoformat()
+
+
+class TestEvent(unittest.TestCase):
+    def test_fire_joins_string_replies(self):
+        event = Event()
+        event += lambda msg: "a\n"
+        event += lambda msg: None
+        event += lambda msg: True
+        self.assertEqual(event("msg"), "a\n", "String replies are returned and other return values ignored")
+
+    def test_fire_without_replies(self):
+        event = Event()
+        event += lambda msg: None
+        self.assertEqual(event("msg"), "")
+
+
+class TestHistoryReplies(unittest.TestCase):
+    def setUp(self):
+        self.device = dashio.Device("DEVICETYPE", "DEVICEID", "DEVICENAME")
+
+    def tearDown(self):
+        self.device.close()
+
+    def request(self, ctrl_type: str, control_id: str, from_time: str) -> str:
+        return self.device._on_message(f"\tDEVICEID\t{ctrl_type}\t{control_id}\tDASHID\t{from_time}\n".encode())
+
+    def test_event_log_history(self):
+        log = dashio.EventLog("LOG1")
+        self.device.add_control(log)
+        log.log.append(dashio.EventData("Something happened"))
+        reply = self.request("LOG", "LOG1", since(1))
+        fields = reply.rstrip("\n").split("\t")
+        self.assertEqual(fields[1:5], ["DEVICEID", "LOG", "LOG1", "DASHID"])
+        self.assertEqual(json.loads(fields[5])["lines"], ["Something happened"])
+        self.assertTrue(reply.endswith("\n"))
+
+    def test_event_log_history_empty(self):
+        log = dashio.EventLog("LOG1")
+        self.device.add_control(log)
+        log.log.append(dashio.EventData("Something happened"))
+        self.assertEqual(self.request("LOG", "LOG1", since(-1)), "", "No reply when there are no events after the time")
+
+    def test_time_graph_history(self):
+        graph = dashio.TimeGraph("TG1")
+        graph.add_line("L1", dashio.TimeGraphLine("Line 1"))
+        self.device.add_control(graph)
+        graph.line_dict["L1"].add_data_point(1.5)
+        reply = self.request("TGRPH", "TG1", since(1))
+        fields = reply.rstrip("\n").split("\t")
+        self.assertEqual(fields[1:6], ["DEVICEID", "TGRPH", "TG1", "DASHID", "L1"])
+        self.assertTrue(fields[-1].endswith(",1.5"))
+
+    def test_map_history(self):
+        a_map = dashio.Map("MAP1")
+        self.device.add_control(a_map)
+        a_map.add_location_to_track(dashio.MapLocation("-45.0", "168.0"), "T1")
+        reply = self.request("MAP", "MAP1", since(1))
+        fields = reply.rstrip("\n").split("\t")
+        self.assertEqual(fields[1:6], ["DEVICEID", "MAP", "MAP1", "DASHID", "T1"], "The track should keep its track_id")
+        self.assertEqual(json.loads(fields[-1])["latitude"], "-45.0")
+
+    def test_map_history_bad_time(self):
+        a_map = dashio.Map("MAP1")
+        self.device.add_control(a_map)
+        a_map.add_location_to_track(dashio.MapLocation("-45.0", "168.0"), "T1")
+        self.assertEqual(self.request("MAP", "MAP1", "not a time"), "")
+
+    def test_receive_callback_reply(self):
+        log = dashio.EventLog("LOG1")
+        self.device.add_control(log)
+        log.add_receive_message_callback(lambda msg: f"\t{{device_id}}\tLOG\tLOG1\t{msg[3]}\t{{\"time\": \"x\"}}\n")
+        reply = self.request("LOG", "LOG1", since(1))
+        self.assertEqual(reply, "\tDEVICEID\tLOG\tLOG1\tDASHID\t{\"time\": \"x\"}\n", "A receive callback's reply should be sent")
+
+
+if __name__ == '__main__':
+    unittest.main()

dashio-3.6.2/tests/test_dashconnection.py

@@ -1,31 +0,0 @@
-import json
-import unittest
-
-import zmq
-
-from dashio import DashConnection, Device, decode_cfg64
-from dashio.dash_connection import DashControl
-
-
-class TestDashConnection(unittest.TestCase):
-    def _get_cfg_dict(self, cfg_str):
-        json_str = cfg_str.rpartition('\t')[2]
-        return json.loads(json_str)
-
-    def test_dash_connection_username(self):
-        # Connect to localhost so the test doesn't contact the Dash server.
-        test_connection = DashConnection("USERNAME", "PASSWORD", host="localhost")
-        self.assertEqual(test_connection.username, 'USERNAME', "username type should be USERNAME")
-        test_connection.close()
-
-    def test_dash_control_cfg_in_device(self):
-        device = Device("DEVICETYPE", "DEVICEID", "DEVICENAME", context=zmq.Context())
-        self.assertTrue(device.add_control(DashControl("DASH1", "USERNAME", "dash.dashio.io")))
-        reply = device._make_cfg64(["", "DEVICEID", "DASHID", "1"])
-        device.close()
-        cfg = decode_cfg64(reply.rstrip("\n").rpartition("\t")[2])
-        self.assertEqual(cfg["DASHIO"], {"controlID": "DASH1", "userName": "USERNAME", "hostURL": "dash.dashio.io"})
-
-
-if __name__ == '__main__':
-    unittest.main()