quarchpy 2.1.20.dev2__py2.py3-none-any.whl → 2.1.20.dev3__py2.py3-none-any.whl

quarchpy/qis/qisFuncs.py.bak

@@ -1,265 +0,0 @@
-"""
-Contains general functions for starting and stopping QIS processes
-"""
-
-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.user_interface.user_interface import printText
-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 = "java -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:
-            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
-        timeout = 10
-        last_error = ""
-        last_out = ""
-        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
-
-    #change directory back to start directory 
-    os.chdir(current_direc)
-
-
-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
-        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":
-                logging.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
-
-
-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
-    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(' --------------------------------------------')
-    except:
-        for idx in range(len(devList)):
-            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: "))
-    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/run.py.bak

@@ -1,283 +0,0 @@
-"""
-This module allows specific quarchpy utilities and embedded applications to be run from the command line
-using the format:
-> python -m quarchpy.run [option]
-"""
-
-# 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.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
-from quarchpy.user_interface import*
-from quarchpy.debug.simple_terminal import main as simple_terminal_main
-import sys, logging, traceback
-
-def main(args):
-    """
-    Main function parses the arguments from the run command only
-    """
-   
-    # Run the internal parser
-    _parse_run_options(args)  
-
-def _parse_run_options(args):
-    """
-    Parses the command line argument supplied via the quarchpy.run command line option
-
-    Parameters
-    ----------
-    args : list[str]
-        List of arguments to process
-
-    """
-
-    found = False
-
-    # Arguments may not always be present
-    if (len(args) > 0):
-        # Obtain the list of commands that can be executed
-        run_options = _get_run_options()
-        # Try to locate a matching command name, executing it if found and passing in the remaining parameters
-        main_arg = args[0]
-        for item in run_options:
-            if (item[0] == main_arg or item[1] == main_arg):
-                found = True
-                item[2](args[1:])
-    else:
-        logging.info("No args passed")
-        found = True
-        _run_help_function()
-
-    # If parsing failed, error and print the available commands
-    if (found == False):
-        logging.error("ERROR - Command line argument not recognised")
-        _run_help_function()
-
-        
-def _get_run_options():
-    """
-    Gets the list of options for quarchpy.run commands which can be called.  This is used internally to access the available commands
-    
-    Returns
-    -------
-    options_list : list[list[object]]
-        List of call parameters, each of which is a list of objects making up the function description
-
-    """
-
-    run_options = []
-
-    #                   [old_name           , simple_name    , execute_function              , help_description]
-    run_options.append (["debug_info"       , "debug"       , _run_debug_function          , "Runs system tests which displays useful information for debugging"])
-    run_options.append ([None               , "module_debug", _run_module_debug_function   , "Gives debug info on selected module and DUT"])
-    run_options.append ([None               , "qcs"         , _run_qcs_function            , "Launches Quarch Compliance Suite server"])
-    run_options.append (["calibration_tool" , "calibration" , _run_calibration_function    , "Runs the Quarch power module calibration tool"])
-    run_options.append ([None               , "qis"         , _run_qis_function            , "Launches Quarch Instrument Server for communication with Quarch power modules"])
-    run_options.append ([None               , "qps"         , _run_qps_function            , "Launches Quarch Power Studios, for power capture and analysis"])
-    run_options.append (["simple_terminal"  , "terminal"    , _run_simple_terminal_function, "Runs the Simple Terminal script"])
-    run_options.append (["upgrade_quarchpy" , "upgrade"     , _run_upgrade_function        , "Detects if an update of Quarchpy is available and assists in the upgrade process"])
-    run_options.append (["h"                , "help"        , _run_help_function           , "Displays the help screen with a list of commands supported"])
-    run_options.append (["dd"               , "list_drives" , _run_show_drives_function    , "Displays a list of shown drives on the current system"])
-
-    return run_options
-
-def _run_simple_terminal_function(args=None):
-    """
-    Runs the Simple Terminal script
-
-    Parameters
-    ----------
-    None
-    """
-    simple_terminal_main()
-
-def _run_debug_function(args=None):
-    """
-    Executes the python debug/system test option, returning details of the installation to the user
-    for debug purposes
-
-    Parameters
-    ----------
-    args : list[str]
-        List of sub arguments to process
-
-    """
-
-    systemTestMain(args)
-
-def _run_module_debug_function(args=None):
-    """
-    Executes the python debug/system test option, returning details of the installation to the user
-    for debug purposes
-
-    Parameters
-    ----------
-    args : list[str]
-        List of sub arguments to process
-
-    """
-
-    moduleDebugMain(args)
-
-def _run_show_drives_function(args=None):
-    """
-    Shows a list of current found drives to the user.
-
-    Parameters
-    ----------
-    args : list[str]
-        List of sub arguments to process
-
-    """
-
-    try:
-        import QuarchpyQCS
-        from QuarchpyQCS.hostInformation import HostInformation
-        host_info = HostInformation()
-        host_info.display_drives()
-    except ImportError as err:
-        logging.error(err)
-        logging.error("Drive detection is now in the QCS standalone package. Please install the QCS package via:")
-        logging.error("'Pip install quarchQCS'")
-        logging.error("Then retry this command")
-
-def _run_qcs_function(args=None):
-    """
-    Executes the QCS server back end process
-
-    Parameters
-    ----------
-    args : list[str]
-        List of sub arguments to process
-
-    """
-
-    try:
-        import QuarchpyQCS
-        # from QuarchpyQCS.driveTestCore import main as driveTestCoreMain
-        from QuarchpyQCS.driveTestCore import main as driveTestCoreMain
-        driveTestCoreMain(args)
-    except ImportError as err:
-        logging.error(err)
-        logging.error("QCS is now a standalone package. Please install the QCS package via:")
-        logging.error("'Pip install quarchQCS'")
-        logging.error("Then retry this command")
-
-
-def _run_qis_function(args=None):
-    """
-    Executes Quarch Instrumentation Server
-
-    Parameters
-    ----------
-    args : list[str]
-        List of sub arguments to process
-
-    """
-    shutdown = False
-    if args != None:
-        for arg in args:
-            if "-shutdown" in arg:
-                shutdown = True
-                if isQisRunning() == True:
-                    printText("Closing QIS")
-                    closeQIS()
-                    break
-                else:
-                    printText("QIS is not running")
-
-    if shutdown is False:
-        startLocalQis(args=args)
-
-
-def _run_qps_function(args=None):
-    """
-    Executes Quarch Power Studio
-
-    Parameters
-    ----------
-    args : list[str]
-        List of sub arguments to process
-
-    """
-    shutdown = False
-    if args != None:
-        for arg in args:
-            if "-shutdown" in arg:
-                shutdown = True
-                if isQpsRunning() == True:
-                    printText("Closing QPS")
-                    closeQPS()
-                    break
-                else:
-                    printText("QPS is not running")
-
-    if shutdown is False:
-        startLocalQps(args=args)
-
-
-def _run_calibration_function(args=None):
-    """
-    Executes the calibration utility for power modules
-
-    Parameters
-    ----------
-    args : list[str]
-        List of sub arguments to process
-
-    """
-    try:
-        from quarchCalibration.calibrationUtil import main as calibrationUtilMain
-        retVal = calibrationUtilMain(args)
-        return retVal
-    except ImportError as err:
-        #TODO check err for a more specific "quarchCalibration" cannot be found rather than a generic import error
-
-        logging.error("Quarch Calibration is now in the quarchCalibration package. Please install the quarchCalibration package via:")
-        logging.error("'pip install quarchCalibration'")
-        logging.error("Then retry this command")
-        traceback.print_exc()
-
-
-
-
-def _run_upgrade_function(args=None):
-    """
-    Checks for updates to quarchpy and runs the update process if required
-
-    Parameters
-    ----------
-    args : list[str]
-        List of sub arguments to process
-
-    """
-
-    uprade_quarchpy_main(args)
-
-
-def _run_help_function(args=None):
-    """
-    Shows the quarchpy.run help screen
-
-    Parameters
-    ----------
-    args : list[str]
-        List of sub arguments to process
-
-    """
-
-    printText("quarchpy.run -[Command]")
-    # Iterate through all of the possible commands and print a nice help string for each
-    run_options = _get_run_options()
-    display_options = []
-    for item in run_options:        
-        short_name = item[1]        
-        description = item[3]
-        display_options.append([short_name,description])
-    displayTable(display_options, align="l", tableHeaders=["Command", "Description"])
-
-if __name__ == "__main__":
-    main (["qps"])
-    main (sys.argv[1:])