quarchpy 2.2.19.dev1__tar.gz → 2.2.19.dev2__tar.gz

{quarchpy-2.2.19.dev1/quarchpy.egg-info → quarchpy-2.2.19.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quarchpy
-Version: 2.2.19.dev1
+Version: 2.2.19.dev2
 Summary: This packpage offers Python support for Quarch Technology modules.
 Author: Quarch Technology ltd
 Author-email: support@quarch.com
@@ -57,7 +57,7 @@ Change Log
 
 2.2.18
 ------
-- Contains patch release for QPS 1.51.2 and QIS 1.53.1
+- Contains patch release for QPS 1.51.2
 - Critical bug fix for opening separate QPS instance by passing ports to startLocalQPS
 
 2.2.17

quarchpy-2.2.19.dev2/quarchpy/_version.py

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

{quarchpy-2.2.19.dev1 → quarchpy-2.2.19.dev2}/quarchpy/connection_specific/connection_QIS.py

@@ -570,8 +570,6 @@ class QisInterface:
             sock = self.sock
 
         dev_string = self.sendAndReceiveText(sock, '$list details')
-        if 'No Devices Found' in dev_string:
-            return [] #Return an empty list if no devices are found.
         dev_string = dev_string.replace('>', '')
         dev_string = dev_string.replace(r'\d+\) ', '')
         dev_string = dev_string.split('\r\n')
@@ -637,7 +635,9 @@ class QisInterface:
         while True:
             printText("Scanning for modules...")
             found_devices = None
-            if scan is True or ip_address is not None:
+            if scan and ip_address is None:
+                found_devices = self.qis_scan_devices(scan=scan, preferred_connection_only=favourite)
+            elif scan and ip_address is not None:
                 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",
@@ -699,7 +699,7 @@ class QisInterface:
             found_devices = self.sendAndReceiveText(self.sock, '$list')
 
         # If we found devices, process them into a list to return
-        if not "no devices found" in found_devices.lower(): # Looks for string in QIS response.
+        if not "no devices found" in found_devices.lower():
             found_devices = found_devices.replace('>', '')
             found_devices = found_devices.split('\r\n')
             # Can't stream over REST. Removing all REST connections.
@@ -716,7 +716,7 @@ class QisInterface:
             if preferred_connection_only:
                 found_devices = self.sort_favourite(found_devices)
         else:
-            found_devices = [] # Return empty list if not devices are found.
+            found_devices = ["***No Devices Found***"]
 
         return found_devices
 

{quarchpy-2.2.19.dev1 → quarchpy-2.2.19.dev2}/quarchpy/device/device.py

@@ -88,15 +88,12 @@ class quarchDevice:
         self.connectionObj = None
         self.timeout = 5  # Default int timeout
         self.is_module_resetting = False
-        self.instance = None
 
         # Determine ConType based on provided instances
         if qps_instance:
             self.ConType = "QPS"
-            self.instance = qps_instance
         if qis_instance:
             self.ConType = "QIS"
-            self.instance = qis_instance
 
         # Call helper to store and validate parameters
         self._store_and_validate_params(ConString, ConType, timeout)

{quarchpy-2.2.19.dev1 → quarchpy-2.2.19.dev2}/quarchpy/device/quarchQPS.py

@@ -47,7 +47,7 @@ class quarchQPS(quarchDevice):
         Raises:
             AttributeError: If the provided quarchDevice is not a valid QPS connection.
         """
-        super().__init__(quarchDevice.ConString, ConType=quarchDevice.ConType, qps_instance=quarchDevice.instance)
+        super().__init__(quarchDevice.ConString, ConType=quarchDevice.ConType)
         self.quarchDevice = quarchDevice
         self.connectionObj = quarchDevice.connectionObj
 

{quarchpy-2.2.19.dev1 → quarchpy-2.2.19.dev2}/quarchpy/device/scanDevices.py

@@ -249,40 +249,25 @@ 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
 
-            # --- 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)
-
-            # 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]
-            # ------------------------------
+            # 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]
 
-            # Decode and extend discovered_devices
+            # Decode the discovered device and extend the provided discovered_devices list if required
             if discovered_devices is not None:
                 idn_info = IDNInfo()
                 fix_idn_info = FixtureIDNInfo()
@@ -292,23 +277,18 @@ 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:
-                    # lines[0] returns an int, so we use slicing lines[0:1] to keep it bytes
-                    index = repr(lines[0:1]).replace("'", "").replace("b", "")
+                    index = repr(lines[0]).replace("'", "")
                     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: " + 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"
+            logger.debug("Found UDP response: " + module_name)
+            ip_module = msg_received[1][0].strip()
             try:
                 # Add a QTL before modules without it.
                 if "QTL" not in module_name.decode("utf-8"):
@@ -318,43 +298,32 @@ 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() in ["all", "telnet"]:
+            if target_conn.lower() == "all" or target_conn.lower() == "telnet":
                 if network_modules.get("\\x8a") or network_modules.get("138"):
-                    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}")
+                    # Append the information to the list.
+                    lan_modules["TELNET:" + ip_module] = module_name
+                    logger.debug("Found Telnet module: " + module_name)
 
             # Checks if there's a value in the REST key.
-            if target_conn.lower() in ["all", "rest"]:
+            if target_conn.lower() == "all" or target_conn.lower() == "rest":
                 if network_modules.get("\\x84") or network_modules.get("132"):
-                    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}")
+                    # Append the information to the list.
+                    lan_modules["REST:" + ip_module] = module_name
+                    logger.debug("Found REST module: " + module_name)
 
             # Checks if there's a value in the TCP key.
-            if target_conn.lower() in ["all", "tcp"]:
+            if target_conn.lower() == "all" or target_conn.lower() == "tcp":
                 if network_modules.get("\\x85") or network_modules.get("133"):
-                    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}")
+                    # Append the information to the list.
+                    lan_modules["TCP:" + ip_module] = module_name
+                    logger.debug("Found TCP module: " + module_name)
         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: " + str(moduleFound))
+            printText("IP Scan succeeded, module found: " + moduleFound)
     logger.debug("Finished UDP scan")
     retVal.update(lan_modules)
     return retVal
@@ -759,4 +728,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.dev1 → quarchpy-2.2.19.dev2}/quarchpy/docs/CHANGES.rst

@@ -15,7 +15,7 @@ Change Log
 
 2.2.18
 ------
-- Contains patch release for QPS 1.51.2 and QIS 1.53.1
+- Contains patch release for QPS 1.51.2
 - Critical bug fix for opening separate QPS instance by passing ports to startLocalQPS
 
 2.2.17

{quarchpy-2.2.19.dev1 → quarchpy-2.2.19.dev2}/quarchpy/qis/qisFuncs.py

@@ -8,9 +8,9 @@ import os, sys
 import socket
 import time, platform
 from subprocess import CompletedProcess, Popen
-from threading import Thread, Lock, Event
+from threading import Thread, Lock, Event, active_count
 from queue import Queue, Empty
-from typing import Optional, List, Tuple, Union
+from typing import Optional, List, Any, Tuple, Union
 
 import quarchpy_binaries
 
@@ -18,30 +18,26 @@ from quarchpy.connection_specific.connection_QIS import QisInterface
 from quarchpy.connection_specific.jdk_jres.fix_permissions import main as fix_permissions, find_java_permissions
 from quarchpy.install_qps import find_qps
 from quarchpy.user_interface import requestDialog
-from quarchpy.user_interface.user_interface import printText
+from quarchpy.user_interface.user_interface import printText, logDebug
 import subprocess
 import logging
 logger = logging.getLogger(__name__)
 
 
-def isQisRunning(port: int = 9722):
+def isQisRunning():
     """
-    Checks if an instance of QIS is running and responding.
-
-    Args:
-        port (int): The TCP port number used to attempt a connection
-            with the QIS interface. QIS defaults to 9722.
-
-    Returns:
-        bool: True if a connection to the QIS interface was successfully
-            established; False otherwise.
+    Checks if a local instance of QIS is running and responding
+    Returns
+    -------
+    is_running : bool\
+        True if QIS is running and responding
     """
 
     qisRunning = False
     myQis = None
-    # Attempt to connect to QIS
+    #attempt to connect to Qis
     try:
-        myQis = QisInterface(connectionMessage=False, port=port)
+        myQis = QisInterface(connectionMessage=False)
         if (myQis is not None):
             #if we can connect to qis, it's running
             qisRunning = True
@@ -56,35 +52,21 @@ def isQisRunning(port: int = 9722):
         return True
 
 
-def isQisRunningAndResponding(timeout=2, port: int = 9722):
+def isQisRunningAndResponding(timeout=2):
     """
-    Checks if QIS is running and responding to a version command.
-
-    This function first verifies if the QIS service is reachable on the
-    specified port, then attempts to validate the connection by sending
-    a `$version` command and checking for a valid response string.
-
-    Args:
-        timeout (int, optional): The total time in seconds to wait for a
-            valid response from the service. Defaults to 2.
-        port (int, optional): The TCP port number to connect to.
-            Defaults to 9722.
-
-    Returns:
-        bool: True if QIS is running and returns a version string containing
-            'v' within the timeout period; False otherwise.
-        """
-    qisRunning = isQisRunning(port=port)
-    if not qisRunning:
+    checks if qis is running and responding to a $version
+    """
+    qisRunning = isQisRunning()
+    if qisRunning == False:
         logger.debug("QIS is not running")
         return False
 
     logger.debug("Qis is running")
-    myQis = QisInterface(connectionMessage=False, port=port)
+    myQis = QisInterface(connectionMessage=False)
     counter = 0
     maxCounter = 20
     while counter <= maxCounter:
-        versionResponse: str = myQis.sendAndReceiveCmd(cmd="$version")
+        versionResponse = myQis.sendAndReceiveCmd(cmd="$version")
         if "v" in versionResponse.lower():
             qisResponding = True
             break
@@ -93,7 +75,7 @@ def isQisRunningAndResponding(timeout=2, port: int = 9722):
             time.sleep(timeout / maxCounter)  # We attempt to get QIS
             counter += 1
 
-    if not qisRunning:
+    if (qisRunning is False):
         logger.debug("QIS is not running")
         return False
     else:
@@ -102,80 +84,58 @@ def isQisRunningAndResponding(timeout=2, port: int = 9722):
 
 
 def startLocalQis(
-        terminal: bool = False,
-        headless: bool = False,
-        args: Optional[List[str]] = None,
-        timeout: int = 20,
-        host: str = '127.0.0.1',
-        **kwargs
+    terminal: bool = False,
+    headless: bool = False,
+    args: List[str] = [],
+    timeout: int = 20,
+    host: str = '127.0.0.1',
+    port: int = 9722,
+    rest_port: int = 9780
 ) -> Optional['QisInterface']:
     """
     Executes QIS on the local system and returns a connected interface.
 
     Args:
-        terminal (bool): True if QIS terminal should be shown on startup (-terminal).
-        headless (bool): True if app should be run in headless mode.
-        args (List[str], optional): List of additional raw parameters.
-        timeout (int): Time in seconds to wait for launch.
-        host (str): Host address (default localhost).
-        **kwargs: Configuration for ports and QIS behavior.
-
-            * **port** (int): The Telnet port to use. Defaults to 9722.
-            * **rest_port** (int): The REST port to use. Defaults to 9780.
-            * **loglevel** (str): Sets logging level [OFF, FATAL, ERROR, WARN, INFO, DEBUG, TRACE, ALL].
-            * **logconsole** (str): If 'ON', logs to the console as well as to file.
-            * **devdebug** (str): If 'ON', enables development debug output.
-            * **devdebug2** (bool): If 'ON', enables extra costly debug output.
-
-    Returns:
-        Optional[QisInterface]: A connected interface object, or None if launch fails.
+        terminal: True if QIS terminal should be shown on startup.
+        headless: True if app should be run in headless mode.
+        args: List of additional parameters.
+        timeout: Time in seconds to wait for launch.
+        host: Host address (default localhost).
+        port: The Telnet port to use (Default: 9722).
+        rest_port: The REST port to use (Default: 9780).
     """
-    # 1. Extract values from kwargs with appropriate defaults
-    port = kwargs.get('port', 9722)
-    rest_port = kwargs.get('rest_port', 9780)
-
-    # 2. Prepare Arguments
-    launch_args = args.copy() if args else []
-
-    # Map kwargs to their CLI flag equivalents
-    kwarg_map = {
-        'loglevel': '-loglevel=',
-        'logconsole': '-logconsole',
-        'devdebug': '-devdebug',
-        'devdebug2': '-devdebug2',
-        'port': '-port=',
-        'rest_port': '-restport='
-    }
-
-    for key, flag in kwarg_map.items():
-        if key in kwargs:
-            val = kwargs[key]
-            # Handle boolean flags (no value needed) vs value flags (suffix needed)
-            if isinstance(val, bool):
-                arg_str = flag if val else None
-            else:
-                arg_str = f"{flag}{val}"
-
-            # Add to launch_args if flag generated and not already manually present
-            if arg_str and not any(flag in a for a in launch_args):
-                launch_args.append(arg_str)
-
-    # 3. Check if already running on the specific target port
+    # 0. Prepare Arguments
+    # We copy the list to avoid modifying the input in place
+    launch_args = args.copy()
+
+    # Sync 'port' arg to CLI flags if non-default
+    if port != 9722:
+        # Only add if not already manually present in args
+        if not any("-port=" in arg for arg in launch_args):
+            launch_args.append(f"-port={port}")
+
+    # Sync 'restport' arg to CLI flags if non-default
+    if rest_port != 9780:
+        if not any("-restport=" in arg for arg in launch_args):
+            launch_args.append(f"-restport={rest_port}")
+
+    # 1. Check if already running (Use the explicit 'port' integer)
     if _check_port_open(host, port):
         logger.debug(f"QIS instance on port {port} is already running. Connecting...")
         return QisInterface(host=host, port=port)
 
-    # 4. Check for installation
+    # 2. Check for installation
     if not find_qps():
         logger.error("Unable to find or install QPS... Aborting...")
         return None
 
-    # 5. Prepare Command and Environment
+    # 3. Prepare Command and Environment
+    # Note: We pass 'launch_args' which now includes our port flags
     command, qis_dir = _prepare_qis_launch_env(terminal, headless, launch_args)
     if not command:
         return None
 
-    # 6. Launch QIS Process
+    # 4. Launch QIS Process
     current_dir = os.getcwd()
     try:
         os.chdir(qis_dir)
@@ -183,11 +143,11 @@ def startLocalQis(
     finally:
         os.chdir(current_dir)
 
-    # 7. Wait for QIS to be ready
+    # 5. Wait for QIS to be ready
     if not _wait_for_qis_service(host, port, timeout, process, launch_args):
         return None
 
-    # 8. Return Connected Interface
+    # 6. Return Connected Interface
     try:
         return QisInterface(host=host, port=port)
     except Exception as e:
@@ -468,6 +428,11 @@ def _wait_for_qis_service(host: str, port: int, timeout: int, process: Optional[
         if _check_port_open(host, port):
             # QIS accepts the connection
             logger.debug(f"QIS detected on port {port} after {time.time() - start_time:.2f}s")
+
+            # Optional: Extra check to ensure it's actually responding to commands
+            # (Replaces old 'isQisRunningAndResponding' logic efficiently)
+            # You could do a quick handshake here if strict validation is required,
+            # but usually TCP open is sufficient for startup success.
             return True
 
         # 2. Monitor Process Health