quarchpy 2.1.25__py2.py3-none-any.whl → 2.1.27__py2.py3-none-any.whl

quarchpy/_version.py

@@ -1 +1 @@
-__version__ = "2.1.25"
+__version__ = "2.1.27"

quarchpy/_version.py.bak

@@ -0,0 +1 @@
+__version__ = "2.1.26"

quarchpy/connection_specific/mDNS.py

@@ -1,6 +1,6 @@
 import platform  # For getting the operating system name
 import subprocess  # For executing a shell command
-
+import logging
 from zeroconf import Zeroconf
 
 
@@ -70,17 +70,27 @@ class MyListener:
         """
         Handle service addition event.
         """
+        logging.debug("Adding service: " +name)
         info = zc.get_service_info(type_, name)
+        # Log the service 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_properties ={}
+            for key, value in info.properties.items():
+                decoded_properties[ key.decode('utf-8')]=value.decode('utf-8')
+                pass
+            #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.
         """
+        logging.debug("Adding device: " +str(ip_address)+"\n"+str(properties_dict))
         qtl_num = "QTL" + properties_dict['86'] if '86' in properties_dict else None
         # Check if module contains REST connection
         if '84' in properties_dict:
@@ -110,11 +120,16 @@ class MyListener:
         Get the found devices and perform ping check.
         """
         temp_dict = self.get_instance().found_devices
+        remove_device = False
         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():
+            can_ping = ping(key[key.index(":") + 1:])
+            if can_ping is False:
+                remove_device=True # Remove the device if it can't be pinged
+            elif self.get_instance().target_conn not in key.lower() and self.get_instance().target_conn.lower() != "all":
+                remove_device = True # or if its of the wrong connection type.
+            if remove_device is True:
                 del self.get_instance().found_devices[key]
-        print(str(self.get_instance().found_devices))
+        logging.debug("Returning found devices "+str(self.get_instance().found_devices))
         return self.get_instance().found_devices
 
     def get_zeroconf(self):

quarchpy/connection_specific/mDNS.py.bak

@@ -0,0 +1,141 @@
+import platform  # For getting the operating system name
+import subprocess  # For executing a shell command
+import logging
+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.
+        """
+        logging.warning("Adding service: " +name)
+        info = zc.get_service_info(type_, name)
+        # Log the service name
+        if "Quarch:" in str(info):
+            # decode the incoming properties from mdns
+            decoded_properties ={}
+            for key, value in info.properties.items():
+                decoded_properties[ key.decode('utf-8')]=value.decode('utf-8')
+                pass
+            #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.
+        """
+        logging.warning("Adding device: " +str(ip_address)+"\n"+str(properties_dict))
+        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
+        remove_device = False
+        for key, value in list(temp_dict.items()):
+            can_ping = ping(key[key.index(":") + 1:])
+            if can_ping is False:
+                remove_device=True # Remove the device if it can't be pinged
+            elif self.get_instance().target_conn not in key.lower() and self.get_instance().target_conn.lower() != "all":
+                remove_device = True # or if its of the wrong connection type.
+            if remove_device is True:
+                del self.get_instance().found_devices[key]
+        logging.warning("Returning found devices "+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"])

quarchpy/docs/CHANGES.rst

@@ -13,6 +13,15 @@ Quarchpy
 Change Log
 ----------
 
+2.1.27
+------
+- new QPS 1.41 same QIS 1.43
+- mDNS scanning improvelemts 
+
+2.1.26
+------
+- minor bugfix
+
 2.1.25
 ------
 - New QPS 1.40 and Qis 1.43