quarchpy 2.2.17.dev1__tar.gz → 2.2.17.dev3__tar.gz

quarchpy-2.2.17.dev3/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 QuarchTechnologyLtd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{quarchpy-2.2.17.dev1 → quarchpy-2.2.17.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quarchpy
-Version: 2.2.17.dev1
+Version: 2.2.17.dev3
 Summary: This packpage offers Python support for Quarch Technology modules.
 Author: Quarch Technology ltd
 Author-email: support@quarch.com
@@ -18,6 +18,7 @@ Classifier: Topic :: System
 Classifier: Topic :: System :: Power (UPS)
 Requires-Python: >=3.7
 Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
 Requires-Dist: zeroconf>=0.23.0
 Requires-Dist: numpy
 Requires-Dist: pandas
@@ -25,6 +26,8 @@ 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
 Dynamic: classifier
@@ -32,6 +35,7 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: keywords
 Dynamic: license
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary

quarchpy-2.2.17.dev3/quarchpy/__init__.py

@@ -0,0 +1,122 @@
+import os
+import sys
+import inspect
+from ._version import __version__
+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)
+
+# 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:
+    # 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"
+
+    file_handler = RotatingFileHandler(logfile, maxBytes=5_000_000, backupCount=5)
+    file_handler.setLevel(logging.DEBUG)
+    file_handler.setFormatter(logging.Formatter(
+        "%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+        "%Y-%m-%d %H:%M:%S"
+    ))
+    logger.addHandler(file_handler)
+
+    # 2. Console: Dynamically mirrors the python root log level
+    console_handler = logging.StreamHandler()
+
+    # 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"
+    ))
+    logger.addHandler(console_handler)
+
+
+# ---- Public API for users ----
+def configure_logging(console_level=None, file_level=None, file_path=None):
+    """Reconfigure quarchpy logging safely."""
+    for handler in logger.handlers:
+        # 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
+        if isinstance(handler, RotatingFileHandler):
+            if file_level is not None:
+                handler.setLevel(file_level)
+            if file_path is not None:
+                handler.baseFilename = str(file_path)
+
+    logger.info(
+        f"quarchpy logging reconfigured console_level:{console_level} file_level:{file_level} file_path:{file_path}")
+
+
+# --- 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"
+]
+
+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)
+
+# --- Public API Imports ---
+from debug.versionCompare import requiredQuarchpyVersion
+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 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

quarchpy-2.2.17.dev3/quarchpy/_version.py

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

{quarchpy-2.2.17.dev1 → quarchpy-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-2.2.17.dev1 → quarchpy-2.2.17.dev3}/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-2.2.17.dev3/quarchpy/connection_specific/connection_Telnet.py

@@ -0,0 +1,41 @@
+import logging
+import time
+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):
+        self.ConnTarget = ConnTarget
+        self.Connection = Telnet(self.ConnTarget)
+        time.sleep(1)
+        self.Connection.read_very_eager()
+
+    def close(self):
+        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,
+        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]
+        Result = Result.decode()
+        Result = Result.strip('> \t\n\r')
+        return Result.strip()

{quarchpy-2.2.17.dev1 → quarchpy-2.2.17.dev3}/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-2.2.17.dev1 → quarchpy-2.2.17.dev3}/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-2.2.17.dev1 → quarchpy-2.2.17.dev3}/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-2.2.17.dev1 → quarchpy-2.2.17.dev3}/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")