quarchpy 2.1.14.dev3__py2.py3-none-any.whl → 2.1.14.dev5__py2.py3-none-any.whl

quarchpy/qis/qisFuncs.py

@@ -53,17 +53,17 @@ def startLocalQis(terminal=False, headless=False, args=None):
         List of additional parameters to be supplied to QIS on the command line
 
     """
-
+    # Gathering Vars needed to build the command
     QisPath =os.path.dirname(os.path.abspath(__file__))
     QisPath,junk = os.path.split (QisPath)
     QisPath = os.path.join(QisPath, "connection_specific","QPS", "qis", "qis.jar")
-    
-    # Process command prefix (needed for headless mode)
+
+    # Building the command
+    # Process command prefix. Needed for headless mode, to support OSs with no system tray.
     if (headless == True or (args is not None and "-headless" in args)):
         cmdPrefix = " -Djava.awt.headless=true "
     else:
-        cmdPrefix = ""
-        
+        cmdPrefix = "java"
     # Process command suffix (additional standard options for QIS).
     if (terminal == True):
         cmdSuffix = " -terminal"
@@ -77,52 +77,35 @@ def startLocalQis(terminal=False, headless=False, args=None):
             # Headless option is processed seperately as a java command
             if (option != "-headless"):
                 cmdSuffix = cmdSuffix + " " + option
-    
     # Find file path and change directory to Qis Location
     current_direc = os.getcwd() 
     os.chdir(os.path.dirname(QisPath))
-    command = cmdPrefix + "-jar qis.jar"+cmdSuffix
-    
-    #different start for different OS 
-    currentOs = platform.system()
-    if (currentOs == "Windows"): 
-        if(cmdSuffix == " -logging=ON"):
-            command = "java " + command
-        else: 
-            command = "start /high /b javaw " + command      
+    command = cmdPrefix+" -jar qis.jar"+cmdSuffix
+
+    # Use the command and check QIS has launched
+    if "-logging=ON" in str(args): #If logging to a terminal window is on then os.system should be used to view logging.
         os.system(command)
-    elif (currentOs == "Linux"):
+    else:
         if sys.version_info[0] < 3:
-            os.popen2("java " + command)
+            sp=os.popen2(command + " 2>&1")
         else:
-            os.popen("java " + command)
-    else: 
-        command = "start /high /b javaw " + command 
-        os.system(command)
+            sp=os.popen(command + " 2>&1")
+        startTime = time.time() #Checks for Popen launch only
+        timeout = 10
+        while not isQisRunning():
+            retval=str(sp.read())
+            if str(retval)!="":
+                print(retval)
+                if "fail" or "error" in retval.lower():
+                    raise Exception(retval)
+                if time.time() - startTime > timeout:
+                    raise TimeoutError("QIS failed to launch within timelimit of " + str(timeout) + " sec.")
+            time.sleep(0.2)
+            pass
 
-    #Qis needs a small time for startup
-    time.sleep(2)
-
-    #see if new instance of qis has started
-    startTime = time.time()
-    currentTime = time.time()
-    timeout = 10
-    while not isQisRunning():
-        time.sleep(0.1)
-        currentTime = time.time()
-        if currentTime - startTime > timeout:
-            raise TimeoutError("QIS failed to launch within timelimit of " +str(timeout) +" sec." )
-            break
-        pass
-    
     #change directory back to start directory 
-    os.chdir(current_direc) 
+    os.chdir(current_direc)
 
-    #This prevents QIS being lanuched more that once by the same instance of quarchpy
-    # try:
-    #     startLocalQis.func_code = (lambda:None).func_code
-    # except:
-    #     startLocalQis.__code__ = (lambda:None).__code__
 
 def check_remote_qis(host='127.0.0.1', port=9722, timeout=0):
     """

quarchpy/qis/qisFuncs.py.bak

@@ -0,0 +1,213 @@
+"""
+Contains general functions for starting and stopping QIS processes
+"""
+
+import os, sys 
+import time, platform 
+from quarchpy.connection_specific.connection_QIS import QisInterface 
+import subprocess
+import logging
+
+def isQisRunning(): 
+    """
+    Checks if a local instance of QIS is running and responding
+    
+    Returns
+    -------
+    is_running : bool
+        True if QIS is running and responding
+
+    """
+ 
+    qisRunning = False
+    myQis = None
+    
+    #attempt to connect to Qis
+    try:
+        myQis = QisInterface(connectionMessage=False)
+        if (myQis is not None):
+            #if we can connect to qis, it's running
+            qisRunning = True 
+    except:
+        #if there's no connection to qis, an exception will be caught
+        pass    
+     
+    if (qisRunning is False):
+        logging.debug("QIS is not running")
+        return False 
+    else:
+        logging.debug("QIS is running")
+        return True
+ 
+def startLocalQis(terminal=False, headless=False, args=None):
+    """
+    Executes QIS on the local system, using the version contained within quarchpy
+    
+    Parameters
+    ----------
+    terminal : bool, optional
+        True if QIS terminal should be shown on startup
+    headless : bool, optional
+        True if app should be run in headless mode for non graphical environments
+    args : list[str], optional
+        List of additional parameters to be supplied to QIS on the command line
+
+    """
+    # Gathering Vars needed to build the command
+    QisPath =os.path.dirname(os.path.abspath(__file__))
+    QisPath,junk = os.path.split (QisPath)
+    QisPath = os.path.join(QisPath, "connection_specific","QPS", "qis", "qis.jar")
+
+    # Building the command
+    # Process command prefix. Needed for headless mode, to support OSs with no system tray.
+    if (headless == True or (args is not None and "-headless" in args)):
+        cmdPrefix = " -Djava.awt.headless=true "
+    else:
+        cmdPrefix = "java"
+    # Process command suffix (additional standard options for QIS).
+    if (terminal == True):
+        cmdSuffix = " -terminal"
+    else:
+        cmdSuffix = ""
+    if args is not None:
+        for option in args:
+            # Avoid doubling the terminal option
+            if (option == "-terminal" and terminal == True):
+                continue
+            # Headless option is processed seperately as a java command
+            if (option != "-headless"):
+                cmdSuffix = cmdSuffix + " " + option
+    # Find file path and change directory to Qis Location
+    current_direc = os.getcwd() 
+    os.chdir(os.path.dirname(QisPath))
+    command = cmdPrefix+" -jar qis.jar"+cmdSuffix
+
+    # Use the command and check QIS has launched
+    if "-logging=ON" in str(args): #If logging to a terminal window is on then os.system should be used to view logging.
+        os.system(command)
+    else:
+        if sys.version_info[0] < 3:
+            sp=os.popen2(command + " 2>&1")
+        else:
+            sp=os.popen(command + " 2>&1")
+        startTime = time.time() #Checks for Popen launch only
+        timeout = 10
+        while not isQisRunning():
+            retval=str(sp.read())
+            if str(retval)!="":
+                print(retval)
+                if "fail" or "error" in retval.lower():
+                    raise Exception(retval)
+                if time.time() - startTime > timeout:
+                    raise TimeoutError("QIS failed to launch within timelimit of " + str(timeout) + " sec.")
+            time.sleep(0.2)
+            pass
+
+    #change directory back to start directory 
+    os.chdir(current_direc)
+
+
+def check_remote_qis(host='127.0.0.1', port=9722, timeout=0):
+    """
+        Checks if a local or specified instance of QIS is running and responding
+        This continues to scan until qis is found or a timeout is hit.
+
+        Returns
+        -------
+        is_running : bool
+            True if QIS is running and responding
+
+        """
+
+    qisRunning = False
+    myQis = None
+
+    start = time.time()
+    while True:
+        # attempt to connect to Qis
+        try:
+            myQis = QisInterface(host=host, port=port, connectionMessage=False)
+            if (myQis is not None):
+                # if we can connect to qis, it's running
+                qisRunning = True
+                break
+        except:
+            # if there's no connection to qis, an exception will be caught
+            pass
+        if (time.time() - start) > timeout:
+            break
+
+    if (qisRunning is False):
+        logging.debug("QIS is not running")
+        return False
+    else:
+        logging.debug("QIS is running")
+        return True
+
+def checkAndCloseQis(host='127.0.0.1', port=9722):
+    if isQisRunning() is True:
+        closeQis()
+
+
+def closeQis(host='127.0.0.1', port=9722):
+    """
+    Helper function to close an instance of QIS.  By default this is the local version, but
+    an address can be specified for remote systems.
+    
+    Parameters
+    ----------
+    host : str, optional
+        Host IP address if not localhost
+    port : str, optional
+        QIS connection port if set to a value other than the default
+        
+    """
+    
+    myQis = QisInterface(host, port)
+    retVal=myQis.sendAndReceiveCmd(cmd = "$shutdown")
+    myQis.disconnect()
+    time.sleep(1)
+    return retVal
+
+#DEPRICATED
+def GetQisModuleSelection (QisConnection):
+    """
+    Prints a list of modules for user selection
+    
+    .. deprecated:: 2.0.12
+        Use the module selection functions of the QisInterface class instead
+    """
+    
+    # Request a list of all USB and LAN accessible power modules
+    devList = QisConnection.getDeviceList()
+    # Removes rest devices
+    devList = [ x for x in devList if "rest" not in x ]
+
+    # Print the devices, so the user can choose one to connect to
+    print ("\n ########## STEP 1 - Select a Quarch Module. ########## \n")
+    print (' --------------------------------------------')
+    print (' |  {:^5}  |  {:^30}|'.format("INDEX", "MODULE"))
+    print (' --------------------------------------------')
+        
+    try:
+        for idx in xrange(len(devList)):
+            print (' |  {:^5}  |  {:^30}|'.format(str(idx+1), devList[idx]))
+            print(' --------------------------------------------')
+    except:
+        for idx in range(len(devList)):
+            print (' |  {:^5}  |  {:^30}|'.format(str(idx+1), devList[idx]))
+            print(' --------------------------------------------')
+
+    # Get the user to select the device to control
+    try:
+        moduleId = int(raw_input ("\n>>> Enter the index of the Quarch module: "))
+    except NameError:
+        moduleId = int(input ("\n>>> Enter the index of the Quarch module: "))
+
+    # Verify the selection
+    if (moduleId > 0 and moduleId <= len(devList)):
+        myDeviceID = devList[moduleId-1]
+    else:
+        myDeviceID = None
+
+    return myDeviceID

quarchpy/qps/qpsFuncs.py

@@ -76,33 +76,29 @@ def startLocalQps(keepQisRunning=False, args=[]):
     QpsPath = os.path.dirname(os.path.abspath(__file__))
     QpsPath, junk = os.path.split(QpsPath)
     QpsPath = os.path.join(QpsPath, "connection_specific", "QPS", "qps.jar")
-
     current_direc = os.getcwd()
-
     os.chdir(os.path.dirname(QpsPath))
 
-    command = "-jar \"" + QpsPath + "\""
-
-    currentOs = platform.system()
-
-    if currentOs in "Windows":
-        command = "start /high /b javaw -Djava.awt.headless=true " + command + " " + str(args)
-        command = command + "-ccs=HIDE"  # note: multiple -ccs options ignored
+    command = "java -jar \"" + QpsPath + "\"" + " " + str(args)
+    if "-logging=ON" in str(args): #If logging to a terminal window is on then os.system should be used to keep a window open to view logging.
         os.system(command)
-    elif currentOs in "Linux":
-        command = command + "-ccs=HIDE"
+    else:
         if sys.version_info[0] < 3:
-            os.popen2("java " + command + " 2>&1")
+            sp=os.popen2(command + " 2>&1")
         else:
-            os.popen("java " + command + " 2>&1")
-    else:  # default to Windows
-        command = "start /high /b javaw -Djava.awt.headless=true " + command + " " + str(args)
-        command = command + "-ccs=HIDE"
-        os.system(command)
-
-    while not isQpsRunning():
-        time.sleep(0.3)
-        pass
+            sp=os.popen(command + " 2>&1")
+        startTime = time.time() #Checks for Popen launch only
+        timeout = 10
+        while not isQpsRunning():
+            retval=str(sp.read())
+            if str(retval)!="":
+                print(retval)
+                if "fail" or "error" in retval.lower():
+                    raise Exception(retval)
+            time.sleep(0.2)
+            if time.time() - startTime > timeout:
+                raise TimeoutError("QPS failed to launch within timelimit of " + str(timeout) + " sec.")
+            pass
 
     os.chdir(current_direc)
 
@@ -197,7 +193,7 @@ QPS requires time in mS with no decimal point, so this is converted here
 
 def toQpsTimeStamp(timestamp):
     """
-    DEPRICATED - QPS expects time passed as a sring and error hadling is done in QPS.
+    DEPRECATED - QPS expects time passed as a string and error handling is done in QPS.
     Returns the parameter passed as a valid qps timestamp
     Assumes
 

quarchpy/qps/qpsFuncs.py.bak

@@ -0,0 +1,224 @@
+import os, sys
+import datetime
+import time, platform
+from quarchpy.qis import isQisRunning, startLocalQis
+from quarchpy.connection_specific.connection_QIS import QisInterface
+from quarchpy.connection_specific.connection_QPS import QpsInterface
+from quarchpy.user_interface import *
+import subprocess
+import logging
+
+
+def isQpsRunning(host='127.0.0.1', port=9822, timeout=0):
+    '''
+    This func will return true if QPS is running with a working QIS connection. This is becuase
+    '''
+    myQps=None
+    logging.debug("Checking if QPS is running")
+    start = time.time()
+    while True:
+        try:
+            myQps = QpsInterface(host, port)
+            break
+        except Exception as e:
+            logging.debug("Error when making QPS interface. QPS may not be running.")
+            logging.debug(e)
+            if (time.time() - start) > timeout:
+                break
+    if myQps is None:
+        logging.debug("QPS is not running")
+        return False
+
+    logging.debug("Checking if QPS reports a QIS connection") # "$qis status" returns connected if it has ever had a QIS connection.
+    answer=0
+    counter=0
+    while True:
+        answer = myQps.sendCmdVerbose(cmd="$qis status")
+        if answer.lower()=="connected":
+            logging.debug("QPS Running With QIS Connected")
+            break
+        else:
+            logging.debug("QPS Running QIS NOT found. Waiting and retrying.")
+            time.sleep(0.5)
+            counter += 1
+            if counter > 5:
+                logging.debug("QPS Running QIS NOT found after "+str(counter)+" attempts.")
+                return False
+
+    logging.debug("Checking if QPS/QIS comms are running")
+    start = time.time()
+    while True:
+        try:
+            answer = myQps.sendCmdVerbose(cmd="$list")
+            break
+        except:
+            pass
+        if (time.time() - start) > timeout:
+            break
+
+    # check for a 1 showing the first module to be displayed, or a no module/device error message.
+    if answer[0] == "1" or "no device" in str(answer).lower() or "no module" in str(answer).lower():
+        logging.debug("QPS and QIS are running and responding with valid $list info")
+        return True
+    else:
+        logging.debug("QPS did not return expected output from $list")
+        logging.debug("$list: " + str(answer))
+        return False
+
+
+def startLocalQps(keepQisRunning=False, args=[]):
+    if keepQisRunning:
+        if not isQisRunning():
+            startLocalQis()
+    temp =""
+    args = temp.join(args)
+
+    QpsPath = os.path.dirname(os.path.abspath(__file__))
+    QpsPath, junk = os.path.split(QpsPath)
+    QpsPath = os.path.join(QpsPath, "connection_specific", "QPS", "qps.jar")
+    current_direc = os.getcwd()
+    os.chdir(os.path.dirname(QpsPath))
+
+    command = "java -jar \"" + QpsPath + "\"" + " " + str(args)
+    if "-logging=ON" in str(args): #If logging to a terminal window is on then os.system should be used to keep a window open to view logging.
+        os.system(command)
+    else:
+        if sys.version_info[0] < 3:
+            sp=os.popen2(command + " 2>&1")
+        else:
+            sp=os.popen(command + " 2>&1")
+        startTime = time.time() #Checks for Popen launch only
+        timeout = 10
+        while not isQpsRunning():
+            retval=str(sp.read())
+            if str(retval)!="":
+                print(retval)
+                if "fail" or "error" in retval.lower():
+                    raise Exception(retval)
+            time.sleep(0.2)
+            if time.time() - startTime > timeout:
+                raise TimeoutError("QPS failed to launch within timelimit of " + str(timeout) + " sec.")
+            pass
+
+    os.chdir(current_direc)
+
+
+def closeQps(host='127.0.0.1', port=9822):
+    myQps = QpsInterface(host, port)
+    myQps.sendCmdVerbose("$shutdown")
+    del myQps
+    time.sleep(1) #needed as calling "isQpsRunning()" will throw an error if it ties to connect while shutdown is in progress.
+
+def GetQpsModuleSelection(QpsConnection, favouriteOnly=True, additionalOptions=['rescan', 'all con types', 'ip scan'], scan=True):
+    favourite = favouriteOnly
+    ip_address = None
+    while True:
+        printText("QPS scanning for devices")
+        tableHeaders = ["Module"]
+        # Request a list of all USB and LAN accessible power modules
+        if ip_address == None:
+            devList = QpsConnection.getDeviceList(scan=scan)
+        else:
+            devList = QpsConnection.getDeviceList(scan=scan, ipAddress=ip_address)
+        if "no device" in devList[0].lower() or "no module" in devList[0].lower():
+            favourite = False  # If no device found conPref wont match and will bugout
+
+        # Removes rest devices
+        devList = [x for x in devList if "rest" not in x]
+        message = "Select a quarch module"
+
+        if (favourite):
+            index = 0
+            sortedDevList = []
+            conPref = ["USB", "TCP", "SERIAL", "REST", "TELNET"]
+            while len(sortedDevList) != len(devList):
+                for device in devList:
+                    if conPref[index] in device.upper():
+                        sortedDevList.append(device)
+                index += 1
+            devList = sortedDevList
+
+            # new dictionary only containing one favourite connection to each device.
+            favConDevList = []
+            index = 0
+            for device in sortedDevList:
+                if (favConDevList == [] or not device.split("::")[1] in str(favConDevList)):
+                    favConDevList.append(device)
+            devList = favConDevList
+
+        if User_interface.instance != None and User_interface.instance.selectedInterface == "testcenter":
+            tempString = ""
+            for module in devList:
+                tempString+=module+"="+module+","
+            devList = tempString[0:-1]
+
+
+        myDeviceID = listSelection(title=message, message=message, selectionList=devList,
+                                   additionalOptions=additionalOptions, nice=True, tableHeaders=tableHeaders, indexReq=True)
+
+        if myDeviceID in 'rescan':
+            ip_address = None
+            favourite = True
+            continue
+        elif myDeviceID in 'all con types':
+            printText('Displaying all conection types...')
+            favourite = False
+            continue
+        elif myDeviceID in 'ip scan':
+            ip_address = requestDialog("Please input IP Address of the module you would like to connect to: ")
+            favourite = False
+            continue
+        else:
+            return myDeviceID
+
+
+
+
+'''
+Legacy function to handle old scripts which call an adjustTime function to get QPS format time.
+This is now done in the QPS module level, so this function returns a integer linux millisecond value
+as per the old one
+'''
+
+
+def legacyAdjustTime(timestamp):
+    return timestamp
+
+
+'''
+Simple function to convert a timestamp or Python datetime object into QPS format time
+QPS requires time in mS with no decimal point, so this is converted here
+'''
+
+
+def toQpsTimeStamp(timestamp):
+    """
+    DEPRECATED - QPS expects time passed as a string and error handling is done in QPS.
+    Returns the parameter passed as a valid qps timestamp
+    Assumes
+
+    # 1620817118182 - ACCEPTED value for QPS    - Milliseconds, 13 chars
+
+    # 1620817126    - time.time() Value         - Seconds
+
+    :param int/float/datetime: Timestamp, mS
+    :return: int             : QPS valid time, mS
+    """
+
+    # Python datetime object
+    if (type(timestamp) is datetime):
+        newTime = time.mktime(timestamp.timetuple())
+        return int(newTime * 1000)
+    # If numeric, assume standard unix time in milliseconds
+    elif (type(timestamp) is float or type(timestamp) is int):
+        return int(timestamp)
+    else:
+        # Try if its a numeric value string first (assumed to be milliseconds)
+        try:
+            timestamp = float(timestamp)
+            return int(timestamp)
+        # Fall back to assuming a standard format time string
+        except:
+            newTime = time.mktime(datetime.datetime.strptime(timestamp, "%Y-%m-%d %H:%M:%S:%f").timetuple())
+            return int(newTime * 1000)
+

quarchpy/venv/.gitignore

@@ -0,0 +1,2 @@
+# created by virtualenv automatically
+*