quarchpy 2.2.19.dev3__tar.gz → 2.2.19.dev4__tar.gz

{quarchpy-2.2.19.dev3/quarchpy.egg-info → quarchpy-2.2.19.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quarchpy
-Version: 2.2.19.dev3
+Version: 2.2.19.dev4
 Summary: This packpage offers Python support for Quarch Technology modules.
 Author: Quarch Technology ltd
 Author-email: support@quarch.com
@@ -26,6 +26,7 @@ Requires-Dist: requests
 Requires-Dist: packaging
 Requires-Dist: quarchpy-binaries
 Requires-Dist: typing-extensions
+Requires-Dist: libusb-package
 Requires-Dist: telnetlib-313-and-up; python_version >= "3.13"
 Dynamic: author
 Dynamic: author-email

quarchpy-2.2.19.dev4/quarchpy/_version.py

@@ -0,0 +1 @@
+__version__ = "2.2.19.dev4"

{quarchpy-2.2.19.dev3 → quarchpy-2.2.19.dev4}/quarchpy/connection_specific/usb_libs/libusb1.py

@@ -46,9 +46,12 @@ except ImportError:
             sizeof(c_size_t), ))
 import ctypes.util
 import platform
-import os.path
+import os
 import sys
+import libusb_package
+import logging
 
+logger = logging.getLogger(__name__)
 
 class Enum(object):
     def __init__(self, member_dict, scope_dict=None):
@@ -171,6 +174,33 @@ def _loadLibrary():
     if sys.version_info[:2] >= (2, 6):
         loader_kw['use_errno'] = True
         loader_kw['use_last_error'] = True
+
+    # Try System Library FIRST on Linux/Unix to avoid deadlocks with bundled library
+    if system not in ['Windows', 'Darwin']:
+        try:
+            return dll_loader('libusb-1.0' + suffix, **loader_kw)
+        except OSError:
+            pass
+
+    # BUNDLED SEARCH (Now acts as a fallback for Linux/Unix if system search fails, and primary search for Windows/macOS)
+    try:
+        # First try using find_library to get the path to the bundled library (Windows/macOS)
+        bundled_path = libusb_package.find_library("usb-1.0")
+        if bundled_path:
+            return dll_loader(bundled_path, **loader_kw)
+        # If that failed (macOS/Linux), find the file manually
+        # Get the folder where libus_package is located
+        wrapper_dir = os.path.dirname(libusb_package.__file__)
+        # Look for the dylib/so in that folder
+        potential_path = os.path.join(wrapper_dir, "libusb-1.0" + suffix)
+        if os.path.exists(potential_path):
+            bundled_path = potential_path
+        if bundled_path:
+            return dll_loader(bundled_path, **loader_kw)
+    except Exception as e:
+        logger.debug("Bundled library failed to load: %s", e)
+        pass  # If bundled fails, proceed to system search below
+
     try:
         return dll_loader('libusb-1.0' + suffix, **loader_kw)
     except OSError:

{quarchpy-2.2.19.dev3 → quarchpy-2.2.19.dev4}/quarchpy/device/scanDevices.py

@@ -249,25 +249,40 @@ def list_network(target_conn="all", debugPrint=False, lanTimeout=1, ipAddressLoo
             network_modules = {}
             msg_received = None
             counter += 1
-            # Receive raw message until timeout, then break.
+
             try:
+                # recvfrom returns a tuple: (bytes_data, (address, port))
                 msg_received = mySocket.recvfrom(1024)
             except Exception as e:
                 logger.debug(str(e))
-                # check if any a device was targeted directly and allow parse
                 if specifiedDevice is not None:
                     msg_received = specifiedDevice
                     specifiedDevice = None
                 else:
                     break
-            cont = 0
 
-            # Used split \r\n since values of 13 or 10 were looked at as /r and /n when using splitlines
-            # This fixes for all cases except if 13 is followed by 10.
-            splits = msg_received[0].split(b"\r\n")
-            del splits[-1]
+            # --- ROBUST DATA EXTRACTION ---
+            # If msg_received is a tuple (data, addr), split them out
+            if isinstance(msg_received, tuple) and len(msg_received) >= 2:
+                raw_payload = msg_received[0]
+                addr_info = msg_received[1]  # This is (ip, port)
+            else:
+                # Fallback if data is raw bytes or something else
+                raw_payload = msg_received
+                addr_info = ("0.0.0.0", 0)
 
-            # Decode the discovered device and extend the provided discovered_devices list if required
+            # Ensure we have bytes to split
+            if isinstance(raw_payload, bytes):
+                splits = raw_payload.split(b"\r\n")
+            else:
+                continue  # Skip this iteration if we don't have valid data
+
+            # Remove empty trailing element if it exists
+            if splits and splits[-1] == b"":
+                del splits[-1]
+            # ------------------------------
+
+            # Decode and extend discovered_devices
             if discovered_devices is not None:
                 idn_info = IDNInfo()
                 fix_idn_info = FixtureIDNInfo()
@@ -277,18 +292,23 @@ def list_network(target_conn="all", debugPrint=False, lanTimeout=1, ipAddressLoo
                 discovered_device.populate_device_info()
                 discovered_devices.append(discovered_device)
 
+            cont = 0
             for lines in splits:
                 if cont <= 1:
                     index = cont
                     data = repr(lines).replace("'", "").replace("b", "")
                     cont += 1
                 else:
-                    index = repr(lines[0]).replace("'", "")
+                    # lines[0] returns an int, so we use slicing lines[0:1] to keep it bytes
+                    index = repr(lines[0:1]).replace("'", "").replace("b", "")
                     data = repr(lines[1:]).replace("'", "").replace("b", "")
                 network_modules[index] = data
+
             module_name = get_user_level_serial_number(network_modules)
-            logger.debug("Found UDP response: " + module_name)
-            ip_module = msg_received[1][0].strip()
+            logger.debug("Found UDP response: " + str(module_name))
+
+            # FIXED: Safely get the IP from our extracted addr_info
+            ip_module = addr_info[0].strip() if isinstance(addr_info, (tuple, list)) else "Unknown"
             try:
                 # Add a QTL before modules without it.
                 if "QTL" not in module_name.decode("utf-8"):
@@ -298,32 +318,43 @@ def list_network(target_conn="all", debugPrint=False, lanTimeout=1, ipAddressLoo
                 if "QTL" not in module_name:
                     module_name = "QTL" + module_name
 
+            # Helper to check if this module already exists in our list with a proper IP
+            def is_duplicate_ghost(name, current_modules, protocol):
+                if ip_module != "0.0.0.0":
+                    return False
+                # Check if any existing entry for this protocol has the same module name
+                return any(m_name == name for key, m_name in current_modules.items() if key.startswith(protocol))
+
+            # Ensure module_name is a string for dictionary values and logging
+            if isinstance(module_name, bytes):
+                module_name = module_name.decode("utf-8", errors="ignore")
+
             # Checks if there's a value in the TELNET key.
-            if target_conn.lower() == "all" or target_conn.lower() == "telnet":
+            if target_conn.lower() in ["all", "telnet"]:
                 if network_modules.get("\\x8a") or network_modules.get("138"):
-                    # Append the information to the list.
-                    lan_modules["TELNET:" + ip_module] = module_name
-                    logger.debug("Found Telnet module: " + module_name)
+                    if not is_duplicate_ghost(module_name, lan_modules, "TELNET:"):
+                        lan_modules[f"TELNET:{ip_module}"] = module_name
+                        logger.debug(f"Found Telnet module: {module_name} at {ip_module}")
 
             # Checks if there's a value in the REST key.
-            if target_conn.lower() == "all" or target_conn.lower() == "rest":
+            if target_conn.lower() in ["all", "rest"]:
                 if network_modules.get("\\x84") or network_modules.get("132"):
-                    # Append the information to the list.
-                    lan_modules["REST:" + ip_module] = module_name
-                    logger.debug("Found REST module: " + module_name)
+                    if not is_duplicate_ghost(module_name, lan_modules, "REST:"):
+                        lan_modules[f"REST:{ip_module}"] = module_name
+                        logger.debug(f"Found REST module: {module_name} at {ip_module}")
 
             # Checks if there's a value in the TCP key.
-            if target_conn.lower() == "all" or target_conn.lower() == "tcp":
+            if target_conn.lower() in ["all", "tcp"]:
                 if network_modules.get("\\x85") or network_modules.get("133"):
-                    # Append the information to the list.
-                    lan_modules["TCP:" + ip_module] = module_name
-                    logger.debug("Found TCP module: " + module_name)
+                    if not is_duplicate_ghost(module_name, lan_modules, "TCP:"):
+                        lan_modules[f"TCP:{ip_module}"] = module_name
+                        logger.debug(f"Found TCP module: {module_name} at {ip_module}")
         mySocket.close()
     if ipAddressLookup is not None:
         if moduleFound is None:
             printText("IP Scan failed, no module found.")
         else:
-            printText("IP Scan succeeded, module found: " + moduleFound)
+            printText("IP Scan succeeded, module found: " + str(moduleFound))
     logger.debug("Finished UDP scan")
     retVal.update(lan_modules)
     return retVal
@@ -551,86 +582,59 @@ Scans for Quarch modules across the given interface(s). Returns a dictionary of
 '''
 
 
-def scanDevices(target_conn="all", lanTimeout=1, scanInArray=True, favouriteOnly=True, filterStr=None,
-                module_type_filter=None, ipAddressLookup=None, discovered_devices=None):
-    logger.info(f"Starting scanDevices (target_conn={target_conn}, lanTimeout={lanTimeout})")
+def scanDevices(target_conn="all", lanTimeout=1, scanInArray=True, favouriteOnly=True, filterStr=None, module_type_filter=None, ipAddressLookup=None, discovered_devices=None):
     foundDevices = dict()
     scannedArrays = list()
 
-    # --- mDNS SETUP ---
-    logger.info("Initializing mDNS/Zeroconf listener...")
-    try:
-        mdns_listener = MyListener().get_instance()
-        zeroconf = mdns_listener.get_zeroconf()
-
-        logger.info("Starting mDNS ServiceBrowser (scan_mDNS)...")
-        browser = scan_mDNS(mdns_listener, zeroconf)
+    # Setup mdns with zeroconf
+    # Ensure listener/zeroconf instance stay persistent (ensures only one thread is used for each scan cycle)
+    mdns_listener = MyListener().get_instance()
+    zeroconf = mdns_listener.get_zeroconf()
+    # Setup new mdns discovery service for every scan cycle
+    browser = scan_mDNS(mdns_listener, zeroconf)
+    # Set target_conn
+    mdns_listener.target_conn = target_conn.lower()
 
-        mdns_listener.target_conn = target_conn.lower()
-        logger.info("mDNS initialization complete.")
-    except Exception as e:
-        logger.error(f"FAILED to initialize mDNS: {e}", exc_info=True)
-
-    # --- SCANNING LOGIC ---
     if target_conn.lower() == "all":
-        logger.info("Commencing 'ALL' connection type scan...")
-
-        logger.info("Starting USB Scan (list_USB)...")
         foundDevices = list_USB(discovered_devices=discovered_devices)
-        logger.info(f"USB Scan complete. Found {len(foundDevices)} potential devices.")
-
-        logger.info("Starting Serial Scan (list_serial)...")
         foundDevices = mergeDict(foundDevices, list_serial())
-        logger.info("Serial Scan complete.")
-
         try:
-            logger.info("Starting Network UDP Scan (list_network)...")
-            foundDevices = mergeDict(foundDevices,
-                                     list_network("all", ipAddressLookup=ipAddressLookup, lanTimeout=lanTimeout,
-                                                  discovered_devices=discovered_devices))
-
-            logger.info("Retrieving discovered devices from mDNS listener...")
+            # This will fail if the test machine is not connected to a network
+            foundDevices = mergeDict(foundDevices, list_network("all", ipAddressLookup=ipAddressLookup, lanTimeout=lanTimeout, discovered_devices=discovered_devices))
             foundDevices = mergeDict(foundDevices, mdns_listener.get_found_devices())
         except Exception as e:
-            logger.error(f"Network scan sequence failed: {e}", exc_info=True)
+            logger.error(e)
             logger.warning("Network scan failed, check network connection")
 
-    elif target_conn.lower() == "serial":
-        logger.info("Commencing Serial-only scan...")
+    if target_conn.lower() == "serial":
         foundDevices = list_serial()
 
-    elif target_conn.lower() == "usb":
-        logger.info("Commencing USB-only scan...")
+    if target_conn.lower() == "usb":
         foundDevices = list_USB()
 
-    elif target_conn.lower() in ["tcp", "rest", "telnet"]:
-        logger.info(f"Commencing {target_conn} specific scan...")
+    if target_conn.lower() == "tcp" or target_conn.lower() == "rest" or target_conn.lower() == "telnet":
         foundDevices = list_network(target_conn, ipAddressLookup=ipAddressLookup, lanTimeout=lanTimeout)
         foundDevices = mergeDict(foundDevices, mdns_listener.get_found_devices())
 
-    # --- ARRAY SCANNING ---
     if scanInArray:
-        logger.info("Checking discovered devices for Array Controllers...")
-        for k, v in foundDevices.items():
+        for k, v in foundDevices.items():  # k=Connection target, v=serial number
             if k not in scannedArrays:
                 scannedArrays.append(k)
                 if isThisAnArrayController(v):
-                    logger.info(f"Device {v} at {k} is an Array Controller. Scanning sub-modules...")
                     try:
                         myQuarchDevice = quarchDevice(k)
                         myArrayController = quarchArray(myQuarchDevice)
                         scannedDevices = myArrayController.scanSubModules()
                         foundDevices = mergeDict(foundDevices, scannedDevices)
                         myArrayController.close_connection()
-                        logger.info(f"Finished sub-module scan for {v}.")
                     except Exception as e:
-                        logger.debug(f"Array sub-scan error for {k}: {e}", exc_info=True)
+                        logger.debug(e, exc_info=True)
+                        logger.debug("Cannot get serial number. Quarch device may be in use by another program.")
                         foundDevices[k] = "DEVICE IN USE"
 
-    # --- FILTERING & SORTING ---
     if favouriteOnly:
-        logger.info("Applying connection favorites filter...")
-        # (Internal sorting logic kept the same)
+
+        # Sort list in order of connection type preference. Can be changed by changing position in conPref list. This must be done so that it is in the correct format for picking the favourite connections.
         index = 0
         sortedFoundDevices = {}
         conPref = ["USB", "TCP", "SERIAL", "REST", "TELNET"]
@@ -641,38 +645,32 @@ def scanDevices(target_conn="all", lanTimeout=1, scanInArray=True, favouriteOnly
             index += 1
         foundDevices = sortedFoundDevices
 
+        # new dictionary only containing one favourite connection to each device.
         favConFoundDevices = {}
+        index = 0
         for k, v in sortedFoundDevices.items():
             if favConFoundDevices == {} or not v in favConFoundDevices.values():
                 favConFoundDevices[k] = v
         foundDevices = favConFoundDevices
 
-    logger.info("Sorting found devices alphabetically...")
+    # Sort by alphabetic order of key
+    sortedFoundDevices = {}
     sortedFoundDevices = sorted(foundDevices.items(), key=operator.itemgetter(1))
     foundDevices = dict(sortedFoundDevices)
-
     if filterStr is not None:
-        logger.info(f"Applying string filters: {filterStr}")
         filteredDevices = {}
         for k, v in foundDevices.items():
             for j in filterStr:
-                if j in v or "LOCKED MODULE" in v:
+                if (
+                        j in v or "LOCKED MODULE" in v):  #show locked modules too incase the module you are looking for is on the system but is locked
                     filteredDevices[k] = v
         foundDevices = filteredDevices
 
+    # used to filter module via type ( Power / Drive / ...)
     if module_type_filter:
-        logger.info(f"Applying module type filter: {module_type_filter}")
         foundDevices = filter_module_type(module_type_filter, foundDevices)
-
-    # --- CLEANUP ---
-    logger.info("Canceling mDNS ServiceBrowser and closing threads...")
-    try:
-        browser.cancel()
-        logger.info("mDNS browser canceled successfully.")
-    except Exception as e:
-        logger.error(f"Error during mDNS browser cancellation: {e}")
-
-    logger.info(f"scanDevices complete. Returning {len(foundDevices)} devices.")
+    # Cancels the mdns discovery service (required to close active thread)
+    browser.cancel()
     return foundDevices
 
 
@@ -761,4 +759,4 @@ def userSelectDevice(scanDictionary=None, scanFilterStr=None, favouriteOnly=True
             favouriteOnly = False
         else:
             # Return the address string of the selected module
-            return userStr
+            return userStr

{quarchpy-2.2.19.dev3 → quarchpy-2.2.19.dev4/quarchpy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quarchpy
-Version: 2.2.19.dev3
+Version: 2.2.19.dev4
 Summary: This packpage offers Python support for Quarch Technology modules.
 Author: Quarch Technology ltd
 Author-email: support@quarch.com
@@ -26,6 +26,7 @@ Requires-Dist: requests
 Requires-Dist: packaging
 Requires-Dist: quarchpy-binaries
 Requires-Dist: typing-extensions
+Requires-Dist: libusb-package
 Requires-Dist: telnetlib-313-and-up; python_version >= "3.13"
 Dynamic: author
 Dynamic: author-email

{quarchpy-2.2.19.dev3 → quarchpy-2.2.19.dev4}/quarchpy.egg-info/requires.txt

@@ -5,6 +5,7 @@ requests
 packaging
 quarchpy-binaries
 typing-extensions
+libusb-package
 
 [:python_version >= "3.13"]
 telnetlib-313-and-up

{quarchpy-2.2.19.dev3 → quarchpy-2.2.19.dev4}/setup.py

@@ -66,6 +66,7 @@ setup(name='quarchpy',
             'packaging',
             'quarchpy-binaries',
             'typing-extensions',
+            'libusb-package',
             'telnetlib-313-and-up; python_version >= "3.13"'],
       python_requires='>=3.7',
       include_package_data=True,

quarchpy-2.2.19.dev3/quarchpy/_version.py

@@ -1 +0,0 @@
-__version__ = "2.2.19.dev3"