quarchpy 2.2.9.dev4__py2.py3-none-any.whl → 2.2.10.dev1__py2.py3-none-any.whl

quarchpy/qis/qisFuncs.py

@@ -1,21 +1,20 @@
-# -*- coding: future_fstrings -*-
 """
+
 Contains general functions for starting and stopping QIS processes
+
 """
-import os, sys 
+
+import os, sys
 import time, platform
 from threading import Thread, Lock, Event, active_count
-try:
-    from queue import Queue, Empty  # Python 3
-except ImportError:
-    from Queue import Queue, Empty  # Python 2
-
+from queue import Queue, Empty
 from quarchpy.connection_specific.connection_QIS import QisInterface
-from quarchpy.connection_specific.jdk_j21_jres.fix_permissions import main as fix_permissions, find_java_permissions
+from quarchpy.connection_specific.jdk_jres.fix_permissions import main as fix_permissions, find_java_permissions
 from quarchpy.user_interface.user_interface import printText, logDebug
 import subprocess
 import logging
 
+
 def isQisRunning():
     """
     Checks if a local instance of QIS is running and responding
@@ -38,7 +37,7 @@ def isQisRunning():
         pass
     if (qisRunning is False):
         logging.debug("QIS is not running")
-        return False 
+        return False
     else:
         logging.debug("QIS is running")
         return True
@@ -49,7 +48,7 @@ def isQisRunningAndResponding(timeout=2):
     checks if qis is running and responding to a $version
     """
     qisRunning = isQisRunning()
-    if qisRunning ==False:
+    if qisRunning == False:
         logging.debug("QIS is not running")
         return False
 
@@ -67,7 +66,6 @@ def isQisRunningAndResponding(timeout=2):
             time.sleep(timeout / maxCounter)  # We attempt to get QIS
             counter += 1
 
-
     if (qisRunning is False):
         logging.debug("QIS is not running")
         return False
@@ -94,11 +92,12 @@ def startLocalQis(terminal=False, headless=False, args=None, timeout=20):
     # 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_j21_jres")
+    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)
+    qis_path, junk = os.path.split(qis_path)
 
     # OS
     current_os = platform.system()
@@ -112,13 +111,13 @@ def startLocalQis(terminal=False, headless=False, args=None, timeout=20):
         return
 
     # ensure the jres folder has the required permissions
-    permissions,message= find_java_permissions()
+    permissions, message = find_java_permissions()
     if permissions is False:
         logging.warning(message)
         logging.warning("Not having correct permissions will prevent Quarch Java Programs to launch")
         logging.warning("Run \"python -m quarchpy.run permission_fix\" to fix this.")
-        user_input = raw_input("Would you like to fix permissions now? (Y/N)")
-        if user_input.lower()=="y":
+        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)
@@ -127,8 +126,6 @@ def startLocalQis(terminal=False, headless=False, args=None, timeout=20):
             else:
                 logging.warning("Attempt to fix permissions was successful. Now continuing.")
 
-
-
     # if current_os != "Windows":
     #     subprocess.call(['chmod', '-R', '+rwx', java_path])
 
@@ -150,20 +147,20 @@ def startLocalQis(terminal=False, headless=False, args=None, timeout=20):
         else:  # default to windows
             qis_path = os.path.join(qis_path, "connection_specific", "QPS", "win-amd64", "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.
-    cmd_prefix =ipv4v6_vm_args
+    cmd_prefix = ipv4v6_vm_args
     if headless is True or (args is not None and "-headless" in args):
         cmd_prefix += " -Djava.awt.headless=true"
 
-
     # Process command suffix (additional standard options for QIS).
     if terminal is True:
         cmd_suffix = " -terminal"
@@ -178,33 +175,31 @@ def startLocalQis(terminal=False, headless=False, args=None, timeout=20):
             if option != "-headless":
                 cmd_suffix = cmd_suffix + " " + option
 
-    # record current working directory
-    current_dir = os.getcwd()
 
+    command = "java\" " + cmd_prefix + " -jar qis.jar" + cmd_suffix
 
-    command = "java " + cmd_prefix + " -jar qis.jar" + cmd_suffix
-    
     # different start for different OS
     if current_os == "Windows":
-        command = java_path + "\\win_amd64_jdk_21_jre\\bin\\" + command
+        command = java_path + "\\win_amd64_jdk_jre\\bin\\" + command
     elif current_os == "Linux" and current_arch == "x86_64":
-        command = java_path + "/lin_amd64_jdk_21_jre/bin/" + command
+        command = java_path + "/lin_amd64_jdk_jre/bin/" + command
     elif current_os == "Linux" and current_arch == "aarch64":
-        command = java_path + "/lin_arm64_jdk_21_jre/bin/" + command
+        command = java_path + "/lin_arm64_jdk_jre/bin/" + command
     elif current_os == "Darwin" and current_arch == "x86_64":
-        command = java_path + "/mac_amd64_jdk_21_jre/bin/" + command
+        command = java_path + "/mac_amd64_jdk_jre/bin/" + command
     elif current_os == "Darwin" and current_arch == "arm64":
-        command = java_path + "/mac_arm64_jdk_21_jre/bin/" + command
+        command = java_path + "/mac_arm64_jdk_jre/bin/" + command
     else:  # default to windows
-        command = java_path + "\\win_amd64_jdk_21_jre\\bin\\" + command
+        command = java_path + "\\win_amd64_jdk_jre\\bin\\" + command
 
     # 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.
-        process = subprocess.Popen(command,shell=True)
-        startTime = time.time() #Checks for Popen launch only
+    # 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 Exception("QIS failed to launch within timelimit of " + str(timeout) + " sec.")
+                raise TimeoutError("QIS failed to launch within timelimit of " + str(timeout) + " sec.")
             pass
     else:
         if sys.version_info[0] < 3:
@@ -212,16 +207,15 @@ def startLocalQis(terminal=False, headless=False, args=None, timeout=20):
         else:
             process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, shell=True)
 
-        startTime = time.time() #Checks for Popen launch only
+        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 Exception("QIS failed to launch within timelimit of " + str(timeout) + " sec.")
+                raise TimeoutError("QIS failed to launch within timelimit of " + str(timeout) + " sec.")
             pass
 
-
         if isQisRunningAndResponding(timeout=timeout):
-            logDebug("QPS running and responding")
+            logDebug("QIS running and responding")
         else:
             logDebug("QIS running but not responding")
 
@@ -229,7 +223,7 @@ def startLocalQis(terminal=False, headless=False, args=None, timeout=20):
     os.chdir(current_dir)
 
 
-def reader(stream, q, source, lock,stop_flag):
+def reader(stream, q, source, lock, stop_flag):
     '''
     Used to read output and place it in a queue for multithreaded reading
     :param stream:
@@ -265,7 +259,7 @@ def _get_std_msg_and_err_from_QIS_process(process):
     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.
+    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
@@ -275,7 +269,7 @@ def _get_std_msg_and_err_from_QIS_process(process):
                 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
+    stop_flag.set()  #Close the threads and return to the main loop where QPS is check to see if its started yet
 
 
 def check_remote_qis(host='127.0.0.1', port=9722, timeout=0):
@@ -315,6 +309,7 @@ def check_remote_qis(host='127.0.0.1', port=9722, timeout=0):
         logging.debug("QIS is running")
         return True
 
+
 def checkAndCloseQis(host='127.0.0.1', port=9722):
     if isQisRunning() is True:
         closeQis()
@@ -333,53 +328,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
-    printText ("\n ########## STEP 1 - Select a Quarch Module. ########## \n")
-    printText (' --------------------------------------------')
-    printText (' |  {:^5}  |  {:^30}|'.format("INDEX", "MODULE"))
-    printText (' --------------------------------------------')
-        
+    printText("\n ########## STEP 1 - Select a Quarch Module. ########## \n")
+    printText(' --------------------------------------------')
+    printText(' |  {:^5}  |  {:^30}|'.format("INDEX", "MODULE"))
+    printText(' --------------------------------------------')
+
     try:
         for idx in xrange(len(devList)):
-            printText (' |  {:^5}  |  {:^30}|'.format(str(idx+1), devList[idx]))
+            printText(' |  {:^5}  |  {:^30}|'.format(str(idx + 1), devList[idx]))
             printText(' --------------------------------------------')
     except:
         for idx in range(len(devList)):
-            printText (' |  {:^5}  |  {:^30}|'.format(str(idx+1), devList[idx]))
+            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/qpsFuncs.py

@@ -1,17 +1,9 @@
-# -*- coding: future_fstrings -*-
 from threading import Thread, Lock, Event, active_count
-try:
-    from queue import Queue, Empty  # Python 3
-except ImportError:
-    from Queue import Queue, Empty  # Python 2
-import time
-import os, sys
-import datetime
+from queue import Queue, Empty
 import 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.connection_specific.jdk_j21_jres.fix_permissions import main as fix_permissions, find_java_permissions
+from quarchpy.connection_specific.jdk_jres.fix_permissions import main as fix_permissions, find_java_permissions
 from quarchpy.user_interface import *
 import subprocess
 import logging
@@ -87,10 +79,11 @@ def startLocalQps(keepQisRunning=False, args=[], timeout=30, startQPSMinimised=T
     # Record current working directory
     current_dir = os.getcwd()
 
-    # JRE 21 path
+    # JRE 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_j21_jres")
+    java_path = os.path.join(java_path, "connection_specific", "jdk_jres")
+    java_path = "\"" + java_path
     # Start to build the path towards qps.jar
     qps_path = os.path.dirname(os.path.abspath(__file__))
     qps_path, junk = os.path.split(qps_path)
@@ -110,7 +103,7 @@ def startLocalQps(keepQisRunning=False, args=[], timeout=30, startQPSMinimised=T
     permissions, message = find_java_permissions()
     if permissions is False:
         logging.warning(message)
-        logging.warning("Not having correct permissions will prevent Quarch Java 21 Programs from launching.")
+        logging.warning("Not having correct permissions will prevent Quarch Java Programs from launching.")
         logging.warning("Run \"python -m quarchpy.run permission_fix\" to fix this.")
         user_input = input("Would you like to use auto run this now? (Y/N)")
         if user_input.lower() == "y":
@@ -146,17 +139,17 @@ def startLocalQps(keepQisRunning=False, args=[], timeout=30, startQPSMinimised=T
 
     # OS dependency
     if current_os in "Windows":
-        command = java_path + "\\win_amd64_jdk_21_jre\\bin\\java -jar qps.jar " + str(args)
+        command = java_path + "\\win_amd64_jdk_jre\\bin\\java\" -jar qps.jar " + str(args)
     elif current_os in "Linux" and current_arch == "x86_64":
-        command = java_path + "/lin_amd64_jdk_21_jre/bin/java -jar qps.jar " + str(args)
+        command = java_path + "/lin_amd64_jdk_jre/bin/java\" -jar qps.jar " + str(args)
     elif current_os in "Linux" and current_arch == "aarch64":
-        command = java_path + "/lin_arm64_jdk_21_jre/bin/java -jar qps.jar " + str(args)
+        command = java_path + "/lin_arm64_jdk_jre/bin/java\" -jar qps.jar " + str(args)
     elif current_os in "Darwin" and current_arch == "x86_64":
-        command = java_path + "/mac_amd64_jdk_21_jre/bin/java -jar qps.jar " + str(args)
+        command = java_path + "/mac_amd64_jdk_jre/bin/java\" -jar qps.jar " + str(args)
     elif current_os in "Darwin" and current_arch == "arm64":
-        command = java_path + "/mac_arm64_jdk_21_jre/bin/java -jar qps.jar " + str(args)
+        command = java_path + "/mac_arm64_jdk_jre/bin/java\" -jar qps.jar " + str(args)
     else:  # default to windows
-        command = java_path + "\\win_amd64_jdk_21_jre\\bin\\java -jar qps.jar " + str(args)
+        command = java_path + "\\win_amd64_jdk_jre\\bin\\java\" -jar qps.jar " + 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.
         if current_os in "Windows":
@@ -177,12 +170,12 @@ def startLocalQps(keepQisRunning=False, args=[], timeout=30, startQPSMinimised=T
             _get_std_msg_and_err_from_QPS_process(process)
             if time.time() - startTime > timeout:
                 os.chdir(current_dir)
-                raise Exception("QPS failed to launch within timelimit of " + str(timeout) + " sec.")
+                raise TimeoutError("QPS failed to launch within timelimit of " + str(timeout) + " sec.")
         logging.debug("QPS detected after " + str(time.time() - startTime) + "s")
 
         while not isQisRunning():
             if time.time() - startTime > timeout:
-                raise Exception(
+                raise TimeoutError(
                     "QPS did launch but QIS did not respond during the timeout time of " + str(timeout) + " sec.")
             time.sleep(0.2)
         logging.debug("QIS detected after " + str(time.time() - startTime) + "s")

quarchpy/run.py

@@ -14,7 +14,7 @@ sys.path.insert(0, parent_dir) #It must be added at the start of the list so it
 
 # Import the various functions which need to be called from the command line options
 from quarchpy.debug.SystemTest import main as systemTestMain
-# from quarchpy.debug.module_debug import parse_arguments as moduleDebugMain
+from quarchpy.debug.module_debug import parse_arguments as moduleDebugMain
 from quarchpy.qis.qisFuncs import startLocalQis, isQisRunning, closeQis as closeQIS
 from quarchpy.qps.qpsFuncs import startLocalQps, isQpsRunning, closeQps as closeQPS
 from quarchpy.debug.upgrade_quarchpy import main as uprade_quarchpy_main
@@ -127,8 +127,8 @@ def _run_module_debug_function(args=None):
         List of sub arguments to process
 
     """
-    printText("This argument is not supported in Python2.")
-    # moduleDebugMain(args)
+
+    moduleDebugMain(args)
 
 def _run_show_drives_function(args=None):
     """

quarchpy/utilities/TestCenter.py

@@ -5,11 +5,12 @@ This is Quarch internal use only.  Each function uses the stdin/stdout to commun
 as such, communication is based on simple strings
 """
 
-#import testCenter
+# import testCenter
 from inspect import getframeinfo, stack
 import sys
 
-def setup (interface_name, stack_level=1, *command_params):
+
+def setup(interface_name, *command_params, stack_level=1):
     """
     Sets up a test interface, passing the interface parameters onto TestCenter to process
     
@@ -23,29 +24,30 @@ def setup (interface_name, stack_level=1, *command_params):
     Returns
     -------
     setup_response : str
-        String returned from setup function. Generally "1" or "0" as a boolean success flag    
+        String returned from setup function. Generally "1" or "0" as a boolean success flag
+
+    """
 
-    """    
-    
     # Get stack info so we can track the calling function for reporting and debug
     caller = getframeinfo(stack()[stack_level][0])
 
     # Write the command and params to STDOUT
-    sys.stdout.write ("SETUP," + str(caller.filename) + "," + str(caller.lineno) + "," + interface_name + ",")
+    sys.stdout.write("SETUP," + str(caller.filename) + "," + str(caller.lineno) + "," + interface_name + ",")
     for index, item in enumerate(command_params):
-        if (index < len(command_params)-1):
-            sys.stdout.write ("\"" + item + "\"" + ",")
+        if index < len(command_params) - 1:
+            sys.stdout.write("\"" + item + "\"" + ",")
         else:
-            sys.stdout.write ("\"" + item)
+            sys.stdout.write("\"" + item)
 
-    sys.stdout.write ("\n")
+    sys.stdout.write("\n")
     sys.stdout.flush()
 
     # Read the response from STDIN as the function result
-    return sys.stdin.readline().strip();
-	
+    return sys.stdin.readline().strip()
+
+
 # Runs an interface setup function
-def testPoint (command_name, stack_level=1, *command_params):
+def testPoint(command_name, *command_params, stack_level=1):
     """
     Runs a test point from the testcenter library functions
     
@@ -61,39 +63,37 @@ def testPoint (command_name, stack_level=1, *command_params):
     test_response : str
         String returned from test function. This varies based on the TestPoint spec    
 
-    """  
+    """
 
     caller = getframeinfo(stack()[stack_level][0])
 
-
     # Write the command and params to STDOUT
-    sys.stdout.write ("TEST," + str(caller.filename) + "," + str(caller.lineno) + "," + command_name + ",")
+    sys.stdout.write("TEST," + str(caller.filename) + "," + str(caller.lineno) + "," + command_name + ",")
     for x in command_params:
-        sys.stdout.write ("\"" + x + "\"" + ",")
+        sys.stdout.write("\"" + x + "\"" + ",")
 
-    sys.stdout.write ("\n")
+    sys.stdout.write("\n")
     sys.stdout.flush()
 
     # Read the response from STDIN as the test response
-    return sys.stdin.readline().strip();
-	
+    return sys.stdin.readline().strip()
+
 
 def endTest(stack_level=1):
     """
     Orders the end of the test.  This will terminate the test parser and disponse of any resources
     held by the test libraries (including quarch module connections)      
 
-    """  
+    """
 
     caller = getframeinfo(stack()[stack_level][0])
 
-    sys.stdout.write ("ENDTEST," + str(caller.filename) + "," + str(caller.lineno));
-    sys.stdout.write ("\n");
+    sys.stdout.write("ENDTEST," + str(caller.filename) + "," + str(caller.lineno))
+    sys.stdout.write("\n")
     sys.stdout.flush()
-	
-    
 
-def beginTestBlock (message_text, stack_level=1):
+
+def beginTestBlock(message_text, stack_level=1):
     """
     Notes the start of a block of tests.  This allows multiple nested layers of related tests
     to improve readability of the results.  This has no effect on the test execution, only
@@ -109,21 +109,21 @@ def beginTestBlock (message_text, stack_level=1):
     test_response : str
         String returned from test function. This will be "1" on success and "0" on error     
             
-    """  
+    """
 
     caller = getframeinfo(stack()[stack_level][0])
 
     # Write the command and params to STDOUT
-    sys.stdout.write ("BLOCK_START," + str(caller.filename) + "," + str(caller.lineno) + "," + "\"" + message_text + "\"")
-    sys.stdout.write ("\n")
+    sys.stdout.write(
+        "BLOCK_START," + str(caller.filename) + "," + str(caller.lineno) + "," + "\"" + message_text + "\"")
+    sys.stdout.write("\n")
     sys.stdout.flush()
 
     # Read the response from STDIN
     return sys.stdin.readline().strip()
-	
 
 
-def endTestBlock (stack_level=1):
+def endTestBlock(stack_level=1):
     """
     Notes the end of a block of tests.  This allows multiple nested layers of related tests
     to improve readability of the results.  This has no effect on the test execution, only
@@ -134,14 +134,38 @@ def endTestBlock (stack_level=1):
     test_response : str
         String returned from test function. This will be "1" on success and "0" on error      
             
-    """  
+    """
 
     caller = getframeinfo(stack()[stack_level][0])
 
     # Write the command and params to STDOUT
-    sys.stdout.write ("BLOCK_END," + str(caller.filename) + "," + str(caller.lineno) + "," + "\"")
-    sys.stdout.write ("\n")
+    sys.stdout.write("BLOCK_END," + str(caller.filename) + "," + str(caller.lineno) + "," + "\"")
+    sys.stdout.write("\n")
     sys.stdout.flush()
 
     # Read the response from STDIN
     return sys.stdin.readline().strip()
+
+
+def GetVariable(package: str, var_name: str) -> str:
+    """
+    Access a TestCenter user variable and return its value.
+
+    Args:
+        package: Name of the TestCenter package to access. UNUSED
+        var_name: Name of the string variable to return.
+
+    Returns:
+        The text of the stored variable.
+    """
+
+    # Get caller file and line number
+    caller = getframeinfo(stack()[stack_level][0])
+
+    # Write the command and params to STDOUT
+    print(f"GET_VARIABLE,{str(caller.filename)},{str(caller.lineno)},{var_name}")
+
+    # Read the response from STDIN
+    response = sys.stdin.readline().strip()
+
+    return response