quarchpy 2.1.24.dev5__py2.py3-none-any.whl → 2.1.26__py2.py3-none-any.whl

quarchpy/_version.py

@@ -1 +1 @@
-__version__ = "2.1.24.dev5"
+__version__ = "2.1.26"

quarchpy/connection_specific/QPS/scriptCommands.txt

@@ -1,7 +1,7 @@
 QPS Command Summary
 Copyright (c) Quarch Ltd
-QPS v1.39
-Generated: 18-Mar-2024
+QPS v1.39.13
+Generated: 13-May-2024
 
 
 *** Commands ***
@@ -345,6 +345,19 @@ Default value: NONE
 Examples:
 $open recording qpsFile="C:\quarch\recordings\AC\AC_Gen_test\AC_Gen_Test.qps"
 
+Command: $progress check
+Description: Checks the progress of a specific QPS task
+Version: 2
+Arguments
+Argument: task
+Description: The task to be checked
+Index: 0
+Type: STRING
+Default value: NONE
+Acceptable values: [open recording]
+Examples:
+$progress check task="open recording"
+
 Command: $qis launch
 Description: Launches new QIS instance
 Version: 2
@@ -992,6 +1005,8 @@ $module scan ~ Scans for available devices
 
 $open recording ~ Opens a recording
 
+$progress check ~ Checks the progress of a specific QPS task
+
 $qis launch ~ Launches new QIS instance
 
 $qis shutdown ~ Shuts down current QIS instance

quarchpy/connection_specific/connection_QPS.py

@@ -140,6 +140,17 @@ class QpsInterface:
         time.sleep(
             sleep)  # Time must be allowed for QPS to Scan. If another scan request is sent it will time out and throw an error.
 
+    def get_list_details(self, sock=None):
+        if sock == None:
+            sock = self.sock
+        devString = self.sendCmdVerbose("$module list details")
+        #devString = self.sendAndReceiveText(sock, '$list details')
+        devString = devString.replace('>', '')
+        devString = devString.replace(r'\d+\) ', '')
+        devString = devString.split('\r\n')
+        devString = [x for x in devString if x]  # remove empty elements
+        return devString
+
     def getDeviceList(self, scan = True, ipAddress = None):
         deviceList = []
         scanWait = 2
@@ -182,4 +193,45 @@ class QpsInterface:
         #return list of devices
         return deviceList
 
+
+    def open_recording(self, file_path, cmdTimeout=5, pollInterval=3, startOpenTimout=5):
+        """
+
+        """
+        #print("Open recording at file : \""+str(file_path)+"\"")
+        self.sendCmdVerbose("$open recording qpsFile=\""+str(file_path)+"\"",timeout=cmdTimeout)
+        loadingStarted=False
+        message=""
+        startTime=time.time()
+        notLoadingMessageStartTime=None
+        while(1):
+            update=self.sendCmdVerbose("$progress check \"open recording\"",timeout=cmdTimeout)
+            #print(update)
+            m = re.search('\d+(\.\d+)?%', update)
+            if m: # A percentage was found
+                loadingStarted=True
+                found = float(m.group(0)[:-1])
+                user_interface.progressBar(found,100)
+                if found > 99.9: # This will catch the case we have 99.9999% or 100% loaded. recording with less that 1mill records auto return 100%
+                    message = "Passed, Recording opened, loading detected and complete."
+                    break
+            elif("Chart window is open but no loading is in progress." in update):
+                if loadingStarted ==True:
+                    # Loading started and has now ended, so we can exit the loop.
+                    message="Passed, Recording opened, loading detected and complete."
+                    break
+                else: # QPS has not started loading a recording.
+                    if notLoadingMessageStartTime == None:
+                        # Start a timer from now so that if loading doesn't take place between now and a timeout value,
+                        # we exit, stating that no loading started within the desired time.
+                        notLoadingMessageStartTime = time.time()
+                    elif time.time() - notLoadingMessageStartTime> startOpenTimout:
+                        message = "No detection that QPS started loading the recording within "+str(startOpenTimout)+"s."
+                        break
+
+            time.sleep(pollInterval) #Sleep pollInterval time, so we are not hammering QPS for updates while its busy loading.
+        time.sleep(1) #sleep outside the loop as there is a
+        return message
+
+
     

quarchpy/connection_specific/mDNS.py

@@ -0,0 +1,126 @@
+import platform  # For getting the operating system name
+import subprocess  # For executing a shell command
+
+from zeroconf import Zeroconf
+
+
+def ping(host):
+    """
+    Returns True if host (str) responds to a ping request.
+    """
+    # Option for the number of packets as a function of
+    param = '-n' if platform.system().lower() == 'windows' else '-c'
+
+    # Building the command. Ex: "ping -c 1 google.com"
+    command = ['ping', param, '1', host]
+
+    # Execute the ping command and capture the output and return code
+    result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+
+    # Check the return code and output to determine the result
+    if result.returncode == 0 and ("destination host unreachable" not in str(result.stdout).lower()):
+        return True  # Ping successful
+    else:
+        return False  # Ping failed
+
+
+class MyListener:
+    """
+    MyListener class to handle service updates, removals, and additions in Zeroconf
+    """
+
+    _instance = None
+
+    @classmethod
+    def get_instance(cls):
+        """
+        Get an instance of MyListener class. If none exists, create one.
+        """
+        if cls._instance is None:
+            cls._instance = MyListener()
+        return cls._instance
+
+    def __init__(self):
+        """
+        Initialize MyListener instance.
+        """
+        self.found_devices = {}
+        self.mdns_service_running = False
+        self.zeroconf = None
+        self.target_conn = None
+
+    def update_service(self, zc, type_, name):
+        """
+        Handle service update event.
+        """
+        info = zc.get_service_info(type_, name)
+        if "Quarch:" in str(info):
+            # decode the incoming properties from mdns
+            decoded_properties = {key.decode('utf-8'): value.decode('utf-8') for key, value in info.properties.items()}
+            decoded_ip = ".".join(str(byte) for byte in info.addresses[0])
+            self.get_instance().add_device(decoded_properties, decoded_ip)
+
+    def remove_service(self, zc, type_, name):
+        """
+        Handle service removal event.
+        """
+        return None
+
+    def add_service(self, zc, type_, name):
+        """
+        Handle service addition event.
+        """
+        info = zc.get_service_info(type_, name)
+        if "Quarch:" in str(info):
+            # decode the incoming properties from mdns
+            decoded_properties = {key.decode('utf-8'): value.decode('utf-8') for key, value in info.properties.items()}
+            decoded_ip = ".".join(str(byte) for byte in info.addresses[0])
+            self.get_instance().add_device(decoded_properties, decoded_ip)
+
+    def add_device(self, properties_dict, ip_address):
+        """
+        Add a device to the found devices dictionary.
+        """
+        qtl_num = "QTL" + properties_dict['86'] if '86' in properties_dict else None
+        # Check if module contains REST connection
+        if '84' in properties_dict:
+            # Check the user specified connection type
+            if self.get_instance().target_conn == "all" or self.get_instance().target_conn == "rest":
+                if properties_dict['84'] == '80':
+                    # print("Rest connection exists for device: " + qtl_num)
+                    # Updates the found devices dict
+                    self.get_instance().update_device_dict(device_dict={"REST:" + ip_address: qtl_num})
+        # Check if module contains TCP connection
+        if '85' in properties_dict:
+            # Check the user specified connection type
+            if self.get_instance().target_conn == "all" or self.get_instance().target_conn == "tcp":
+                if properties_dict['85'] == "9760":
+                    # print("TCP connection exists for device: " + qtl_num)
+                    # Updates the found devices dict
+                    self.get_instance().update_device_dict(device_dict={"TCP:" + ip_address: qtl_num})
+
+    def update_device_dict(self, device_dict):
+        """
+        Update the found devices dictionary.
+        """
+        self.get_instance().found_devices.update(device_dict)
+
+    def get_found_devices(self):
+        """
+        Get the found devices and perform ping check.
+        """
+        temp_dict = self.get_instance().found_devices
+        for key, value in list(temp_dict.items()):
+            result = ping(key[key.index(":") + 1:])
+            if not result or self.get_instance().target_conn not in key.lower():
+                del self.get_instance().found_devices[key]
+        print(str(self.get_instance().found_devices))
+        return self.get_instance().found_devices
+
+    def get_zeroconf(self):
+        """
+        Get the Zeroconf instance. If none exists, create one.
+        """
+        if self.get_instance().zeroconf is None:
+            self.get_instance().zeroconf = Zeroconf()
+        return self.get_instance().zeroconf

quarchpy/debug/SystemTest.py

@@ -1,5 +1,5 @@
-# from quarchpy import *
-# from quarchpy.device import *
+from quarchpy import *
+from quarchpy.device import *
 try:
     from importlib.metadata import distribution
 except:
@@ -7,11 +7,7 @@ except:
         from importlib_metadata import distribution
     except Exception as e:
         print("Failed to import distribution from importlib_metadata")
-    try:
 
-        from importlib_metadata import distribution
-    except:
-        print("here")
 import os
 import platform
 import sys

quarchpy/debug/SystemTest.py.bak

@@ -0,0 +1,200 @@
+from quarchpy import *
+from quarchpy.device import *
+try:
+    from importlib.metadata import distribution
+except:
+    try:
+        from importlib_metadata import distribution
+    except Exception as e:
+        print("Failed to import distribution from importlib_metadata")
+
+import os
+import platform
+import sys
+import subprocess
+from quarchpy._version import __version__
+
+def test_communication():
+    print("")
+    print("DEVICE COMMUNICATION TEST")
+    print("-------------------------")
+    print("")
+    deviceList = scanDevices('all', favouriteOnly=False)
+    print("Devices visible:\r\n" + str(deviceList))
+    print("")
+    moduleStr = userSelectDevice(deviceList, nice=True, additionalOptions=["Rescan", "Quit", "All Conn Types"])
+    if moduleStr == "quit":
+        print("User selected quit")
+        return 0
+    print("Selected module is: " + moduleStr)
+    # Create a device using the module connection string
+    myDevice = getQuarchDevice(moduleStr)
+    QuarchSimpleIdentify(myDevice)
+    # Close the module before exiting the script
+    myDevice.closeConnection()
+
+def test_system_info():
+    print("")
+    print("SYSTEM INFORMATION")
+    print("------------------")
+    print("OS Name: " + os.name)
+    print("Platform System: " + platform.system())
+    print("Platform: " + platform.platform())
+
+    if "nt" in os.name:
+        print("Platform Architecture: " + platform.architecture()[0])
+    else:
+        print(str(bytes(subprocess.check_output(['cat', '/etc/os-release'], stderr=subprocess.STDOUT)).decode()))
+    print("Platform Release:  " + platform.release())
+
+    try:
+        print("Quarchpy Version: " + get_quarchpy_version())
+    except:
+        print("Unable to detect Quarchpy version")
+    try:
+        print("Quarchpy info Location: " + str(distribution("quarchpy")._path))
+    except Exception as e:
+        print(e)
+        print("Unable to detect Quarchpy location")
+    try:
+        print("Python Version: " + sys.version)
+    except:
+        print("Unable to detect Python version")
+    try:
+        print("QIS version number: " + get_QIS_version())
+    except:
+        print("Unable to detect QIS version")
+    try:
+        javaVersion = bytes(subprocess.check_output(['java', '-version'], stderr=subprocess.STDOUT)).decode()
+        print("Java Version: " + str(javaVersion))
+    except:
+        print("Unable to detect java version"
+              "If Java is not installed then QIS and QPS will NOT run")
+    try:
+        javaLocation = get_java_location()
+        print("Java Location: " + str(javaLocation))
+    except:
+        print("Unable to detect java location"
+              "If Java is not installed then QIS and QPS will NOT run")
+
+    # Scan for all quarch devices on the system
+
+def QuarchSimpleIdentify(device1):
+    """
+    Prints basic identification test data on the specified module, compatible with all Quarch devices
+
+    Parameters
+    ----------
+    device1: quarchDevice
+        Open connection to a quarch device
+        
+    """
+    # Print the module name
+    print("MODULE IDENTIFY TEST")
+    print("--------------------")
+    print("")
+    print("Module Name: "),
+    print(device1.sendCommand("hello?"))
+    print("")
+    # Print the module identify and version information
+    print("Module Identity Information: ")
+    print(device1.sendCommand("*idn?"))
+
+def get_QIS_version():
+    """
+    Returns the version of QIS.  This is the version of QIS currenty running on the local system if one exists.
+    Otherwise the local version within quarchpy will be exectued and its version returned.
+
+    Returns
+    -------
+    version: str
+        String representation of the QIS version number
+        
+    """
+
+    qis_version = ""
+    my_close_qis = False
+    if isQisRunning() == False:
+        my_close_qis = True
+        startLocalQis(headless=True)
+        
+    myQis = qisInterface()
+    qis_version = myQis.sendAndReceiveCmd(cmd="$version")
+    if "No Target Device Specified" in qis_version:
+        qis_version = myQis.sendAndReceiveCmd(cmd="$help").split("\r\n")[0]
+    if my_close_qis:
+        myQis.sendAndReceiveCmd(cmd = "$shutdown")
+    return qis_version
+
+def get_java_location():
+    """
+    Returns the location of java.
+
+    Returns
+    -------
+    location: str
+        String representation of the java location.
+    """
+    if "windows" in platform.platform().lower():
+        location = bytes(subprocess.check_output(['where', 'java'], stderr=subprocess.STDOUT)).decode()
+    elif "linux" in platform.platform().lower():
+        location = bytes(subprocess.check_output(['whereis', 'java'], stderr=subprocess.STDOUT)).decode()
+    else:
+        location = "Unable to detect OS to check java version."
+    return location
+
+def get_quarchpy_version():
+    try:
+       return __version__
+    except:
+        return "Unknown"
+
+def fix_usb():
+    content_to_write = "SUBSYSTEM==\"usb\", ATTRS{idVendor}==\"16d0\", MODE=\"0666\"" \
+                       "SUBSYSTEM==\"usb_device\", ATTRS{idVendor}==\"16d0\", MODE=\"0666\""
+
+    if "centos" in str(platform.platform()).lower():
+        content_to_write = "SUBSYSTEM==\"usb\", ATTRS{idVendor}==\"16d0\", MODE=\"0666\", GROUP=*\n " \
+                           "SUBSYSTEM==\"usb_device\", ATTRS{idVendor}==\"16d0\", MODE=\"0666\", GROUP=*"
+
+    destination = "/etc/udev/rules.d/20-quarchmodules.rules"
+
+    f = open("/etc/udev/rules.d/20-quarchmodules.rules", "w")
+    f.write(content_to_write)
+    f.close()
+
+    os.system("udevadm control --reload")
+    os.system("udevadm trigger")
+
+    print("USB rule added to file : /etc/udev/rules.d/20-quarchmodules.rules")
+
+
+def main (args=None):
+    """
+    Main function to allow the system test to be called direct from the command line
+    """
+    bool_test_system_info = True
+    bool_test_communication = True
+    bool_fixusb=False
+    if args is not None and len(args)>0:
+        for arg in args:
+            if "--fixusb" in str(arg).lower():
+                bool_fixusb=True
+                # todo: Should we still be running the debug info stuff after this?
+            if "--skipsysteminfo" in str(arg).lower():
+                bool_test_system_info=False
+            if "--skipcommstest" in str(arg).lower():
+                bool_test_communication=False
+
+    if bool_fixusb:
+        fix_usb()
+    if bool_test_system_info:
+        test_system_info()
+    if bool_test_communication:
+        test_communication()
+
+
+if __name__ == "__main__":
+    main([])
+    #main(["--skipSystemInfo","--skipCommsTest"])
+    #main(["--fixusb"])