dashio 3.3.0__tar.gz → 3.3.2__tar.gz

dashio-3.3.2/PKG-INFO

@@ -0,0 +1,197 @@
+Metadata-Version: 2.1
+Name: dashio
+Version: 3.3.2
+Summary: DashIO interface library
+Home-page: https://dashio.io
+Download-URL: https://github.com/dashio-connect/python-dashio
+Author: James Boulton
+Author-email: james@dashio.com
+License: MIT
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Operating System :: OS Independent
+Requires-Python: >3.6.0
+Description-Content-Type: text/markdown
+Provides-Extra: testing
+License-File: LICENSE
+
+# DashIO
+
+![Tests](https://github.com/dashio-connect/python-dashio/actions/workflows/tests.yml/badge.svg)
+
+[**DashIO**](http://dashio.io) - It is a quick effortless way to connect your IoT device to your phone, tablet or iPad using the free **Dash** app. It allows easy setup of controls such as Dials, Text Boxes, Charts, Graphs, Notifications..., from your IoT device. You can define the look and layout of the controls on your phone from your IoT device. There are three methods to connect to your phone; Bluetooth Low Energy (BLE), TCP or MQTT.
+
+## Getting Started
+
+For the big picture on **DashIO**, take a look at our website: <a href="https://dashio.io">dashio.io</a>
+
+## Documentation
+
+For all documentation and software guides: <a href="https://dashio.io/documents">dashio.io/documents</a>
+
+For the **DashIO** Python guide: <a href="https://dashio.io/guide-python">dashio.io/guide-python</a>
+
+For the **DashIO** Python library: <a href="https://dashio.io/python-library/">dashio.io/python-library</a>
+
+## Examples
+
+There are plenty of examples in the github repository under the Examples directory.
+
+## Dash IoT Application
+
+The **Dash** app is free and available for both Apple and Android devices. Use it to create beautiful and powerful user interfaces to you IoT devices.
+
+Dashio Phone               |  Dashio Tablet
+:-------------------------:|:-------------------------:
+<img src="https://dashio.io/wp-content/uploads/2020/11/IMG_4154.jpeg" width="150" /> | <img src="https://dashio.io/wp-content/uploads/2020/12/IMG_4203.jpeg" width="450" />
+
+## Requirements
+
+* python3.6 and above
+* paho-mqtt
+* pyzmq
+* python-dateutil
+* zeroconf
+* shortuuid
+
+## Install
+
+`pip3 install dashio`
+
+Or
+
+```sh
+git clone https://github.com/dashio-connect/python-dashio.git
+cd python-dashio
+pip3 install .
+```
+
+## A Quick Guide
+
+This guide covers the **DashIO** python library. For information on the [***Dash***](https://dashio.io/dashboard) phone app please visit the website.
+
+### Basics
+
+So what is **DashIO**? It is a quick effortless way to connect your IoT device to your phone. It allows easy setup of controls such as Dials, Text Boxes, Maps, Graphs, Notifications..., from your Device. You can define the look and layout of the controls on your phone from your IoT device. There are three methods to connect to your phone tcp, mqtt, dash, and BLE. What's Dash then? Dash is a mqtt server with extra bits added in to allow you to send notifications, share your devices, and save your settings from your phone via the **Dash** app.
+
+Show me some code.
+
+```python
+# Examples/ex01.py
+import dashio
+import random
+import time
+
+device = dashio.Device("aDeviceType", "aDeviceID", "aDeviceName")
+tcp_con = dashio.TCPConnection()
+tcp_con.add_device(device)
+first_dial_control = dashio.Dial("FirstDial")
+device.add_control(first_dial_control)
+
+while True:
+    first_dial_control.dial_value = random.random() * 100
+    time.sleep(5)
+```
+
+This is about the fewest lines of code to get talking to the app. There is a lot happening under the hood to make this work. After the import we create a device with three attributes:
+
+* "aDeviceType": a common name device_type for all IoT devices using this code which is used for device discovery
+* "aDeviceID": a device_ID to uniquely identify this device, preferably a UUID.
+* "aDeviceName": The name of this device, which can be changed at any time.
+
+These attributes describe the device to the app and allow you to distinguish one of your devices from another.
+
+The next two lines create a TCP connection and then add the device to the connection. This device is discoverable by the Dash app. You can also discover your IoT device using a third party Bonjour/Zeroconf discovery tool. The mDNS service will be "DashIO.tcp."
+
+Though this device is discoverable by the app it would be nice to have the DashIO app automatically setup a new DeviceView and place your control on the new DeviceView. To do that we need to add a few more lines of code:
+
+```python
+# Examples/ex02.py
+import dashio
+import random
+import time
+
+device = dashio.Device("aDeviceType", "aDeviceID", "aDeviceName")
+tcp_con = dashio.TCPConnection()
+tcp_con.add_device(device)
+first_dial_control = dashio.Dial("FirstDial", control_position=dashio.ControlPosition(0.24, 0.36, 0.54, 0.26))
+device.add_control(first_dial_control)
+
+dv_dial = dashio.DeviceView("aDeviceViewID", "A Dial")
+dv_dial.add_control(first_dial_control)
+device.add_control(dv_dial)
+
+while True:
+    first_dial_control.dial_value = random.random() * 100
+    time.sleep(5)
+```
+
+First we altered the instantiation of a Dial by including a control_position. This allows us to place the control at a set location. The added lines instantiated a DeviceView control, which we than added the dial control. Finally we added the DeviceView to the device.
+
+The next piece of the puzzle to consider is how do we get data from the DashIO app? Lets add a Knob and connect it to the Dial:
+
+```python
+# Examples/ex03.py
+import dashio
+import time
+
+device = dashio.Device("aDeviceType", "aDeviceID", "aDeviceName")
+tcp_con = dashio.TCPConnection()
+tcp_con.add_device(device)
+first_dial_control = dashio.Dial("FirstDial", control_position=dashio.ControlPosition(0.24, 0.36, 0.54, 0.26))
+device.add_control(first_dial_control)
+
+dv = dashio.DeviceView("aDeviceViewID", "A Dial")
+dv.add_control(first_dial_control)
+device.add_control(dv)
+
+def knob_event_handler(msg):
+    first_dial_control.dial_value = float(msg[3])
+
+aknob = dashio.Knob("aKNB", control_position=dashio.ControlPosition(0.24, 0.14, 0.54, 0.26))
+aknob.add_receive_message_callback += knob_event_handler
+dv.add_control(aknob)
+device.add_control(aknob)
+
+while True:
+    time.sleep(1)
+```
+
+First we added a function that sets the dial value. Next we added a Knob control and added our new function to be called when it receives data from the DashIO app. We also add it to the DeviceView and to the device. Now when the knob in the DashIO app is moved the dial is set to the same value.
+
+### Using the Config64
+
+The **Dash** app can generate a CFG64 text string that defines the controls, the controls layout, and device parameters for the Device. The CFG64 string can be used in a number of ways. If we run the example above and using the **Dash** app to export a layout we can use the layout to setup the device and controls.
+
+```python
+# Examples/ex04.py
+import dashio
+import time
+
+cfg64 = "pVNdr5pAEP0rN/tMjHCrbXnjQ60RxQD1Nmn6wIVVN8IuXZar1vjfOwuLeNWmTfo2OztzZnLmnBPybA+Z339oaLbwbYhOqBTHDCMT"\
+"LfxgbnlIQwmjgrNs6kIyni1sSJWYpj7Njj4NcIbjEuoFr7CG8viATL3f11ARc0xF0+TiN5LgFcF7eGuI43QVZxU0fRxoSBBRz7Oe"\
+"ZpS9wvcWk81WBLEgDJn9njFUNUtWEshRqLX9KPLncpEt288Jncux6zgrYYVjW3dB0D9oaAfYDssYh+4Ap9Cakjgbsyxj+7Ie3PbL"\
+"fFtpyy01tCep2F7gBgB3uBtiQDYnsFz/DGyGnhs0vEajb5GKnCUyT6hgXCBzMBwASaSw0pTjsoRZ+mejpw8/9fSebvTRWUPuVEHM"\
+"rWUTeP5EZUaLr000CZZfmshauU0Qek6kOh1PBe5q9fLuurYVTh15XMEzYG8MNw7JL/gxYK0NJylQUOUUFjMMSTNcs8m0l6ZVfinR"\
+"b0Ryc285w2Y8xbzl9WVLBH4Kc7bD7f9uQ9OO9jjZqY+/tEQ8pmWtteQI3MtF3mN08nLhsKo1kkmbHR4NbP/ukCUrAagFmc/GVWlH"\
+"nQ5KJUDEIs7lxPBnBd1IysGdWl5Nf8FxQspaxIDYHmM5Hd34bEx4KdTC/+UphfHAU7X+SXYhuHHFH512b6tnACkYoaK7q/ILaOMV"\
+"8ysUbzSOHrv1X61VUSKkS9C1y6JO/XYULdpoouzijCfScGnNVIhFVQAAheNoe7ImmkiKZteOSqXl9SbAbxCez78B"
+
+config_dict = dashio.decode_cfg64(cfg64)
+device = dashio.Device("aDeviceType", "aDeviceID", "aDeviceName", cfg_dict=config_dict)
+tcp_con = dashio.TCPConnection()
+tcp_con.add_device(device)
+
+aknob: dashio.Knob = device.get_control(dashio.ControlName.KNOB, "aKNB")
+first_dial_control: dashio.Dial = device.get_control(dashio.ControlName.DIAL, "FirstDial")
+
+def knob_event_handler(msg):
+    aknob.knob_dial_value = float(msg[3])
+    first_dial_control.dial_value = float(msg[3])
+
+aknob.add_receive_message_callback(knob_event_handler)
+
+while True:
+    time.sleep(1)
+```
+
+We've added the cfg64 string. Then decoded it with *dashio.decode_cfg64(cfg64)*. This function returns a dictionary that we can pass into Device so that it can to instantiate and add the controls.

dashio-3.3.2/README.md

@@ -0,0 +1,181 @@
+# DashIO
+
+![Tests](https://github.com/dashio-connect/python-dashio/actions/workflows/tests.yml/badge.svg)
+
+[**DashIO**](http://dashio.io) - It is a quick effortless way to connect your IoT device to your phone, tablet or iPad using the free **Dash** app. It allows easy setup of controls such as Dials, Text Boxes, Charts, Graphs, Notifications..., from your IoT device. You can define the look and layout of the controls on your phone from your IoT device. There are three methods to connect to your phone; Bluetooth Low Energy (BLE), TCP or MQTT.
+
+## Getting Started
+
+For the big picture on **DashIO**, take a look at our website: <a href="https://dashio.io">dashio.io</a>
+
+## Documentation
+
+For all documentation and software guides: <a href="https://dashio.io/documents">dashio.io/documents</a>
+
+For the **DashIO** Python guide: <a href="https://dashio.io/guide-python">dashio.io/guide-python</a>
+
+For the **DashIO** Python library: <a href="https://dashio.io/python-library/">dashio.io/python-library</a>
+
+## Examples
+
+There are plenty of examples in the github repository under the Examples directory.
+
+## Dash IoT Application
+
+The **Dash** app is free and available for both Apple and Android devices. Use it to create beautiful and powerful user interfaces to you IoT devices.
+
+Dashio Phone               |  Dashio Tablet
+:-------------------------:|:-------------------------:
+<img src="https://dashio.io/wp-content/uploads/2020/11/IMG_4154.jpeg" width="150" /> | <img src="https://dashio.io/wp-content/uploads/2020/12/IMG_4203.jpeg" width="450" />
+
+## Requirements
+
+* python3.6 and above
+* paho-mqtt
+* pyzmq
+* python-dateutil
+* zeroconf
+* shortuuid
+
+## Install
+
+`pip3 install dashio`
+
+Or
+
+```sh
+git clone https://github.com/dashio-connect/python-dashio.git
+cd python-dashio
+pip3 install .
+```
+
+## A Quick Guide
+
+This guide covers the **DashIO** python library. For information on the [***Dash***](https://dashio.io/dashboard) phone app please visit the website.
+
+### Basics
+
+So what is **DashIO**? It is a quick effortless way to connect your IoT device to your phone. It allows easy setup of controls such as Dials, Text Boxes, Maps, Graphs, Notifications..., from your Device. You can define the look and layout of the controls on your phone from your IoT device. There are three methods to connect to your phone tcp, mqtt, dash, and BLE. What's Dash then? Dash is a mqtt server with extra bits added in to allow you to send notifications, share your devices, and save your settings from your phone via the **Dash** app.
+
+Show me some code.
+
+```python
+# Examples/ex01.py
+import dashio
+import random
+import time
+
+device = dashio.Device("aDeviceType", "aDeviceID", "aDeviceName")
+tcp_con = dashio.TCPConnection()
+tcp_con.add_device(device)
+first_dial_control = dashio.Dial("FirstDial")
+device.add_control(first_dial_control)
+
+while True:
+    first_dial_control.dial_value = random.random() * 100
+    time.sleep(5)
+```
+
+This is about the fewest lines of code to get talking to the app. There is a lot happening under the hood to make this work. After the import we create a device with three attributes:
+
+* "aDeviceType": a common name device_type for all IoT devices using this code which is used for device discovery
+* "aDeviceID": a device_ID to uniquely identify this device, preferably a UUID.
+* "aDeviceName": The name of this device, which can be changed at any time.
+
+These attributes describe the device to the app and allow you to distinguish one of your devices from another.
+
+The next two lines create a TCP connection and then add the device to the connection. This device is discoverable by the Dash app. You can also discover your IoT device using a third party Bonjour/Zeroconf discovery tool. The mDNS service will be "DashIO.tcp."
+
+Though this device is discoverable by the app it would be nice to have the DashIO app automatically setup a new DeviceView and place your control on the new DeviceView. To do that we need to add a few more lines of code:
+
+```python
+# Examples/ex02.py
+import dashio
+import random
+import time
+
+device = dashio.Device("aDeviceType", "aDeviceID", "aDeviceName")
+tcp_con = dashio.TCPConnection()
+tcp_con.add_device(device)
+first_dial_control = dashio.Dial("FirstDial", control_position=dashio.ControlPosition(0.24, 0.36, 0.54, 0.26))
+device.add_control(first_dial_control)
+
+dv_dial = dashio.DeviceView("aDeviceViewID", "A Dial")
+dv_dial.add_control(first_dial_control)
+device.add_control(dv_dial)
+
+while True:
+    first_dial_control.dial_value = random.random() * 100
+    time.sleep(5)
+```
+
+First we altered the instantiation of a Dial by including a control_position. This allows us to place the control at a set location. The added lines instantiated a DeviceView control, which we than added the dial control. Finally we added the DeviceView to the device.
+
+The next piece of the puzzle to consider is how do we get data from the DashIO app? Lets add a Knob and connect it to the Dial:
+
+```python
+# Examples/ex03.py
+import dashio
+import time
+
+device = dashio.Device("aDeviceType", "aDeviceID", "aDeviceName")
+tcp_con = dashio.TCPConnection()
+tcp_con.add_device(device)
+first_dial_control = dashio.Dial("FirstDial", control_position=dashio.ControlPosition(0.24, 0.36, 0.54, 0.26))
+device.add_control(first_dial_control)
+
+dv = dashio.DeviceView("aDeviceViewID", "A Dial")
+dv.add_control(first_dial_control)
+device.add_control(dv)
+
+def knob_event_handler(msg):
+    first_dial_control.dial_value = float(msg[3])
+
+aknob = dashio.Knob("aKNB", control_position=dashio.ControlPosition(0.24, 0.14, 0.54, 0.26))
+aknob.add_receive_message_callback += knob_event_handler
+dv.add_control(aknob)
+device.add_control(aknob)
+
+while True:
+    time.sleep(1)
+```
+
+First we added a function that sets the dial value. Next we added a Knob control and added our new function to be called when it receives data from the DashIO app. We also add it to the DeviceView and to the device. Now when the knob in the DashIO app is moved the dial is set to the same value.
+
+### Using the Config64
+
+The **Dash** app can generate a CFG64 text string that defines the controls, the controls layout, and device parameters for the Device. The CFG64 string can be used in a number of ways. If we run the example above and using the **Dash** app to export a layout we can use the layout to setup the device and controls.
+
+```python
+# Examples/ex04.py
+import dashio
+import time
+
+cfg64 = "pVNdr5pAEP0rN/tMjHCrbXnjQ60RxQD1Nmn6wIVVN8IuXZar1vjfOwuLeNWmTfo2OztzZnLmnBPybA+Z339oaLbwbYhOqBTHDCMT"\
+"LfxgbnlIQwmjgrNs6kIyni1sSJWYpj7Njj4NcIbjEuoFr7CG8viATL3f11ARc0xF0+TiN5LgFcF7eGuI43QVZxU0fRxoSBBRz7Oe"\
+"ZpS9wvcWk81WBLEgDJn9njFUNUtWEshRqLX9KPLncpEt288Jncux6zgrYYVjW3dB0D9oaAfYDssYh+4Ap9Cakjgbsyxj+7Ie3PbL"\
+"fFtpyy01tCep2F7gBgB3uBtiQDYnsFz/DGyGnhs0vEajb5GKnCUyT6hgXCBzMBwASaSw0pTjsoRZ+mejpw8/9fSebvTRWUPuVEHM"\
+"rWUTeP5EZUaLr000CZZfmshauU0Qek6kOh1PBe5q9fLuurYVTh15XMEzYG8MNw7JL/gxYK0NJylQUOUUFjMMSTNcs8m0l6ZVfinR"\
+"b0Ryc285w2Y8xbzl9WVLBH4Kc7bD7f9uQ9OO9jjZqY+/tEQ8pmWtteQI3MtF3mN08nLhsKo1kkmbHR4NbP/ukCUrAagFmc/GVWlH"\
+"nQ5KJUDEIs7lxPBnBd1IysGdWl5Nf8FxQspaxIDYHmM5Hd34bEx4KdTC/+UphfHAU7X+SXYhuHHFH512b6tnACkYoaK7q/ILaOMV"\
+"8ysUbzSOHrv1X61VUSKkS9C1y6JO/XYULdpoouzijCfScGnNVIhFVQAAheNoe7ImmkiKZteOSqXl9SbAbxCez78B"
+
+config_dict = dashio.decode_cfg64(cfg64)
+device = dashio.Device("aDeviceType", "aDeviceID", "aDeviceName", cfg_dict=config_dict)
+tcp_con = dashio.TCPConnection()
+tcp_con.add_device(device)
+
+aknob: dashio.Knob = device.get_control(dashio.ControlName.KNOB, "aKNB")
+first_dial_control: dashio.Dial = device.get_control(dashio.ControlName.DIAL, "FirstDial")
+
+def knob_event_handler(msg):
+    aknob.knob_dial_value = float(msg[3])
+    first_dial_control.dial_value = float(msg[3])
+
+aknob.add_receive_message_callback(knob_event_handler)
+
+while True:
+    time.sleep(1)
+```
+
+We've added the cfg64 string. Then decoded it with *dashio.decode_cfg64(cfg64)*. This function returns a dictionary that we can pass into Device so that it can to instantiate and add the controls.

{dashio-3.3.0 → dashio-3.3.2}/dashio/dashconnection.py

@@ -317,7 +317,7 @@ class DashConnection(threading.Thread):
         control_type = ""
         while self.running:
             try:
-                socks = dict(poller.poll(50))
+                socks = dict(poller.poll(15))
             except zmq.error.ContextTerminated:
                 break
 

{dashio-3.3.0 → dashio-3.3.2}/dashio/iotcontrol/button.py

@@ -129,7 +129,7 @@ class Button(Control):
         on_color=Color.BLUE,
         off_color=Color.RED,
         text="",
-        control_position=None
+        control_position: ControlPosition = None
     ):
         super().__init__("BTTN", control_id)
         self._cfg_columnar.append(

{dashio-3.3.0 → dashio-3.3.2}/dashio/iotcontrol/chart.py

@@ -29,11 +29,14 @@ from .enums import Color, ChartLineType, ChartXAxisLabelsStyle, TitlePosition
 class ChartLine:
     """ChartLine class
     """
-    def __init__(self, name="", line_type=ChartLineType.LINE, color=Color.BLACK):
+    def __init__(self, name="", line_type=ChartLineType.LINE, color=Color.BLACK, right_axis=False):
         self.name = name.translate(BAD_CHARS)
         self.line_type = line_type
         self.color = color
         self.data = []
+        self.axis_side = 'left'
+        if right_axis:
+            self.axis_side = 'right'
 
     def get_line_data(self):
         """Returns the line data formated for the iotdashboard app
@@ -43,7 +46,7 @@ class ChartLine:
         str
             The formatted line data
         """
-        data_str = f"\t{self.name}\t{self.line_type.value}\t{self.color.value}\t"
+        data_str = f"\t{self.name}\t{self.line_type.value}\t{self.color.value}\t{self.axis_side}\t"
         data_str += "\t".join(map(str, self.data))
         data_str += "\n"
         return data_str
@@ -65,6 +68,9 @@ class ChartConfig(ControlConfig):
         y_axis_min: float,
         y_axis_max: float,
         y_axis_num_bars: int,
+        y_axis_label_rt: str,
+        y_axis_min_rt: float,
+        y_axis_max_rt: float,
         control_position: ControlPosition,
     ) -> None:
         super().__init__(control_id, title, control_position, title_position)
@@ -77,6 +83,9 @@ class ChartConfig(ControlConfig):
         self.cfg["yAxisMin"] = y_axis_min
         self.cfg["yAxisMax"] = y_axis_max
         self.cfg["yAxisNumBars"] = y_axis_num_bars
+        self.cfg["yAxisLabelRt"] = y_axis_label_rt.translate(BAD_CHARS)
+        self.cfg["yAxisMinRt"] = y_axis_min_rt
+        self.cfg["yAxisMaxRt"] = y_axis_max_rt
 
     @classmethod
     def from_dict(cls, cfg_dict: dict):
@@ -104,6 +113,9 @@ class ChartConfig(ControlConfig):
             cfg_dict["yAxisMin"],
             cfg_dict["yAxisMax"],
             cfg_dict["yAxisNumBars"],
+            cfg_dict["yAxisLabelRt"],
+            cfg_dict["yAxisMinRt"],
+            cfg_dict["yAxisMaxRt"],
             ControlPosition(cfg_dict["xPositionRatio"], cfg_dict["yPositionRatio"], cfg_dict["widthRatio"], cfg_dict["heightRatio"])
         )
         tmp_cls.parent_id = cfg_dict["parentID"]
@@ -138,8 +150,11 @@ class Chart(Control):
         x_axis_labels_style=ChartXAxisLabelsStyle.ON,
         y_axis_label="",
         y_axis_min=0.0,
-        y_axis_max=100.0,
+        y_axis_max=1000.0,
         y_axis_num_bars=5,
+        y_axis_label_rt="",
+        y_axis_min_rt=0.0,
+        y_axis_max_rt=1000.0,
         control_position=None,
     ):
         """A Chart Control
@@ -188,6 +203,9 @@ class Chart(Control):
                 y_axis_min,
                 y_axis_max,
                 y_axis_num_bars,
+                y_axis_label_rt,
+                y_axis_min_rt,
+                y_axis_max_rt,
                 control_position
             )
         )
@@ -198,6 +216,8 @@ class Chart(Control):
         self._y_axis_min = y_axis_min
         self._y_axis_max = y_axis_max
         self._y_axis_num_bars = y_axis_num_bars
+        self._y_axis_min_rt = y_axis_min_rt
+        self._y_axis_max_rt = y_axis_max_rt
 
     @property
     def x_axis_min(self):
@@ -224,6 +244,16 @@ class Chart(Control):
         """Returns the Y axis maximum value"""
         return self._y_axis_max
 
+    @property
+    def y_axis_min_rt(self):
+        """Returns the Y axis minimum value right side"""
+        return self._y_axis_min_rt
+
+    @property
+    def y_axis_max_rt(self):
+        """Returns the Y axis maximum value right side"""
+        return self._y_axis_max_rt
+
     @property
     def y_axis_num_bars(self):
         """Returns the y axis number of bars"""
@@ -255,6 +285,9 @@ class Chart(Control):
             cfg_dict["yAxisMin"],
             cfg_dict["yAxisMax"],
             cfg_dict["yAxisNumBars"],
+            cfg_dict.get("yAxisLabelRt", ''),
+            cfg_dict.get("yAxisMinRt", 0.0),
+            cfg_dict.get("yAxisMaxRt", 1000.0),
             ControlPosition(cfg_dict["xPositionRatio"], cfg_dict["yPositionRatio"], cfg_dict["widthRatio"], cfg_dict["heightRatio"])
         )
         tmp_cls.parent_id = cfg_dict["parentID"]

{dashio-3.3.0 → dashio-3.3.2}/dashio/iotcontrol/control.py

@@ -175,6 +175,19 @@ class ControlConfig:
         """
         return self.cfg
 
+    def update_position(self, control_position: ControlPosition):
+        """Updates the controls position from control_position
+
+        Parameters
+        ----------
+        control_position : ControlPosition
+            The position to use to update the control
+        """
+        self.cfg["xPositionRatio"] = control_position.x_position_ratio
+        self.cfg["yPositionRatio"] = control_position.y_position_ratio
+        self.cfg["widthRatio"] = control_position.width_ratio
+        self.cfg["heightRatio"] = control_position.height_ratio
+
     def __init__(
         self,
         control_id: str,
@@ -267,12 +280,11 @@ class Control():
             for cfg in self._cfg_full_page:
                 cfg_list.append(f"\tCFG\t{dashboard_id}\t{self.cntrl_type}\t{cfg.get_cfg_json()}")
         else:
-            logging.debug("Len: %s", len(self._cfg_columnar))
             for control_cfg in self._cfg_columnar:
                 cfg_list.append(f"\tCFG\t{dashboard_id}\t{self.cntrl_type}\t{control_cfg.get_cfg_json()}")
         return cfg_list
 
-    def get_cfg64(self, data) -> dict:
+    def get_cfg64(self, data) -> list:
         """Returns the CFG dict for the control called when the iotdashboard app asks for a CFG
 
         Parameters
@@ -289,7 +301,7 @@ class Control():
         try:
             num_columns = int(data[3])
         except (IndexError, ValueError):
-            return ""
+            return []
         if num_columns >= self._cfg_full_page_no_columns and self._cfg_full_page:
             for cfg in self._cfg_full_page:
                 cfg_list.append(cfg.get_cfg64())
@@ -337,12 +349,6 @@ class Control():
             The type of control to implement
         control_id : str
             An unique control identity string. The control identity string must be a unique string for each control per device
-        title : str, optional
-            Title of the control, by default None
-        control_position : ControlPosition, optional
-            The position of the control on a DeviceView this sets for number of columns = 1, by default None
-        title_position : TitlePosition, optional
-            Position of the title when displayed on the iotdashboard app, by default None
         """
         # Dictionary to store CFG json
         self._cfg_columnar = []

{dashio-3.3.0 → dashio-3.3.2}/dashio/iotcontrol/enums.py

@@ -81,6 +81,8 @@ class Icon(Enum):
     CIRCLE = "Circle"
     SQUARE = "Square"
     TRIANGLE = "Triangle"
+    TICK = "Tick"
+    CROSS = "Cross"
     MAIL = "Mail"
     BOAT = "Boat"
     SAILBOAT = "Sailboat"
@@ -179,6 +181,7 @@ class ButtonState(Enum):
     """Button states"""
     ON = "ON"
     OFF = "OFF"
+    FLASH = "FLASH"
 
 
 class Keyboard(Enum):

{dashio-3.3.0 → dashio-3.3.2}/dashio/iotcontrol/event_log.py

@@ -28,7 +28,7 @@ from ..constants import BAD_CHARS
 from .control import Control, ControlPosition, ControlConfig, _get_title_position
 from .enums import Color, TitlePosition
 from .ring_buffer import RingBuffer
-
+from .event import Event
 
 class EventData:
     """Event log data point
@@ -107,7 +107,8 @@ class EventLog(Control):
         super().__init__("LOG", control_id)
         self._cfg_columnar.append(ControlConfig(control_id, title, control_position, title_position))
 
-        self.message_rx_event = self._get_log_from_timestamp
+        self._message_rx_event = Event()
+        self._message_rx_event += self._get_log_from_timestamp
         self.log = RingBuffer(max_log_entries)
 
     @classmethod

{dashio-3.3.0 → dashio-3.3.2}/dashio/iotcontrol/map.py

@@ -28,7 +28,7 @@ import json
 from ..constants import BAD_CHARS
 from .control import Control, ControlPosition, ControlConfig, _get_title_position
 from .enums import TitlePosition, Color
-
+from .event import Event
 
 class MapLocation:
     """
@@ -164,7 +164,9 @@ class Map(Control):
         self._cfg_columnar.append(ControlConfig(control_id, title, control_position, title_position))
         self.tracks = {}
         self.tracks["DEFAULT"] = self.default_track
-        self.message_rx_event = self._get_tracks_from_timestamp
+
+        self._message_rx_event = Event()
+        self._message_rx_event += self._get_tracks_from_timestamp
 
     @classmethod
     def from_cfg_dict(cls, cfg_dict: dict):