indipyclient 0.0.1__py3-none-any.whl

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/__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/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())