quarchpy 2.1.11.dev4__py3-none-any.whl → 2.2.17.dev1__py3-none-any.whl

quarchpy/qis/qisFuncs.py

@@ -1,45 +1,82 @@
 """
+
 Contains general functions for starting and stopping QIS processes
+
 """
 
-import os, sys 
-import time, platform 
-from quarchpy.connection_specific.connection_QIS import QisInterface 
+import os, sys
+import time, platform
+from threading import Thread, Lock, Event, active_count
+from queue import Queue, Empty
+from quarchpy.connection_specific.connection_QIS import QisInterface
+from quarchpy.connection_specific.jdk_jres.fix_permissions import main as fix_permissions, find_java_permissions
+from quarchpy.install_qps import find_qps
+from quarchpy.user_interface.user_interface import printText, logDebug
 import subprocess
 import logging
+logger = logging.getLogger(__name__)
+
 
-def isQisRunning(): 
+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 
+            qisRunning = True
     except:
         #if there's no connection to qis, an exception will be caught
-        pass    
-     
+        pass
+    if (qisRunning is False):
+        logger.debug("QIS is not running")
+        return False
+    else:
+        logger.debug("QIS is running")
+        return True
+
+
+def isQisRunningAndResponding(timeout=2):
+    """
+    checks if qis is running and responding to a $version
+    """
+    qisRunning = isQisRunning()
+    if qisRunning == False:
+        logger.debug("QIS is not running")
+        return False
+
+    logger.debug("Qis is running")
+    myQis = QisInterface(connectionMessage=False)
+    counter = 0
+    maxCounter = 20
+    while counter <= maxCounter:
+        versionResponse = myQis.sendAndReceiveCmd(cmd="$version")
+        if "v" in versionResponse.lower():
+            qisResponding = True
+            break
+        else:
+            logger.debug("Qis returned from $version: " + str(versionResponse) + "  Expected to contain ': v'")
+            time.sleep(timeout / maxCounter)  # We attempt to get QIS
+            counter += 1
+
     if (qisRunning is False):
-        logging.debug("QIS is not running")
-        return False 
+        logger.debug("QIS is not running")
+        return False
     else:
-        logging.debug("QIS is running")
+        logger.debug("QIS is running")
         return True
- 
-def startLocalQis(terminal=False, headless=False, args=None):
+
+
+def startLocalQis(terminal=False, headless=False, args=None, timeout=20):
     """
     Executes QIS on the local system, using the version contained within quarchpy
     
@@ -53,76 +90,177 @@ def startLocalQis(terminal=False, headless=False, args=None):
         List of additional parameters to be supplied to QIS on the command line
 
     """
+    if not find_qps():
+        logger.error("Unable to find or install QPS... Aborting...")
+        return
+
+    # java path
+    java_path = os.path.dirname(os.path.abspath(__file__))
+    java_path, junk = os.path.split(java_path)
+    java_path = os.path.join(java_path, "connection_specific", "jdk_jres")
+    java_path = "\"" + java_path
+
+    # change directory to /QPS/QIS
+    qis_path = os.path.dirname(os.path.abspath(__file__))
+    qis_path, junk = os.path.split(qis_path)
+
+    # OS
+    current_os = platform.system()
+    current_arch = platform.machine()
+    current_arch = current_arch.lower()  # ensure comparing same case
+
+    # Currently officially unsupported
+    if (current_os in "Linux" and current_arch == "aarch64") or (current_os in "Darwin" and current_arch == "arm64"):
+        logger.warning("The system [" + current_os + ", " + current_arch + "] is not officially supported.")
+        logger.warning("Please contact Quarch support for running QuarchPy on this system.")
+        return
+
+    # ensure the jres folder has the required permissions
+    permissions, message = find_java_permissions()
+    if permissions is False:
+        logger.warning(message)
+        logger.warning("Not having correct permissions will prevent Quarch Java Programs to launch")
+        logger.warning("Run \"python -m quarchpy.run permission_fix\" to fix this.")
+        user_input = input("Would you like to fix permissions now? (Y/N)")
+        if user_input.lower() == "y":
+            fix_permissions()
+            permissions, message = find_java_permissions()
+            time.sleep(0.5)
+            if permissions is False:
+                logger.warning("Attempt to fix permissions was unsuccessful. Please fix these manually.")
+            else:
+                logger.warning("Attempt to fix permissions was successful. Now continuing.")
+
+    qis_path = os.path.join(qis_path, "connection_specific", "QPS", "qis", "qis.jar")
+
+    # record current working directory
+    current_dir = os.getcwd()
+    os.chdir(os.path.dirname(qis_path))
+
+    # Building the command
+
+    # prefer IPV4 to IPV6
+    ipv4v6_vm_args = "-Djava.net.preferIPv4Stack=true -Djava.net.preferIPv6Addresses=false"
+
+    # Process command prefix. Needed for headless mode, to support OSs with no system tray.
+    # Added the flag to suppress the Java restricted method warning
+    cmd_prefix = ipv4v6_vm_args + " --enable-native-access=ALL-UNNAMED"
+    if headless is True or (args is not None and "-headless" in args):
+        cmd_prefix += " -Djava.awt.headless=true"
+
+    # Ignore netty unsafe warning
+    cmd_prefix += " -Dio.netty.noUnsafe=true"
 
-    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)
-    if (headless == True or (args is not None and "-headless" in args)):
-        cmdPrefix = " -Djava.awt.headless=true "
-    else:
-        cmdPrefix = ""
-        
     # Process command suffix (additional standard options for QIS).
-    if (terminal == True):
-        cmdSuffix = " -terminal"
+    if terminal is True:
+        cmd_suffix = " -terminal"
     else:
-        cmdSuffix = ""
+        cmd_suffix = ""
     if args is not None:
         for option in args:
             # Avoid doubling the terminal option
-            if (option == "-terminal" and terminal == True):
+            if option == "-terminal" and terminal is 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
-    
-    #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      
-        os.system(command)
-    elif (currentOs == "Linux"):
+            if option != "-headless":
+                cmd_suffix = cmd_suffix + " " + option
+
+
+    command = "java\" " + cmd_prefix + " -jar qis.jar" + cmd_suffix
+
+    # different start for different OS
+    if current_os == "Windows":
+        command = java_path + "\\win_amd64_jdk_jre\\bin\\" + command
+    elif current_os == "Linux" and current_arch == "x86_64":
+        command = java_path + "/lin_amd64_jdk_jre/bin/" + command
+    elif current_os == "Linux" and current_arch == "aarch64":
+        command = java_path + "/lin_arm64_jdk_jre/bin/" + command
+    elif current_os == "Darwin" and current_arch == "x86_64":
+        command = java_path + "/mac_amd64_jdk_jre/bin/" + command
+    elif current_os == "Darwin" and current_arch == "arm64":
+        command = java_path + "/mac_arm64_jdk_jre/bin/" + command
+    else:  # default to windows
+        command = java_path + "\\win_amd64_jdk_jre\\bin\\" + command
+
+    # Use the command and check QIS has launched
+    # If logging to a terminal window is on then os.system should be used to view logging.
+    if "-logging=ON" in str(args):
+        process = subprocess.Popen(command, shell=True)
+        startTime = time.time()  # Checks for Popen launch only
+        while not isQisRunning():
+            if time.time() - startTime > timeout:
+                raise TimeoutError("QIS failed to launch within timelimit of " + str(timeout) + " sec.")
+            pass
+    else:
         if sys.version_info[0] < 3:
-            os.popen2("java " + command)
+            process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
+        else:
+            process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, shell=True)
+
+        startTime = time.time()  #Checks for Popen launch only
+        while not isQisRunning():
+            _get_std_msg_and_err_from_QIS_process(process)
+            if time.time() - startTime > timeout:
+                raise TimeoutError("QIS failed to launch within timelimit of " + str(timeout) + " sec.")
+            pass
+
+        if isQisRunningAndResponding(timeout=timeout):
+            logDebug("QIS running and responding")
         else:
-            os.popen("java " + command)
-    else: 
-        command = "start /high /b javaw " + command 
-        os.system(command)
-
-    #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." )
+            logDebug("QIS running but not responding")
+
+    # change directory back to start directory
+    os.chdir(current_dir)
+
+
+def reader(stream, q, source, lock, stop_flag):
+    '''
+    Used to read output and place it in a queue for multithreaded reading
+    :param stream:
+    :param q:
+    :param source:
+    :param lock: The lock for the queue
+    :param stop_flag: Flag to exit the loop and close the thread
+    :return: None
+    '''
+    while not stop_flag.is_set():
+        line = stream.readline()
+        if not line:
             break
-        pass
-    
-    #change directory back to start directory 
-    os.chdir(current_direc) 
+        with lock:
+            q.put((source, line.strip()))
+
+
+def _get_std_msg_and_err_from_QIS_process(process):
+    '''
+    Uses multithreading to check for stderr and stdmsg passed by the process that launches QPS
+    This allows the user to understand why QPS might not have appeared.
+    :param process: The Process Used to launch QPS
+    :return: None
+    '''
+    # Read back stdmsg and stderr in seperate threads so they are non blocking
+    q = Queue()
+    lock = Lock()
+    stop_flag = Event()
+
+    t1 = Thread(target=reader, args=[process.stdout, q, 'stdout', lock, stop_flag])
+    t2 = Thread(target=reader, args=[process.stderr, q, 'stderr', lock, stop_flag])
+    t1.start()
+    t2.start()
+    counter = 0
+    # check for stderr or stdmsg from the queue
+    while counter <= 3:  # If 3 empty reads from the queue then move on to see if QPS is running.
+        try:
+            source, line = q.get(timeout=1)  # Wait for 1 second for new lines
+            counter = 0
+            if source == "stderr":
+                logger.error(f"{source}: {line}")
+            else:
+                printText(f"{source}: {line}")
+        except Empty:
+            counter += 1
+    stop_flag.set()  #Close the threads and return to the main loop where QPS is check to see if its started yet
 
-    #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):
     """
@@ -155,12 +293,13 @@ def check_remote_qis(host='127.0.0.1', port=9722, timeout=0):
             break
 
     if (qisRunning is False):
-        logging.debug("QIS is not running")
+        logger.debug("QIS is not running")
         return False
     else:
-        logging.debug("QIS is running")
+        logger.debug("QIS is running")
         return True
 
+
 def checkAndCloseQis(host='127.0.0.1', port=9722):
     if isQisRunning() is True:
         closeQis()
@@ -179,54 +318,53 @@ def closeQis(host='127.0.0.1', port=9722):
         QIS connection port if set to a value other than the default
         
     """
-    
+
     myQis = QisInterface(host, port)
-    retVal=myQis.sendAndReceiveCmd(cmd = "$shutdown")
+    retVal = myQis.sendAndReceiveCmd(cmd="$shutdown")
     myQis.disconnect()
     time.sleep(1)
     return retVal
 
+
 #DEPRICATED
-def GetQisModuleSelection (QisConnection):
+def GetQisModuleSelection(QisConnection):
     """
     Prints a list of modules for user selection
     
-    .. deprecated:: 2.0.12
+    .. 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 ]
+    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 (' --------------------------------------------')
-        
+    printText("\n ########## STEP 1 - Select a Quarch Module. ########## \n")
+    printText(' --------------------------------------------')
+    printText(' |  {:^5}  |  {:^30}|'.format("INDEX", "MODULE"))
+    printText(' --------------------------------------------')
+
     try:
         for idx in xrange(len(devList)):
-            print (' |  {:^5}  |  {:^30}|'.format(str(idx+1), devList[idx]))
-            print(' --------------------------------------------')
+            printText(' |  {:^5}  |  {:^30}|'.format(str(idx + 1), devList[idx]))
+            printText(' --------------------------------------------')
     except:
         for idx in range(len(devList)):
-            print (' |  {:^5}  |  {:^30}|'.format(str(idx+1), devList[idx]))
-            print(' --------------------------------------------')
+            printText(' |  {:^5}  |  {:^30}|'.format(str(idx + 1), devList[idx]))
+            printText(' --------------------------------------------')
 
     # Get the user to select the device to control
     try:
-        moduleId = int(raw_input ("\n>>> Enter the index of the Quarch module: "))
+        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: "))
+        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]
+        myDeviceID = devList[moduleId - 1]
     else:
         myDeviceID = None
 
     return myDeviceID
- 
- 

quarchpy/qps/__init__.py

@@ -1,6 +1,6 @@
-__all__ = ['isQpsRunning','startLocalQps','closeQps','GetQpsModuleSelection','qpsInterface','toQpsTimeStamp']
+__all__ = ['isQpsRunning','startLocalQps','closeQps','GetQpsModuleSelection','qpsInterface']
 
-from .qpsFuncs import isQpsRunning, startLocalQps, closeQps, GetQpsModuleSelection, toQpsTimeStamp
+from .qpsFuncs import isQpsRunning, startLocalQps, closeQps, GetQpsModuleSelection
 from quarchpy.connection_specific.connection_QPS import QpsInterface as qpsInterface