indipyclient 0.0.1__tar.gz

indipyclient-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023,2024 Bernard Czenkusz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

indipyclient-0.0.1/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.1
+Name: indipyclient
+Version: 0.0.1
+Summary: Pure python package, providing a terminal client and a set of classes which can be used to create scripts or clients to control remote instruments using the INDI protocol.
+Keywords: indi,client,astronomy,instrument
+Author-email: Bernard Czenkusz <bernie@skipole.co.uk>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Topic :: Scientific/Engineering :: Astronomy
+Classifier: Topic :: Scientific/Engineering :: Interface Engine/Protocol Translator
+Project-URL: Documentation, https://indipyclient.readthedocs.io
+Project-URL: Source, https://github.com/bernie-skipole/indipyclient
+
+# indipyclient
+INDI terminal client to communicate to an indi service.
+
+This is a pure python package, with no dependencies, providing an INDI client terminal
+
+It also provides a set of classes which can be used to create an INDI client. Either a script, or a GUI implementation could use this to generate the INDI protocol XML, and to create the connection to a port serving INDI drivers.
+
+The client can be called with python3 -m indipyclent.
+
+    usage: python3 -m indipyclient [options]
+
+    INDI terminal client communicating to indi service.
+
+    options:
+      -h, --help            show this help message and exit
+      -p PORT, --port PORT  Port of the indi server (default 7624).
+      --host HOST           Hostname/IP of the indi server (default localhost).
+      -b BLOBS, --blobs BLOBS
+                            Optional folder where BLOB's will be saved.
+      --loglevel LOGLEVEL   Enables logging, value 1, 2 or 3.
+      --logfile LOGFILE     File where logs will be saved
+      --version             show program's version number and exit
+
+    The BLOB's folder can also be set from within the session.
+    Setting loglevel and logfile should only be used for brief
+    diagnostic purposes, the logfile could grow very big.
+    loglevel:1 log vector tags without members or contents,
+    loglevel:2 log vectors and members - but not BLOB contents,
+    loglevel:3 log vectors and all contents
+
+A typical sesssion would look like:
+
+![Terminal screenshot](https://github.com/bernie-skipole/indipyclient/raw/main/image.png)
+
+
+This is a companion package to 'indipydriver' which can be used to create INDI drivers.
+
+INDI - Instrument Neutral Distributed Interface.
+
+See https://en.wikipedia.org/wiki/Instrument_Neutral_Distributed_Interface
+
+The INDI protocol is defined so that drivers should operate with any INDI client.
+
+The protocol defines the format of the data sent, such as light, number, text, switch or BLOB (Binary Large Object) and the client can send commands to control the instrument.  The client can be general purpose, taking the format of switches, numbers etc., from the protocol.
+
+INDI is often used with astronomical instruments, but is a general purpose protocol which can be used for any instrument control providing drivers are available.
+
+Further documentation is available at:
+
+https://indipyclient.readthedocs.io
+

indipyclient-0.0.1/README.md

@@ -0,0 +1,50 @@
+# indipyclient
+INDI terminal client to communicate to an indi service.
+
+This is a pure python package, with no dependencies, providing an INDI client terminal
+
+It also provides a set of classes which can be used to create an INDI client. Either a script, or a GUI implementation could use this to generate the INDI protocol XML, and to create the connection to a port serving INDI drivers.
+
+The client can be called with python3 -m indipyclent.
+
+    usage: python3 -m indipyclient [options]
+
+    INDI terminal client communicating to indi service.
+
+    options:
+      -h, --help            show this help message and exit
+      -p PORT, --port PORT  Port of the indi server (default 7624).
+      --host HOST           Hostname/IP of the indi server (default localhost).
+      -b BLOBS, --blobs BLOBS
+                            Optional folder where BLOB's will be saved.
+      --loglevel LOGLEVEL   Enables logging, value 1, 2 or 3.
+      --logfile LOGFILE     File where logs will be saved
+      --version             show program's version number and exit
+
+    The BLOB's folder can also be set from within the session.
+    Setting loglevel and logfile should only be used for brief
+    diagnostic purposes, the logfile could grow very big.
+    loglevel:1 log vector tags without members or contents,
+    loglevel:2 log vectors and members - but not BLOB contents,
+    loglevel:3 log vectors and all contents
+
+A typical sesssion would look like:
+
+![Terminal screenshot](https://github.com/bernie-skipole/indipyclient/raw/main/image.png)
+
+
+This is a companion package to 'indipydriver' which can be used to create INDI drivers.
+
+INDI - Instrument Neutral Distributed Interface.
+
+See https://en.wikipedia.org/wiki/Instrument_Neutral_Distributed_Interface
+
+The INDI protocol is defined so that drivers should operate with any INDI client.
+
+The protocol defines the format of the data sent, such as light, number, text, switch or BLOB (Binary Large Object) and the client can send commands to control the instrument.  The client can be general purpose, taking the format of switches, numbers etc., from the protocol.
+
+INDI is often used with astronomical instruments, but is a general purpose protocol which can be used for any instrument control providing drivers are available.
+
+Further documentation is available at:
+
+https://indipyclient.readthedocs.io

indipyclient-0.0.1/indipyclient/__init__.py

@@ -0,0 +1,5 @@
+from .ipyclient import IPyClient
+from .events import (delProperty, defSwitchVector, defTextVector, defNumberVector, defLightVector, defBLOBVector,
+                     setSwitchVector, setTextVector, setNumberVector, setLightVector, setBLOBVector, Message, VectorTimeOut)
+
+version = "0.0.1"

indipyclient-0.0.1/indipyclient/__main__.py

@@ -0,0 +1,101 @@
+
+"""Usage is
+
+python3 -m indipyclient
+
+"""
+
+
+import os, sys, argparse, asyncio, collections, contextlib, pathlib
+
+
+from . import version
+
+from .console.consoleclient import ConsoleClient, ConsoleControl
+
+from .console.widgets import ERRORDATA
+
+
+async def runclient(client, control):
+    try:
+        t1 = asyncio.create_task(client.asyncrun())
+        t2 = asyncio.create_task(control.asyncrun())
+        await asyncio.gather(t1, t2)
+    except Exception:
+         t1.cancel()
+         t2.cancel()
+    # wait for tasks to be done
+    while (not t1.done()) and (not t2.done()):
+        await asyncio.sleep(0)
+
+
+def main():
+    """The main routine."""
+
+    parser = argparse.ArgumentParser(usage="python3 -m indipyclient [options]",
+                                     description="INDI terminal client communicating to indi service.",
+                                     epilog="""The BLOB's folder can also be set from within the session.
+Setting loglevel and logfile should only be used for brief
+diagnostic purposes, the logfile could grow very big.
+loglevel:1 log vector tags without members or contents,
+loglevel:2 log vectors and members - but not BLOB contents,
+loglevel:3 log vectors and all contents
+""")
+    parser.add_argument("-p", "--port", type=int, default=7624, help="Port of the indi server (default 7624).")
+    parser.add_argument("--host", default="localhost", help="Hostname/IP of the indi server (default localhost).")
+    parser.add_argument("-b", "--blobs", help="Optional folder where BLOB's will be saved.")
+    parser.add_argument("--loglevel", help="Enables logging, value 1, 2 or 3.")
+    parser.add_argument("--logfile", help="File where logs will be saved")
+
+    parser.add_argument("--version", action="version", version=version)
+    args = parser.parse_args()
+
+    eventque = collections.deque(maxlen=4)
+
+    if args.blobs:
+        try:
+            blobfolder = pathlib.Path(args.blobs).expanduser().resolve()
+        except Exception:
+            print("Error: If given, the BLOB's folder should be an existing directory")
+            return 1
+        else:
+            if not blobfolder.is_dir():
+                print("Error: If given, the BLOB's folder should be an existing directory")
+                return 1
+    else:
+        blobfolder = None
+
+    # On receiving an event, the client appends it into eventque
+    client = ConsoleClient(indihost=args.host, indiport=args.port, eventque=eventque)
+
+    if args.loglevel and args.logfile:
+        try:
+            loglevel = int(args.loglevel)
+            if loglevel not in (1,2,3):
+                print("Error: If given, the loglevel should be 1, 2 or 3")
+                return 1
+        except:
+            print("Error: If given, the loglevel should be 1, 2 or 3")
+            return 1
+        client.setlogging(loglevel, args.logfile)
+
+    # Monitors eventque and acts on the events, creates the console screens
+    control = ConsoleControl(client, blobfolder=blobfolder)
+
+    asyncio.run(runclient(client, control))
+
+    # ERRORDATA is a list of any traceback.TracebackException() objects
+    # which records exceptions which may have occurred. They are printed
+    # here, after the console has closed down to avoid messing up
+    # the console formatting
+
+    if ERRORDATA:
+        for errortrace in ERRORDATA:
+            print("".join(errortrace.format()))
+            print("------------------")
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

indipyclient-0.0.1/indipyclient/console/consoleclient.py

@@ -0,0 +1,438 @@
+
+import asyncio, sys
+
+import curses
+
+from traceback import TracebackException as TBE
+
+from ..ipyclient import IPyClient
+from ..events import (delProperty, defSwitchVector, defTextVector, defNumberVector, defLightVector, defBLOBVector,
+                     setSwitchVector, setTextVector, setNumberVector, setLightVector, setBLOBVector, Message, VectorTimeOut)
+
+from . import windows
+from . import widgets
+
+# set limit to terminal size
+MINROWS = 22
+MINCOLS = 78
+
+
+class ConsoleClient(IPyClient):
+
+    """Overrides IPyClient
+       On receiving an event, appends it into eventque
+       Which will pass the received event into ConsoleControl"""
+
+    async def rxevent(self, event):
+        """Add event to eventque"""
+        self.clientdata['eventque'].appendleft(event)
+
+
+class ConsoleControl:
+
+    def __init__(self, client, blobfolder=None):
+        """client is an instance of ConsoleClient
+           If given, blobfolder will be the folder where BLOBs will be saved"""
+        self.client = client
+        self.blobfolder = blobfolder
+        if self.blobfolder:
+            self.blobenabled = True
+        else:
+            self.blobenabled = False
+
+        # this is populated with events as they are received
+        self.eventque = self.client.clientdata['eventque']
+
+        # set up screen
+        self.stdscr = curses.initscr()
+        curses.start_color()
+        curses.noecho()
+        curses.cbreak()
+        curses.curs_set(0)
+        self.stdscr.keypad(True)
+        curses.mousemask(curses.BUTTON1_RELEASED)
+
+        self.maxrows, self.maxcols = self.stdscr.getmaxyx()
+
+        if self.maxrows < MINROWS or self.maxcols < MINCOLS:
+            curses.nocbreak()
+            self.stdscr.keypad(False)
+            curses.curs_set(1)
+            curses.echo()
+            curses.endwin()
+            print("Terminal too small! Try 80 columns x 24 rows")
+            sys.exit(1)
+
+
+        # Idle, OK, Busy or Alert.
+        # gray, green, yellow and red
+
+        curses.init_pair(1, curses.COLOR_BLACK, curses.COLOR_GREEN)
+        curses.init_pair(2, curses.COLOR_BLACK, curses.COLOR_YELLOW)
+        curses.init_pair(3, curses.COLOR_BLACK, curses.COLOR_RED)
+
+        # this keeps track of which screen is being displayed,
+        # initially start with the messages screen
+        self.screen = windows.MessagesScreen(self.stdscr, self)
+        self.screen.show()
+
+        # this is set to True, to shut down the client
+        self._shutdown = False
+        # and shutdown routine sets this to True to stop coroutines
+        self.stop = False
+        # these are set to True when asyncrun is finished
+        self.updatescreenstopped = False
+        self.getinputstopped = False
+
+        # list of known device names, this is needed to send
+        # BLOB's enabled
+        self.devicenames = []
+
+        # BLOBfiles, is a dictionary of {(devicename,vectorname,membername):filepath}
+        self.BLOBfiles = {}
+
+
+
+    def color(self, state):
+        "Returns curses.color_pair given a state"
+        if not curses.has_colors():
+            return curses.color_pair(0)
+        state = state.lower()
+        if state == "ok":
+            return curses.color_pair(1)
+        elif state == "busy":
+            return curses.color_pair(2)
+        elif state == "alert":
+            return curses.color_pair(3)
+        return curses.color_pair(0)
+
+    @property
+    def connected(self):
+        return self.client.connected
+
+
+    def shutdown(self):
+        self._shutdown = True
+
+
+    async def _checkshutdown(self):
+        "If self._shutdown becomes True, shutdown"
+        while not self._shutdown:
+            await asyncio.sleep(0)
+        await self.client.report("Shutting down client - please wait")
+        self.client.shutdown()
+        while not self.client.stopped:
+            await asyncio.sleep(0)
+        # now stop co-routines
+        self.stop = True
+        while (not self.updatescreenstopped) and (not self.getinputstopped):
+            await asyncio.sleep(0)
+        # async tasks finished, clear up the terminal
+        curses.nocbreak()
+        self.stdscr.keypad(False)
+        curses.curs_set(1)
+        curses.echo()
+        curses.endwin()
+
+
+    async def updatescreen(self):
+        "Update while events are being received"
+        try:
+            while not self.stop:
+                await asyncio.sleep(0)
+                if isinstance(self.screen, windows.TooSmall):
+                    continue
+                if not self.connected:
+                    if isinstance(self.screen, windows.MessagesScreen):
+                        # set disconnected status and focus on the quit button
+                        if not self.screen.disconnectionflag:
+                            self.devicenames.clear()
+                            self.screen.showunconnected() # sets disconnectionflag
+                    else:
+                        # when not connected, show messages screen
+                        self.screen.close("Messages")
+                    continue
+                # act when an event is received
+                try:
+                    event = self.eventque.pop()
+                except IndexError:
+                    # no event received, so do not update screen
+                    continue
+                if isinstance(event, VectorTimeOut) and (event.devicename == self.screen.devicename):
+                    if isinstance(self.screen, windows.ChooseVectorScreen):
+                        self.screen.timeout(event)
+                        continue
+                    if isinstance(self.screen, windows.VectorScreen) and (self.screen.vectorname == event.vectorname):
+                        self.screen.timeout(event)
+                        continue
+                if hasattr(event, 'devicename'):
+                    # if this is a new device, update it with BLOB status
+                    if event.devicename and (event.devicename not in self.devicenames):
+                        if event.devicename in self.client:
+                            device = self.client[event.devicename]
+                            if device.enable:
+                                # new devicename
+                                self.devicenames.append(event.devicename)
+                                if self.blobenabled:
+                                    self.client.send_enableBLOB('Also', event.devicename)
+                                else:
+                                    self.client.send_enableBLOB('Never', event.devicename)
+                # If the event is a received BLOB, save it to the BLOB Folder
+                if isinstance(event, setBLOBVector):
+                    # make filename from timestamp
+                    timestampstring = event.timestamp.strftime('%Y%m%d_%H_%M_%S')
+                    for membername, membervalue in event.items():
+                        sizeformat = event.sizeformat[membername]
+                        filename =  membername + "_" + timestampstring + sizeformat[1]
+                        counter = 0
+                        while True:
+                            filepath = self.blobfolder / filename
+                            if filepath.exists():
+                                # append a digit to the filename
+                                counter += 1
+                                filename = membername + "_" + timestampstring + "_" + str(counter) + sizeformat[1]
+                            else:
+                                # filepath does not exist, so a new file with this filepath can be created
+                                break
+                        filepath.write_bytes(membervalue)
+                        # record the filepath
+                        self.BLOBfiles[(event.devicename, event.vectorname, membername)] = filepath
+                if isinstance(self.screen, windows.MessagesScreen):
+                    self.screen.update(event)
+                    continue
+                if isinstance(self.screen, windows.DevicesScreen):
+                    self.screen.update(event)
+                    continue
+                if isinstance(self.screen, windows.EnableBLOBsScreen):
+                    self.screen.update(event)
+                    continue
+                if event.devicename != self.screen.devicename:
+                    # the remaining screens are only affected if the event devicename
+                    # is the device they refer to
+                    continue
+                if isinstance(event, delProperty):
+                    if event.vectorname is None:
+                        # the whole device is disabled,
+                        if event.devicename and (event.devicename in self.devicenames):
+                            self.devicenames.remove(event.devicename)
+                        # show devicesscreen
+                        self.screen.close("Devices")
+                        continue
+                    if isinstance(self.screen, windows.ChooseVectorScreen):
+                        # one vector has been disabled, update the ChooseVectorScreen
+                        self.screen.update(event)
+                        continue
+                    if isinstance(self.screen, windows.VectorScreen) and (self.screen.vectorname == event.vectorname):
+                        # This vector has been disabled, show ChooseVectorScreen
+                        self.screen.close("Vectors")
+                        continue
+                    continue
+                # so its not a delete property
+                if isinstance(self.screen, windows.ChooseVectorScreen):
+                    self.screen.update(event)
+                    continue
+                if isinstance(self.screen, windows.VectorScreen) and (self.screen.vectorname == event.vectorname):
+                    # The event refers to this vector
+                    self.screen.update(event)
+
+        except asyncio.CancelledError:
+            self._shutdown = True
+            raise
+        except Exception as e:
+            widgets.ERRORDATA.append(TBE.from_exception(e))
+            self._shutdown = True
+        finally:
+            self.updatescreenstopped = True
+
+
+    async def getinput(self):
+        try:
+            while not self.stop:
+                await asyncio.sleep(0)
+                if isinstance(self.screen, windows.TooSmall):
+                    result = await self.screen.inputs()
+                    if result == "Resize":
+                        self.maxrows, self.maxcols = self.stdscr.getmaxyx()
+                        if self.maxrows < 10 or self.maxcols < 40:
+                            self.shutdown()
+                            continue
+                        if self.maxrows < MINROWS or self.maxcols < MINCOLS:
+                            self.screen = windows.TooSmall(self.stdscr, self)
+                            self.screen.show()
+                            continue
+                        # so resize has increased to proper size
+                        self.screen = windows.MessagesScreen(self.stdscr, self)
+                        self.screen.show()
+                        continue
+                    if result == "Quit":
+                        self._shutdown = True
+                        break
+
+                if isinstance(self.screen, windows.MessagesScreen):
+                    result = await self.screen.inputs()
+                    if result == "Resize":
+                        self.maxrows, self.maxcols = self.stdscr.getmaxyx()
+                        if self.maxrows < 16 or self.maxcols < 40:
+                            self.shutdown()
+                            continue
+                        if self.maxrows < MINROWS or self.maxcols < MINCOLS:
+                            self.screen = windows.TooSmall(self.stdscr, self)
+                            self.screen.show()
+                            continue
+                        self.screen = windows.MessagesScreen(self.stdscr, self)
+                        self.screen.show()
+                        continue
+                    if result == "Quit":
+                        self._shutdown = True
+                        break
+                    if result == "Devices":
+                        self.screen = windows.DevicesScreen(self.stdscr, self)
+                        self.screen.show()
+                        continue
+                    if result == "EnableBLOBs":
+                        self.screen = windows.EnableBLOBsScreen(self.stdscr, self)
+                        self.screen.show()
+                        continue
+                if isinstance(self.screen, windows.EnableBLOBsScreen):
+                    result = await self.screen.inputs()
+                    if result == "Resize":
+                        self.maxrows, self.maxcols = self.stdscr.getmaxyx()
+                        if self.maxrows < 16 or self.maxcols < 40:
+                            self.shutdown()
+                            continue
+                        if self.maxrows < MINROWS or self.maxcols < MINCOLS:
+                            self.screen = windows.TooSmall(self.stdscr, self)
+                            self.screen.show()
+                            continue
+                        self.screen = windows.EnableBLOBsScreen(self.stdscr, self)
+                        self.screen.show()
+                        continue
+                    if result == "Quit":
+                        self._shutdown = True
+                        break
+                    if result == "Messages":
+                        self.screen = windows.MessagesScreen(self.stdscr, self)
+                        self.screen.show()
+                        continue
+                    if result == "Devices":
+                        self.screen = windows.DevicesScreen(self.stdscr, self)
+                        self.screen.show()
+                        continue
+                if isinstance(self.screen, windows.DevicesScreen):
+                    result = await self.screen.inputs()
+                    if result == "Resize":
+                        self.maxrows, self.maxcols = self.stdscr.getmaxyx()
+                        if self.maxrows < 16 or self.maxcols < 40:
+                            self.shutdown()
+                            continue
+                        if self.maxrows < MINROWS or self.maxcols < MINCOLS:
+                            self.screen = windows.TooSmall(self.stdscr, self)
+                            self.screen.show()
+                            continue
+                        self.screen = windows.DevicesScreen(self.stdscr, self)
+                        self.screen.show()
+                        continue
+                    if result == "Quit":
+                        self._shutdown = True
+                        break
+                    if result == "Messages":
+                        self.screen = windows.MessagesScreen(self.stdscr, self)
+                        self.screen.show()
+                        continue
+                    devices = {devicename.lower():device for devicename, device in self.client.items() if device.enable}
+                    if result in devices:
+                        devicename = devices[result].devicename
+                        self.screen = windows.ChooseVectorScreen(self.stdscr, self, devicename)
+                        self.screen.show()
+                        continue
+                if isinstance(self.screen, windows.ChooseVectorScreen):
+                    result = await self.screen.inputs()
+                    if result == "Resize":
+                        self.maxrows, self.maxcols = self.stdscr.getmaxyx()
+                        if self.maxrows < 16 or self.maxcols < 40:
+                            self.shutdown()
+                            continue
+                        if self.maxrows < MINROWS or self.maxcols < MINCOLS:
+                            self.screen = windows.TooSmall(self.stdscr, self)
+                            self.screen.show()
+                            continue
+                        self.screen = windows.ChooseVectorScreen(self.stdscr, self, self.screen.devicename, group=self.screen.groupwin.active)
+                        self.screen.show()
+                        continue
+                    if result == "Quit":
+                        self._shutdown = True
+                        break
+                    if result == "Messages":
+                        self.screen = windows.MessagesScreen(self.stdscr, self)
+                        self.screen.show()
+                        continue
+                    if result == "Devices":
+                        self.screen = windows.DevicesScreen(self.stdscr, self)
+                        self.screen.show()
+                        continue
+                    if result == "Vectors":
+                        # get device, vector and show VectorScreen
+                        self.screen = windows.VectorScreen(self.stdscr, self, self.screen.devicename, self.screen.vectorname)
+                        self.screen.show()
+                        continue
+                if isinstance(self.screen, windows.VectorScreen):
+                    result = await self.screen.inputs()
+                    if result == "Resize":
+                        self.maxrows, self.maxcols = self.stdscr.getmaxyx()
+                        if self.maxrows < 16 or self.maxcols < 40:
+                            self.shutdown()
+                            continue
+                        if self.maxrows < MINROWS or self.maxcols < MINCOLS:
+                            self.screen = windows.TooSmall(self.stdscr, self)
+                            self.screen.show()
+                            continue
+                        self.screen = windows.VectorScreen(self.stdscr, self, self.screen.devicename, self.screen.vectorname)
+                        self.screen.show()
+                        continue
+                    if result == "Quit":
+                        self._shutdown = True
+                        break
+                    if result == "Messages":
+                        self.screen = windows.MessagesScreen(self.stdscr, self)
+                        self.screen.show()
+                        continue
+                    if result == "Devices":
+                        self.screen = windows.DevicesScreen(self.stdscr, self)
+                        self.screen.show()
+                        continue
+                    if result == "Vectors":
+                        self.screen = windows.ChooseVectorScreen(self.stdscr, self, self.screen.devicename, group=self.screen.vector.group)
+                        self.screen.show()
+                        continue
+
+        except asyncio.CancelledError:
+            self._shutdown = True
+            raise
+        except Exception as e:
+            widgets.ERRORDATA.append(TBE.from_exception(e))
+            self._shutdown = True
+        finally:
+            self.getinputstopped = True
+
+
+    def send_enableBLOB(self):
+        "Sends Also to enable blobs for all devices"
+        if not self.blobenabled:
+            return
+        for devicename,device in self.client.items():
+            if device.enable:
+                self.client.send_enableBLOB('Also', devicename)
+
+    def send_disableBLOB(self):
+        "Sends Never to disable blobs for all devices"
+        if self.blobenabled:
+            return
+        for devicename,device in self.client.items():
+            if device.enable:
+                self.client.send_enableBLOB('Never', devicename)
+
+
+    async def asyncrun(self):
+        """Gathers tasks to be run simultaneously"""
+        self.stop = False
+        await asyncio.gather(self.updatescreen(), self.getinput(), self._checkshutdown())