quarchpy 2.2.1.dev6__py2.py3-none-any.whl → 2.2.3__py2.py3-none-any.whl

quarchpy/device/quarchQPS.py.bak

@@ -0,0 +1,398 @@
+from quarchpy.device import quarchDevice
+from quarchpy.qps import toQpsTimeStamp
+from quarchpy.utilities.Version import Version
+from quarchpy.user_interface.user_interface import requestDialog
+import os, time, datetime, sys, logging
+
+if sys.version_info[0] < 3:
+    from StringIO import StringIO
+else:
+    from io import StringIO
+
+current_milli_time = lambda: int(round(time.time() * 1000))
+current_second_time = lambda: int(round(time.time()))
+
+
+# Using standard Unix time,  milliseconds since the epoch (midnight 1 January 1970 UTC)
+# Should avoid issues with time zones and summer time correction but the local and host
+# clocks should still be synchronised
+def qpsNowStr():
+    return current_milli_time()  # datetime supports microseconds
+
+
+class quarchQPS(quarchDevice):
+    def __init__(self, quarchDevice):
+        self.quarchDevice = quarchDevice
+        self.ConType = quarchDevice.ConType
+        self.ConString = quarchDevice.ConString
+
+        self.connectionObj = quarchDevice.connectionObj
+        self.IP_address = quarchDevice.connectionObj.qps.host
+        self.port_number = quarchDevice.connectionObj.qps.port
+
+    def startStream(self, directory, unserInput=True):
+        """
+        directory - str - desired stream dir
+        unserInput=True - if a failure occurs userInput=True allows user to rectify problem with user input. set to False if user interaction is not available (automating).
+        """
+        #time.sleep(1)  # TODO remove this sleep once script->QPS timeing issue resolved. This works fine in the meantime
+        return quarchStream(self.quarchDevice, directory, unserInput)
+
+
+class quarchStream:
+    def __init__(self, quarchQPS, directory, unserInput=True):
+        self.connectionObj = quarchQPS.connectionObj
+        self.IP_address = quarchQPS.connectionObj.qps.host
+        self.port_number = quarchQPS.connectionObj.qps.port
+        self.ConString = quarchQPS.ConString
+        self.ConType = quarchQPS.ConType
+        #time.sleep(1)
+        response = self.startQPSStream(directory)
+        if not "fail:" in response.lower():
+            return
+        else:
+            if unserInput is False:
+                raise Exception(response)
+            else:
+                self.failCheck(response)
+
+    def startQPSStream(self, newDirectory):
+        '''STARTS the stream '''
+        response = self.connectionObj.qps.sendCmdVerbose("$start stream \"" + str(newDirectory) + "\"")
+        if "Error" in response:
+            response = self.connectionObj.qps.sendCmdVerbose("$start stream " + str(newDirectory))
+        return response
+
+    def failCheck(self, response):
+        ''' handles failed starting of stream that requires input from user to fix.'''
+        while "fail:" in response.lower():
+            if "Fail: Directory already exists" in response:
+                newDir = requestDialog(message=response+"  Please enter a new file name:")
+                response = self.startQPSStream(newDir)
+            else:  # If its a failure we don't know how to handle.
+                raise Exception(response)
+        return response
+
+    def get_stats(self, format="df"):
+        """
+                      Returns the QPS annotation statistics grid information as a pandas dataframe object
+
+                                  Returns
+                                  -------
+                                  df = : dataframe
+                                      The response text from QPS. If successful "ok. Saving stats to : file_name" otherwise returns the exception thrown
+        """
+        command_response = self.connectionObj.qps.sendCmdVerbose("$get stats", timeout=60).strip()
+        if command_response.startswith("Fail"):
+            raise Exception(command_response)
+
+        if format == "df":
+            try:
+                import warnings
+                import pandas as pd
+                warnings.simplefilter(action='ignore', category=FutureWarning)
+            except Exception as e:
+                logging.error(e)
+                logging.warning("pandas not imported correctly. Continuing")
+            pd.set_option('display.max_columns', None)
+            pd.set_option('display.width', 1024)
+            test_data = StringIO(command_response)
+
+            # pandas.read_csv() replaced error_bad_lines with on_bad_lines from v1.3.0
+            if Version.is_v1_ge_v2(pd.__version__, "1.3.0"):
+                retVal = pd.read_csv(test_data, sep=",", header=[0, 1], on_bad_lines="skip")
+            else:
+                retVal = pd.read_csv(test_data, sep=",", header=[0, 1], error_bad_lines=False)
+        elif format == "list":
+            retVal = []
+            for line in command_response.replace("\r\n", "\n").split("\n"):
+                row = []
+                for element in line.split(","):
+                    row.append(element)
+                retVal.append(row)
+
+        return retVal
+
+    def stats_to_CSV(self, file_name=""):
+        """
+        Saves the statistics grid to a csv file
+
+                    Parameters
+                    ----------
+                    file-name= : str, optional
+                        The absolute path of the file you would like to save the csv to. If left empty then a filename will be give.
+                        Default location is the path of the executable.
+                    Returns
+                    -------
+                    command_response : str or None
+
+                        The response text from QPS. If successful "ok. Saving stats to : file_name" otherwise returns the exception thrown
+        """
+        command_response = self.connectionObj.qps.sendCmdVerbose("$stats to csv \"" + file_name + "\"", timeout=60)
+        if command_response.startswith("Fail"):
+            raise Exception(command_response)
+        return command_response
+
+    def get_custom_stats_range(self, start_time, end_time):
+        """
+                      Returns the QPS statistics information over a specific time ignoring any set annotations.
+
+                                Parameters
+                                ----------
+                                start_time = : str
+                                    The time in seconds you would like the stats to start this can be in integer or string format.
+                                    or using the following format to specify daysDhours:minutes:seconds.milliseconds
+                                    xxxDxx:xx:xx.xxxx
+                                end_time = : str
+                                    The time in seconds you would like the stats to stop this can be in integer or string format
+                                    or using the following format to specify daysDhours:minutes:seconds.milliseconds
+                                    xxxDxx:xx:xx.xxxx
+                                Returns
+                                -------
+                                df = : dataframe
+                                    The response text from QPS. If successful "ok. Saving stats to : file_name" otherwise returns the exception thrown
+        """
+        try:
+            import warnings
+            import pandas as pd
+            warnings.simplefilter(action='ignore', category=FutureWarning)
+        except:
+            logging.warning("pandas not imported correctly")
+        command_response = self.connectionObj.qps.sendCmdVerbose(
+            "$get custom stats range " + str(start_time) + " " + str(end_time), timeout=60)
+        if command_response.startswith("Fail"):
+            raise Exception(command_response)
+        test_data = StringIO(command_response)
+        try:
+            pd.set_option('display.max_columns', None)
+            pd.set_option('display.width', 1024)
+            # df = pd.read_csv(test_data, sep=",", header=[0,1])
+            # pandas.read_csv() replaced error_bad_lines with on_bad_lines from v1.3.0
+            if Version.is_v1_ge_v2(pd.__version__, "1.3.0"):
+                df = pd.read_csv(test_data, sep=",", header=[0, 1], on_bad_lines="skip")
+            else:
+                df = pd.read_csv(test_data, sep=",", header=[0, 1], error_bad_lines=False)
+        except Exception as e:
+            logging.error("Unable to create pandas data frame from command response :" + str(command_response))
+            raise e
+        return df
+
+    def takeSnapshot(self):
+        """
+                      Triggers QPS take snapshot function and saves it in the streams directory.
+        """
+        command_response = self.connectionObj.qps.sendCmdVerbose("$take snapshot")
+        if command_response.startswith("Fail"):
+            raise Exception(command_response)
+        return (command_response)
+
+    def getStreamState(self):
+        """
+                      Askes QPS for the stream status.
+                      QPS stream state != Module stream state.
+                      This is different from "rec stream?" cmd to the module as it will return "streaming" when the module is nolonger streaming but QPS is still receiveing stream data from the module.
+                      ei the module has stopped streaming but is emptying the stream buffer.
+        """
+        command_response = self.connectionObj.qps.sendCmdVerbose("$stream state")
+        if command_response.startswith("Fail"):
+            raise Exception(command_response)
+        return (command_response)
+
+    def addAnnotation(self, title, annotationTime=0, extraText="", yPos="", titleColor="", annotationColor="",
+                      annotationType="", annotationGroup=""):
+        """
+                    Adds a custom annotation to stream with given parameters.
+
+                    Parameters
+                    ----------
+                    title= : str
+                        The title appears next to the annotation in the stream
+                    extraText= : str, optional
+                        The additional text that can be viewed when selecting the annotation
+                    yPos : str, optional
+                        The percetange of how high up the screen the annotation should appear 0 is the bottom and 100 the top
+                    titleColor : str, optional
+                        The color of the text next to the annotation in hex format 000000 to FFFFFF
+                    annotationColor : str, optional
+                        The color of the annotation marker in hex format 000000 to FFFFFF
+                    annotationGroup : str, optional
+                        The group the annotation belongs to
+                    annotationTime : int, optional
+                        The time in milliseconds after the start of the stream at which the annotation should be placed. 0 will plot the annotation live at the most recent sample
+
+                    Returns
+                    -------
+                    command_response : str or None
+
+                        The response text from QPS. "ok" if annotation successfully added
+            """
+        annotationTime = str(annotationTime)
+        annotationType = annotationType.lower()
+        if annotationType == "" or annotationType == "annotation":
+            annotationType = "annotate"
+        elif annotationType == "comment":
+            pass  # already in the correct format for command
+        else:
+            retString = "Fail annotationType must be 'annotation' or 'comment'"
+            logging.warning(retString)
+            return retString
+
+        # If the function has already been passed the XML string to give to QPS
+        if ("<<" in title.replace(" ", "")):
+            annotationString = str(title)
+        else:
+            annotationString = "<"
+
+            if annotationTime == "0":
+                # Use current time
+                annotationTime = qpsNowStr()
+            elif (annotationTime.startswith("e")):
+                pass
+            else:
+                # Convert timestamp to QPS format
+                # annotationTime = toQpsTimeStamp(annotationTime)
+                annotationTime = str(annotationTime)
+
+            if title != "":
+                annotationString += "<text>" + str(title) + "</text>"
+            if extraText != "":
+                annotationString += "<extraText>" + str(extraText) + "</extraText>"
+            if yPos != "":
+                annotationString += "<yPos>" + str(yPos) + "</yPos>"
+            if titleColor != "":
+                annotationString += "<textColor>" + str(titleColor) + "</textColor>"
+            if annotationColor != "":
+                annotationString += "<color>" + str(annotationColor) + "</color>"
+            if annotationGroup != "":
+                annotationString += "<userType>" + str(annotationGroup) + "</userType>"
+            annotationString += ">"
+
+        # command is sent on newline so \n needs to be chnaged to \\n which is changed back just before printing in qps.
+        annotationString = annotationString.replace("\n", "\\n")
+        logging.debug("Time sending to QPS:" + str(annotationTime))
+        return self.connectionObj.qps.sendCmdVerbose(
+            "$" + annotationType + " " + str(annotationTime) + " " + annotationString)
+
+    def addComment(self, title, commentTime=0, extraText="", yPos="", titleColor="", commentColor="", annotationType="",
+                   annotationGroup=""):
+        # Comments are just annotations that do not affect the statistics grid.
+        # This function was kept to be backwards compatible and is a simple pass through to add annotation.
+        if annotationType == "":
+            annotationType = "comment"
+        return self.addAnnotation(title=title, annotationTime=commentTime, extraText=extraText, yPos=yPos,
+                                  titleColor=titleColor, annotationColor=commentColor, annotationType=annotationType,
+                                  annotationGroup=annotationGroup)
+
+    def saveCSV(self, filePath, linesPerFile=None, cr=None, delimiter=None, timeout=60):
+        """
+            Saves the stream to csv file at specified location
+
+            Parameters
+            ----------
+            filePath= : str
+                The file path that ou would like the CSV file saved to.
+            linesPerFile= : str, optional
+                    The number of lines per CSV file. Can be any int number or "all"
+            cr : bool, optional
+                Whether the end of line terminator should include a carriage return.
+            delimiter : str, optional
+                The delimiter to be used by the csv file.
+            timeout : str, otptional
+                The timeout to wait for a response from QPS
+
+            Returns
+            -------
+            command_response : str or None
+                The response text from QPS. "ok" if command is successful or the stack trace if exception thrown
+        """
+        args = ""
+
+        if linesPerFile != None:
+            args += " -l" + str(linesPerFile)
+        if cr != None:
+            if cr is True:
+                args += " -cyes"
+            elif cr is False:
+                args += " -cno"
+        if delimiter != None:
+            args += " -s" + delimiter
+
+        # , filePath, linesPerFile, cr, delimiter
+        return self.connectionObj.qps.sendCmdVerbose("$save csv \"" + filePath + "\" " + args, timeout=timeout)
+
+    def createChannel(self, channelName, channelGroup, baseUnits, usePrefix):
+        # Conditions to convert false / true inputs to specification input
+        if usePrefix == False:
+            usePrefix = "no"
+        if usePrefix == True:
+            usePrefix = "yes"
+
+        return self.connectionObj.qps.sendCmdVerbose(
+            "$create channel " + channelName + " " + channelGroup + " " + baseUnits + " " + usePrefix)
+
+    def hideChannel(self, channelSpecifier):
+        return self.connectionObj.qps.sendCmdVerbose("$hide channel " + channelSpecifier)
+
+    def showChannel(self, channelSpecifier):
+        return self.connectionObj.qps.sendCmdVerbose("$show channel " + channelSpecifier)
+
+    def myChannels(self):
+        return self.connectionObj.qps.sendCmdVerbose("$channels")
+
+    def channels(self):
+        return self.connectionObj.qps.sendCmdVerbose("$channels").splitlines()
+
+    def stopStream(self):
+        return self.connectionObj.qps.sendCmdVerbose("$stop stream")
+
+    def stopStreamAndAllowBufferToEmpty(self, checkInterval=0.5):
+        self.stopStream()
+        streamState = self.getStreamState().lower()
+        while "running" in streamState:
+            logging.debug("Stream buffer still emptying: " + streamState)
+            time.sleep(checkInterval)
+            streamState = self.getStreamState().lower()
+        logging.debug("QPS no longer Streaming: " + streamState)
+
+    def hideAllDefaultChannels(self):
+
+        # TODO query QPS / Device for all channel names and hide all of them
+        # All Default Channels
+        self.hideChannel("3.3v:voltage")
+        self.hideChannel("3v3:voltage")
+        self.hideChannel("5v:voltage")
+        self.hideChannel("12v:voltage")
+        self.hideChannel("3v3:current")
+        self.hideChannel("3.3v:current")
+        self.hideChannel("5v:current")
+        self.hideChannel("12v:current")
+        self.hideChannel("3v3:power")
+        self.hideChannel("3.3v:power")
+        self.hideChannel("5v:power")
+        self.hideChannel("12v:power")
+        self.hideChannel("tot:power")
+        # Default PAM channels
+        self.hideChannel("perst#:digital")
+        self.hideChannel("wake#:digital")
+        self.hideChannel("lkreq#:digital")
+        self.hideChannel("smclk:digital")
+        self.hideChannel("smdat:digital")
+
+    # function to add a data point the the stream
+    # time value will default to current time if none passed
+    def addDataPoint(self, channelName, groupName, dataValue, dataPointTime=0, timeFormat="unix"):
+        '''
+        channelName - str
+        groupName - str
+        dataValue - int/float value of the data point
+        dataPointTime=0 - time of the data point
+        timeFormat="unix" - the format of the given time
+        '''
+        if dataPointTime == None or dataPointTime == 0:
+            dataPointTime = qpsNowStr()
+        else:
+            dataPointTime = toQpsTimeStamp(dataPointTime)
+
+        self.connectionObj.qps.sendCmdVerbose(
+            "$stream data add " + channelName + " " + groupName + " " + str(dataPointTime) + " " + str(
+                dataValue) + " " + timeFormat)

quarchpy/device/scanDevices.py

@@ -179,6 +179,7 @@ def list_network(target_conn="all", debugPring=False, lanTimeout=1, ipAddressLoo
     retVal={}
     lan_modules = dict()
     specifiedDevice = None
+    moduleFound = None
     # Broadcast the message.
     logging.debug("Broadcast LAN discovery message for UDP scan to all network interfaces")
     ipList = socket.gethostbyname_ex(socket.gethostname())
@@ -199,7 +200,7 @@ def list_network(target_conn="all", debugPring=False, lanTimeout=1, ipAddressLoo
 
         if ipAddressLookup is not None:
             # Attempts to find the device through UDP then REST
-            specifiedDevice = lookupDevice(str(ipAddressLookup).strip(), mySocket, lan_modules)
+            specifiedDevice, moduleFound = lookupDevice(str(ipAddressLookup).strip(), mySocket, lan_modules, moduleFound)
 
 
         mySocket.sendto(b'Discovery: Who is out there?\0\n', ('255.255.255.255', 30303))
@@ -266,7 +267,11 @@ def list_network(target_conn="all", debugPring=False, lanTimeout=1, ipAddressLoo
                     lan_modules["TCP:" + ip_module] = module_name
                     logging.debug("Found TCP module: " + module_name)
         mySocket.close()
-
+    if ipAddressLookup is not None:
+        if moduleFound is None:
+            printText("IP Scan failed, no module found.")
+        else:
+            printText("IP Scan succeeded, module found: " + moduleFound)
     logging.debug("Finished UDP scan")
     retVal.update(lan_modules)
     return retVal
@@ -304,7 +309,7 @@ def get_user_level_serial_number(network_modules):
 
 
 ''''''
-def lookupDevice(ipAddressLookup, mySocket, lan_modules):
+def lookupDevice(ipAddressLookup, mySocket, lan_modules, module_found):
     try:
         specifiedDevice =None
         # For future reference, 0 is the C terminator for a string
@@ -318,8 +323,8 @@ def lookupDevice(ipAddressLookup, mySocket, lan_modules):
         # Check to see if the response contains the connection protocol
         return specifiedDevice
     except Exception as e:
-        logging.warning("Error during UDP lookup of IP address "+ str(ipAddressLookup) +"  Error: " + str(e))
-        logging.warning("No Quarch module found at this address. Please check the IP address and that you can ping it.\r\n")
+        logging.debug("Error during UDP lookup of IP address "+ str(ipAddressLookup) +"  Error: " + str(e))
+        logging.debug("No Quarch module found at this address. Please check the IP address and that you can ping it.\r\n")
 
     #return None # Commented out, attempt a REST connection with IP. This is what other quarch applications do.
     if specifiedDevice is None: #Only True if TCP not found or errored
@@ -333,10 +338,11 @@ def lookupDevice(ipAddressLookup, mySocket, lan_modules):
             # Exit as device was found correctly
             # Add the item to list
             lan_modules["REST:" + str(ipAddressLookup).replace("\r\n", "")] = restDevice
+            module_found = restDevice
             specifiedDevice=None # Don't return rest connection, to bypass tcp parsing.
         except Exception as e:
-            logging.warning("Error During REST scan of IP address " + str(ipAddressLookup) + "  Error: " + str(e))
-            logging.warning("Please check the IP address and that you can ping it.\r\n")
+            logging.debug("Error During REST scan of IP address " + str(ipAddressLookup) + "  Error: " + str(e))
+            logging.debug("Please check the IP address and that you can ping it.\r\n")
         try:
             # from threading import Thread
             # t = Thread(target=connection_TCP.TCPConn, args=(str(ipAddressLookup).replace("\r\n", ""),))
@@ -355,12 +361,14 @@ def lookupDevice(ipAddressLookup, mySocket, lan_modules):
             # Exit as device was found correctly
             # Add the item to list
             lan_modules["TCP:" + str(ipAddressLookup).replace("\r\n", "")] = tcpDevice
+            module_found = tcpDevice
             specifiedDevice=None # Don't return tcp connection, to bypass tcp parsing.
         except Exception as e:
-            logging.warning("Error During TCP scan of IP address " + str(ipAddressLookup) + "  Error: " + str(e))
-            logging.warning("Please check the IP address and that you can ping it.\r\n")
+            logging.debug("Error During TCP scan of IP address " + str(ipAddressLookup) + "  Error: " + str(e))
+            logging.debug("Please check the IP address and that you can ping it.\r\n")
+
         # Needs to return None so previous method will not attempt another lookup.
-        return specifiedDevice
+        return specifiedDevice, module_found
 
 
 

quarchpy/docs/CHANGES.rst

@@ -13,6 +13,18 @@ Quarchpy
 Change Log
 ----------
 
+
+2.2.2
+-----
+- New QPS 1.44 and QIS 1.46
+- Added support for automatic creation of default synthetic channels when connecting to module via QIS
+- Minor bug fixes
+
+2.2.1
+-----
+- New QPS v1.43 and QIS v1.45 packaged with java 21 with no need for installed java.
+- Minor bug fixes
+
 2.2.0
 -----
 - New QPS v1.42 and QIS v1.44 packaged with java 21 with no need for installed java.