quarchpy 2.2.17.dev2__py3-none-any.whl → 2.2.17.dev3__py3-none-any.whl

quarchpy/__init__.py

@@ -6,16 +6,34 @@ import logging
 from pathlib import Path
 from logging.handlers import RotatingFileHandler
 
+
+# --- Dynamic Level Synchronization ---
+class SyncWithRootFilter(logging.Filter):
+    """
+    A filter that dynamically checks the root logger's level.
+    This allows the quarchpy console handler to 'point' to the
+    global python log level even if it changes mid-script.
+    """
+
+    def filter(self, record):
+        # Dynamically fetch the root logger's effective level
+        root_level = logging.getLogger().getEffectiveLevel()
+        # Only allow the log record if its level is >= the current root level
+        return record.levelno >= root_level
+
+
 logger = logging.getLogger("quarchpy")
+
+# Master Valve: Must stay DEBUG so the File Handler captures everything.
 logger.setLevel(logging.DEBUG)
 
-# Don't propagate to root unless you want duplicate output
+# Propagate to root is False because we provide our own console handler.
+# If True, you would see duplicate logs if the user also has a root handler.
 logger.propagate = False
 
 # Only add handlers once
 if not logger.handlers:
-
-    # File handler (always debug)
+    # 1. File handler (Always capture DEBUG for the 'permanent record')
     log_dir = Path.home() / ".quarchpy"
     log_dir.mkdir(exist_ok=True)
     logfile = log_dir / "quarchpy.log"
@@ -28,9 +46,15 @@ if not logger.handlers:
     ))
     logger.addHandler(file_handler)
 
-    # Console: default WARNING
+    # 2. Console: Dynamically mirrors the python root log level
     console_handler = logging.StreamHandler()
-    console_handler.setLevel(logging.WARNING)
+
+    # We set this to NOTSET (0) so the handler itself doesn't block anything...
+    console_handler.setLevel(logging.NOTSET)
+
+    # ...instead, we use the custom filter to do the dynamic level check.
+    console_handler.addFilter(SyncWithRootFilter())
+
     console_handler.setFormatter(logging.Formatter(
         "%(asctime)s [%(levelname)s] %(name)s: %(message)s",
         "%Y-%m-%d %H:%M:%S"
@@ -42,9 +66,14 @@ if not logger.handlers:
 def configure_logging(console_level=None, file_level=None, file_path=None):
     """Reconfigure quarchpy logging safely."""
     for handler in logger.handlers:
-        # Change console level
-        if isinstance(handler, logging.StreamHandler):
+        # Change console level (Note: Setting this overrides the SyncWithRootFilter behavior)
+        if isinstance(handler, logging.StreamHandler) and not isinstance(handler, RotatingFileHandler):
             if console_level is not None:
+                # If the user explicitly sets a level, we remove the dynamic filter
+                # so it behaves exactly as the user requested.
+                for f in handler.filters:
+                    if isinstance(f, SyncWithRootFilter):
+                        handler.removeFilter(f)
                 handler.setLevel(console_level)
 
         # Change file level and path
@@ -54,61 +83,40 @@ def configure_logging(console_level=None, file_level=None, file_path=None):
             if file_path is not None:
                 handler.baseFilename = str(file_path)
 
-    logger.info("quarchpy logging reconfigured")
-
-
-# Adds / to the path.
-folder2add = os.path.realpath(os.path.abspath(os.path.split(inspect.getfile( inspect.currentframe() ))[0]) + "//")
-if folder2add not in sys.path:
-    sys.path.insert(0, folder2add)
-
-# Adds /disk_test to the path.
-folder2add = os.path.realpath(os.path.abspath(os.path.split(inspect.getfile( inspect.currentframe() ))[0]) + "//disk_test")
-if folder2add not in sys.path:
-    sys.path.insert(0, folder2add)
+    logger.info(
+        f"quarchpy logging reconfigured console_level:{console_level} file_level:{file_level} file_path:{file_path}")
 
-# Adds /connection_specific to the path.
-folder2add = os.path.realpath(os.path.abspath(os.path.split(inspect.getfile( inspect.currentframe() ))[0]) + "//connection_specific")
-if folder2add not in sys.path:
-    sys.path.insert(0, folder2add)
 
-# Adds /serial to the path.
-folder2add = os.path.realpath(os.path.abspath(os.path.split(inspect.getfile( inspect.currentframe() ))[0]) + "//connection_specific//serial")
-if folder2add not in sys.path:
-    sys.path.insert(0, folder2add)
+# --- Path Management (Maintain existing legacy behavior) ---
+base_path = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
+folders = [
+    "",
+    "disk_test",
+    "connection_specific",
+    os.path.join("connection_specific", "serial"),
+    os.path.join("connection_specific", "QIS"),
+    os.path.join("connection_specific", "usb_libs"),
+    "config_files"
+]
 
-# Adds /QIS to the path.
-folder2add = os.path.realpath(os.path.abspath(os.path.split(inspect.getfile( inspect.currentframe() ))[0]) + "//connection_specific//QIS")
-if folder2add not in sys.path:
-    sys.path.insert(0, folder2add)
+for folder in folders:
+    folder2add = os.path.realpath(os.path.join(base_path, folder))
+    if folder2add not in sys.path:
+        sys.path.insert(0, folder2add)
 
-# Adds /usb_libs to the path.
-folder2add = os.path.realpath(os.path.abspath(os.path.split(inspect.getfile( inspect.currentframe() ))[0]) + "//connection_specific//usb_libs")
-if folder2add not in sys.path:
-    sys.path.insert(0, folder2add)
-
-# Adds /usb_libs to the path.
-folder2add = os.path.realpath(os.path.abspath(os.path.split(inspect.getfile( inspect.currentframe() ))[0]) + "//config_files")
-if folder2add not in sys.path:
-    sys.path.insert(0, folder2add)
-
-# Basic functions imported up to the root module in the package
+# --- Public API Imports ---
 from debug.versionCompare import requiredQuarchpyVersion
-
-#importing legacy API functions to the root module in the package.  This is to avoid
-#breacking back-compatibility with old scripts.  Avoid using these direct imports
-#and use the managed sub module format instead (from quarchpy.device import *)
 from device import quarchDevice, getQuarchDevice, get_quarch_device
 from connection_specific.connection_QIS import QisInterface, QisInterface as qisInterface
 from connection_specific.connection_QPS import QpsInterface, QpsInterface as qpsInterface
 from qis.qisFuncs import isQisRunning, startLocalQis, GetQisModuleSelection
 from qis.qisFuncs import closeQis, closeQis as closeQIS
 from device.quarchPPM import quarchPPM
-from iometer.iometerFuncs import generateIcfFromCsvLineData, readIcfCsvLineData, generateIcfFromConf, runIOMeter, processIometerInstResults
+from iometer.iometerFuncs import generateIcfFromCsvLineData, readIcfCsvLineData, generateIcfFromConf, runIOMeter, \
+    processIometerInstResults
 from device.quarchQPS import quarchQPS
 from qps.qpsFuncs import isQpsRunning, startLocalQps, GetQpsModuleSelection
 from qps.qpsFuncs import closeQps, closeQps as closeQPS
 from disk_test.DiskTargetSelection import getDiskTargetSelection, getDiskTargetSelection as GetDiskTargetSelection
 from fio.FIO_interface import runFIO
-from device.scanDevices import scanDevices
-
+from device.scanDevices import scanDevices

quarchpy/_version.py

@@ -1 +1 @@
-__version__ = "2.2.17.dev2"
+__version__ = "2.2.17.dev3"

quarchpy/connection_specific/connection_QIS.py

@@ -609,8 +609,7 @@ class QisInterface:
             logger.warning(e)
             return False
 
-
-    def get_qis_module_selection(self, preferred_connection_only=True, additional_options="DEF_ARGS", scan=True) -> str:
+    def get_qis_module_selection(self, preferred_connection_only=True, additional_options=['rescan', 'all con types', 'ip scan'], scan=True) -> str:
         """
         Scans for available modules and allows the user to select one through an interactive selection process.
         Can also handle additional custom options and some built-in ones such as rescanning
@@ -634,10 +633,6 @@ class QisInterface:
             ValueError: Raised if no valid selection is made or the provided IP address is invalid.
         """
 
-        # Avoid mutable warning by adding the argument list in the function rather than the header
-        if additional_options == "DEF_ARGS":
-            additional_options = ['rescan', 'all con types', 'ip scan']
-
         table_headers = ["Modules"]
         ip_address = None
         favourite = preferred_connection_only
@@ -650,8 +645,8 @@ class QisInterface:
                 found_devices = self.qis_scan_devices(scan=scan, preferred_connection_only=favourite, ip_address=ip_address)
 
             my_device_id = listSelection(title="Select a module",message="Select a module",
-                                          selectionList=found_devices, additionalOptions= additional_options,
-                                          nice=True, tableHeaders=table_headers, indexReq=True)
+                                         selectionList=found_devices, additionalOptions= additional_options,
+                                         nice=True, tableHeaders=table_headers, indexReq=True)
 
             if my_device_id.lower() == 'rescan':
                 favourite = True

quarchpy/connection_specific/connection_QPS.py

@@ -1,15 +1,13 @@
 import sys
 import socket
-import time
-import datetime
-import subprocess
-import os
-import random
 import logging
-logger = logging.getLogger(__name__)
 import time
 import re
-from quarchpy.user_interface import user_interface
+from typing import Union, List, Optional, Any
+
+from quarchpy.user_interface import user_interface, User_interface, printText, listSelection, requestDialog
+
+logger = logging.getLogger(__name__)
 
 class QpsInterface:
     def __init__(self, host='127.0.0.1', port=9822):
@@ -113,7 +111,6 @@ class QpsInterface:
         time.sleep(0.3)
         return retVal
 
-
     def disconnect(self, targetDevice):
         self.sendCmdVerbose("$disconnect")
 
@@ -122,6 +119,7 @@ class QpsInterface:
            return self.sendCmdVerbose("close")
         else:
             return self.sendCmdVerbose(conString+" close")
+
     def scanIP(self, ipAddress, sleep=10):
         """
         Triggers QPS to look at a specific IP address for a quarch module
@@ -195,6 +193,71 @@ class QpsInterface:
         #return list of devices
         return deviceList
 
+    def get_qps_module_selection(
+            self,
+            preferred_connection_only: bool = True,
+            additional_options: Optional[List[str]] = None,
+            scan: bool = True
+    ) -> Optional[Any]:
+        """
+        Scans for QPS devices and prompts the user to select one.
+        """
+        if additional_options is None:
+            additional_options = ['rescan', 'all con types', 'ip scan']
+
+        # State variables
+        favourite = preferred_connection_only
+        ip_address = None
+
+        while True:
+            printText("QPS scanning for devices")
+
+            # 1. Fetch raw list from QPS
+            dev_list = self.getDeviceList(scan=scan, ipAddress=ip_address)
+
+            # 2. Check for empty results and sanitize
+            # If no devices found, force favorite mode off to prevent sorting bugs
+            if self._is_list_empty_or_error(dev_list):
+                favourite = False
+
+            # Remove REST devices (unsupported here)
+            dev_list = [x for x in dev_list if "rest" not in x]
+
+            # 3. Apply Sorting
+            # We always sort by type (USB > TCP), but we only deduplicate
+            # (hide extra connections) if 'favourite' is True.
+            dev_list = self._apply_favourite_sorting(dev_list, one_conn_per_mod=favourite)
+
+            # 4. Show UI
+            selection = listSelection(
+                title="Select a Quarch module",
+                message="Select a Quarch module",
+                selectionList=dev_list,
+                additionalOptions=additional_options,
+                nice=True,
+                tableHeaders=["Module"],
+                indexReq=True
+            )
+
+            # 5. Handle User Response
+            if selection == 'rescan':
+                ip_address = None
+                favourite = True
+                continue
+
+            elif selection == 'all con types':
+                printText('Displaying all connection types...')
+                favourite = False
+                continue
+
+            elif selection == 'ip scan':
+                ip_address = requestDialog("Please input IP Address of the module you would like to connect to: ")
+                favourite = False
+                continue
+
+            else:
+                # If it's not an option, it must be a device
+                return selection
 
     def open_recording(self, file_path, cmdTimeout=5, pollInterval=3, startOpenTimout=5):
         """
@@ -239,5 +302,50 @@ class QpsInterface:
         time.sleep(1) # sleep outside the loop as there is a
         return message
 
+    def _is_list_empty_or_error(self, dev_list: List[str]) -> bool:
+        """Checks if the returned list is empty or contains error messages."""
+        if not dev_list:
+            return True
+        first_item = dev_list[0].lower()
+        return "no device" in first_item or "no module" in first_item
+
+    def _apply_favourite_sorting(self, dev_list: List[str], one_conn_per_mod: bool = True) -> List[str]:
+        """
+        Sorts devices by connection preference (USB > TCP > ...).
+        If one_conn_per_mod is True, it also removes duplicate physical devices,
+        keeping only the highest priority connection type found.
+        """
+        sorted_list = []
+        seen_ids = set()
+        con_pref = ["USB", "TCP", "SERIAL", "REST", "TELNET"]
+
+        # Helper to process a device and decide if it should be added
+        def try_add_device(device_str):
+            if device_str in sorted_list:
+                return
+
+            if one_conn_per_mod:
+                # Extract ID (e.g., 'QTL1234' from 'USB::QTL1234')
+                if "::" in device_str:
+                    dev_id = device_str.split("::")[1]
+                    if dev_id in seen_ids:
+                        return  # Skip: We already have a preferred connection for this ID
+                    seen_ids.add(dev_id)
+
+            sorted_list.append(device_str)
+
+        # Pass 1: Add devices that match our specific preferences, in order
+        for pref in con_pref:
+            for device in dev_list:
+                if pref in device.upper():
+                    try_add_device(device)
+
+        # Pass 2: Add any remaining devices that didn't match preferences (Safety net)
+        # This ensures devices with weird/new connection types don't disappear.
+        for device in dev_list:
+            if device not in sorted_list:
+                try_add_device(device)
+
+        return sorted_list
 
     

quarchpy/connection_specific/connection_Telnet.py

@@ -1,7 +1,21 @@
-from telnetlib import Telnet
+import logging
 import time
-#from telnetlib3 import Telnet
+import sys
 
+# -----------------------------------------------------------
+# Import Logic: Handles Python 3.13+ deprecation of telnetlib
+# -----------------------------------------------------------
+try:
+    from telnetlib import Telnet
+except ImportError:
+    logging.debug("Standard telnetlib not found (Python 3.13+ detected). Using drop-in replacement.")
+    try:
+        from telnetlib313andup import Telnet
+    except ImportError as e:
+        logging.error("CRITICAL: 'telnetlib313andup' is not installed.")
+        logging.error("Please run: pip install telnetlib-313-and-up")
+        raise e
+# -----------------------------------------------------------
 
 class TelnetConn:
     def __init__(self, ConnTarget):
@@ -14,14 +28,14 @@ class TelnetConn:
         self.Connection.close()
         # The closed device reports as in use if a connection is opened to it within 0.05s.
         # This happens during scanning as rest detects the device and shows it as "in use" Putting a sleep here
-        #  allows time for the connection to be close,
+        # allows time for the connection to be close,
         time.sleep(0.15)
         return True
 
     def sendCommand(self, Command, expectedResponse = True):
         self.Connection.write((Command + "\r\n").encode('latin-1'))
-        self.Connection.read_until(b"\r\n",3)
-        Result = self.Connection.read_until(b">",3)[:-1]
+        self.Connection.read_until(b"\r\n", 3)
+        Result = self.Connection.read_until(b">", 3)[:-1]
         Result = Result.decode()
         Result = Result.strip('> \t\n\r')
         return Result.strip()

quarchpy/connection_specific/jdk_jres/fix_permissions.py

@@ -11,11 +11,8 @@ def main():
     current_os = platform.system()
     if current_os != "Windows":
         print("Fixing Permissions")
-        # Check the current OS
-        current_os = platform.system()
         # JRE path
         java_path = quarchpy_binaries.get_jre_home()
-    
         # Ensure the jres folder has the required permissions
         subprocess.call(['chmod', '-R', '+rwx', java_path])
 

quarchpy/connection_specific/usb_libs/libusb1.py

@@ -48,6 +48,7 @@ import ctypes.util
 import platform
 import os.path
 import sys
+import libusb_package
 
 class Enum(object):
     def __init__(self, member_dict, scope_dict=None):
@@ -170,6 +171,26 @@ def _loadLibrary():
     if sys.version_info[:2] >= (2, 6):
         loader_kw['use_errno'] = True
         loader_kw['use_last_error'] = True
+
+    try:
+        bundled_path = libusb_package.find_library("usb-1.0")
+
+        # If that failed (macOS/Linux), find the file manually
+        import os
+        # 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:
+        pass  # If bundled fails, proceed to system search below
+
     try:
         return dll_loader('libusb-1.0' + suffix, **loader_kw)
     except OSError:

quarchpy/debug/SystemTest.py

@@ -236,24 +236,82 @@ def _get_logging_directory(app_type: AppType = "QuarchPy") -> str:
 
     return log_dir
 
+
+import os
+import sys
+import platform
+
+
 def fix_usb():
+    print("\n--- USB Permission Setup ---")
+
+    rule_file_path = "/etc/udev/rules.d/20-quarchmodules.rules"
+
+    # --- CHECK EXISTING INSTALLATION ---
+    # We check if the file exists AND if it contains the correct settings
+    if os.path.exists(rule_file_path):
+        try:
+            with open(rule_file_path, 'r') as f:
+                content = f.read()
+                # We look for the Vendor ID (16d0) and the writable mode (0666)
+                if 'idVendor' in content and '16d0' in content and '0666' in content:
+                    print("USB permissions appear to be correctly set up already. No changes needed.")
+                    return  # Exit the function here
+        except IOError:
+            # If we can't read the file for some reason, we assume we need to fix it
+            pass
+
+    # --- IF WE REACH HERE, PERMISSIONS ARE MISSING ---
+
+    print("This script needs to update your system permissions to allow access to the device.")
+    print(f"We will add a rule file to: {rule_file_path}")
+
+    # Link provided before any action is taken
+    print("\nFor full details on why this is required, please read:")
+    print("https://quarch.com/support/faqs/usb/#linux-permissions")
+    print("----------------------------")
+
+    # Ask for permission before proceeding
+    response = input("Do you want to proceed with these changes? (y/n): ")
+    if response.lower() != 'y':
+        print("Operation cancelled by user.")
+        return
+
+    # Check if the user is root (UID 0)
+    print("\nStep 1: Checking for administrator privileges...")
+    if os.geteuid() != 0:
+        print(">> Current user is not admin. Elevating permissions now...")
+
+        # Re-run the script with sudo
+        args = ['sudo', sys.executable] + sys.argv
+        os.execvp('sudo', args)
+
+    # If we reach here, we are root
+    print(">> Administrator privileges confirmed.")
+
+    print("Step 2: Defining the access rules (Vendor ID: 16d0)...")
     content_to_write = "SUBSYSTEM==\"usb\", ATTRS{idVendor}==\"16d0\", MODE=\"0666\"\n" \
                        "SUBSYSTEM==\"usb_device\", ATTRS{idVendor}==\"16d0\", MODE=\"0666\""
 
     if "centos" in str(platform.platform()).lower():
+        print(">> CentOS detected. Applying group permissions fix...")
         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()
-
+    print("Step 3: Saving the rule file...")
+    try:
+        f = open(rule_file_path, "w")
+        f.write(content_to_write)
+        f.close()
+    except IOError as e:
+        print(f"!! Failed to write file: {e}")
+        return
+
+    print("Step 4: Reloading system USB drivers...")
     os.system("udevadm control --reload")
     os.system("udevadm trigger")
 
-    print("USB rule added to file : /etc/udev/rules.d/20-quarchmodules.rules")
+    print("\nSUCCESS: USB Setup Complete.")
 
 def _check_fw():
     print("")

quarchpy/debug/module_debug.py

@@ -76,15 +76,23 @@ def main(filepath=None):
     except FileNotFoundError as err:
         logger.error(f"Config file not found for module : {moduleStr}\nExiting Script")
         my_device.close_connection()
-        return
+        return None
 
     # Parse the file to get the device capabilities
-    dev_caps = parse_config_file(file)
+    try:
+        dev_caps = parse_config_file(file)
+    except Exception as err:
+        logger.error(f"Could not parse config file for {moduleStr}\nExiting Script"
+                     f"\nError details: {err}")
+        print(f"Could not parse config file for {moduleStr}\nPlease note only breaker and hot-plug modules are currently supported."
+              f"\nExiting Script")
+        my_device.close_connection()
+        return None
 
     if not dev_caps:
         logger.error(f"Could not parse config file for {moduleStr}\nExiting Script")
         my_device.close_connection()
-        return
+        return None
     logText("\nCONFIG FILE LOCATED:")
     logText(file)
     logText("\n")