quarchpy 2.2.12__py2.py3-none-any.whl → 2.2.13__py2.py3-none-any.whl

quarchpy/device/scanDevices.py

@@ -1,17 +1,24 @@
+import logging
 import operator
 import socket
 from sys import platform
+from typing import Optional, List
 
 from quarchpy.config_files.quarch_config_parser import return_module_type_list
 from quarchpy.user_interface import *
 from quarchpy.user_interface import User_interface
 
 try:
-    from quarchpy.connection_specific.connection_USB import importUSB  # , USBConn
+    from quarchpy.connection_specific.connection_USB import importUSB
 except:
     printText("System Compatibility issue - Is your Python architecture consistent with the Operating System?")
     pass
 from quarchpy.device import quarchDevice, quarchArray
+from quarchpy.device.device_idn_info import IDNInfo
+from quarchpy.device.device_fixture_idn_info import FixtureIDNInfo
+from quarchpy.device.device_network_info import DeviceNetworkInfo
+from quarchpy.device.packet_processing import decode_locate_packet
+from quarchpy.device.discovered_device import DiscoveredDevice
 from quarchpy.connection_specific.connection_Serial import serialList, serial
 from quarchpy.device.quarchArray import isThisAnArrayController
 from quarchpy.connection_specific.connection_USB import TQuarchUSB_IF
@@ -37,7 +44,7 @@ Scan for Quarch modules across all available COM ports
 '''
 
 
-def list_serial(debuPrint=False):
+def list_serial(debugPrint=False):
     serial_ports = serialList.comports()
     serial_modules = dict()
 
@@ -74,7 +81,7 @@ Scan for all Quarch devices available over USB
 '''
 
 
-def list_USB(debuPrint=False):
+def list_USB(debuPrint=False, discovered_devices: Optional[List[DiscoveredDevice]] = None):
     QUARCH_VENDOR_ID = 0x16d0
     QUARCH_PRODUCT_ID1 = 0x0449
 
@@ -142,12 +149,11 @@ def list_USB(debuPrint=False):
                 logging.error("Exception on closing USB port: " + str(err))
                 continue
 
-    # before returning the list of usb modules scan through the list for a 1944 create a quarch device and use sendCommand("*enclosure?")
-
+    # Before returning the list of usb modules scan through the list for a 1944 create a quarch device and use sendCommand("*enclosure?")
     for module in hdList:
-        quarchDevice = module
+        quarchUSBDevice = module
         QquarchDevice = TQuarchUSB_IF(context)
-        QquarchDevice.connection = quarchDevice
+        QquarchDevice.connection = quarchUSBDevice
         QquarchDevice.OpenPort()
         time.sleep(0.02)  # sleep sometimes needed before sending comand directly after opening device
         QquarchDevice.SetTimeout(2000)
@@ -168,6 +174,37 @@ def list_USB(debuPrint=False):
         logging.warning("Potential permission error accessing Quarch module(s) via USB.")
         logging.warning("If unknown, run the command 'sudo python3 -m quarchpy.run debug --fixusb' to add a new usb rule.")
 
+    # Ensure discovered usb devices are populated if required.
+    # Devices connected via USB must be enquired via *IDN?
+    if discovered_devices is not None:
+        try:
+            index = 0
+            cmd = "*IDN?"
+            # Create a temporary list to ensure nothing is overwritten.
+            temp_discovered_devices_list: List[DiscoveredDevice] = []
+            for key, value in usb_modules.items():
+                # Ensure to skip any locked modules.
+                if key != "USB:???":
+                    idn_info = IDNInfo()
+                    fix_idn_info = FixtureIDNInfo()
+                    device_net_info = DeviceNetworkInfo()
+                    discovered_device = DiscoveredDevice(idn_info, fix_idn_info, device_net_info)
+                    temp_discovered_devices_list.append(discovered_device)
+                    quarch_device = quarchDevice(key)
+                    response = quarch_device.send_command(cmd)
+                    is_idn_valid = temp_discovered_devices_list[index].idn_info.parse_idn_response(response)
+                    # Cleanup connection to module
+                    quarch_device.close_connection()
+                    del quarch_device
+                    if is_idn_valid:
+                        index += 1
+                    else:
+                        temp_discovered_devices_list.remove(discovered_device)
+
+            discovered_devices.extend(temp_discovered_devices_list)
+        except Exception as e:
+            logging.debug(str(e))
+
     return usb_modules
 
 
@@ -176,7 +213,7 @@ List all Quarch devices found over LAN, using a UDP broadcast scan
 '''
 
 
-def list_network(target_conn="all", debugPring=False, lanTimeout=1, ipAddressLookup=None):
+def list_network(target_conn="all", debugPrint=False, lanTimeout=1, ipAddressLookup=None, discovered_devices: Optional[List[DiscoveredDevice]] = None):
     retVal = {}
     lan_modules = dict()
     specifiedDevice = None
@@ -202,8 +239,7 @@ def list_network(target_conn="all", debugPring=False, lanTimeout=1, ipAddressLoo
 
         if ipAddressLookup is not None:
             # Attempts to find the device through UDP then REST
-            specifiedDevice, moduleFound = lookupDevice(str(ipAddressLookup).strip(), mySocket, lan_modules,
-                                                        moduleFound)
+            specifiedDevice, moduleFound = lookupDevice(str(ipAddressLookup).strip(), mySocket, lan_modules, moduleFound)
 
         mySocket.sendto(b'Discovery: Who is out there?\0\n', ('255.255.255.255', 30303))
         counter = 0
@@ -216,6 +252,7 @@ def list_network(target_conn="all", debugPring=False, lanTimeout=1, ipAddressLoo
             try:
                 msg_received = mySocket.recvfrom(1024)
             except Exception as e:
+                logging.debug(str(e))
                 # check if any a device was targeted directly and allow parse
                 if specifiedDevice is not None:
                     msg_received = specifiedDevice
@@ -228,6 +265,17 @@ def list_network(target_conn="all", debugPring=False, lanTimeout=1, ipAddressLoo
             # This fixes for all cases except if 13 is followed by 10.
             splits = msg_received[0].split(b"\r\n")
             del splits[-1]
+
+            # 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()
+                device_net_info = DeviceNetworkInfo()
+                discovered_device: DiscoveredDevice = DiscoveredDevice(idn_info, fix_idn_info, device_net_info)
+                discovered_device.device_info = decode_locate_packet(splits)
+                discovered_device.populate_device_info()
+                discovered_devices.append(discovered_device)
+
             for lines in splits:
                 if cont <= 1:
                     index = cont
@@ -423,7 +471,7 @@ def get_connection_target(module_string, scan_dictionary=None, connection_prefer
                             The Connection target of the supplied device.
     """
     logging.debug("Getting connection target for : " + str(module_string))
-    if connection_preference == None:
+    if connection_preference is None:
         connection_preference = ["USB", "TCP", "SERIAL", "REST", "TELNET"]
     module_string.replace("::", ":")  #QIS/QPS format to QuarchPy format
     delimeter_pos = module_string.find(":")
@@ -502,8 +550,7 @@ 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):
+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()
 
@@ -515,19 +562,13 @@ def scanDevices(target_conn="all", lanTimeout=1, scanInArray=True, favouriteOnly
     browser = scan_mDNS(mdns_listener, zeroconf)
     # Set target_conn
     mdns_listener.target_conn = target_conn.lower()
-    # Setup mdns discovery that stays persistent in the background - (could be removed)
-    # if not mdns_listener.mdns_service_running:
-    #     from zeroconf import ServiceBrowser, Zeroconf
-    #     scan_mDNS(mdns_listener, None)
-    #     mdns_listener.mdns_service_running = True
 
     if target_conn.lower() == "all":
-        foundDevices = list_USB()
+        foundDevices = list_USB(discovered_devices=discovered_devices)
         foundDevices = mergeDict(foundDevices, list_serial())
         try:
-            #This will fail if the test machine is not connected to a network
-            foundDevices = mergeDict(foundDevices,
-                                     list_network("all", ipAddressLookup=ipAddressLookup, lanTimeout=lanTimeout))
+            # 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:
             logging.error(e)
@@ -543,23 +584,23 @@ def scanDevices(target_conn="all", lanTimeout=1, scanInArray=True, favouriteOnly
         foundDevices = list_network(target_conn, ipAddressLookup=ipAddressLookup, lanTimeout=lanTimeout)
         foundDevices = mergeDict(foundDevices, mdns_listener.get_found_devices())
 
-    if (scanInArray):
+    if scanInArray:
         for k, v in foundDevices.items():  # k=Connection target, v=serial number
-            if (k not in scannedArrays):
+            if k not in scannedArrays:
                 scannedArrays.append(k)
-                if (isThisAnArrayController(v)):
+                if isThisAnArrayController(v):
                     try:
                         myQuarchDevice = quarchDevice(k)
-                        myArrayControler = quarchArray(myQuarchDevice)
-                        scanDevices = myArrayControler.scanSubModules()
-                        foundDevices = mergeDict(foundDevices, scanDevices)
-                        myArrayControler.close_connection()
+                        myArrayController = quarchArray(myQuarchDevice)
+                        scannedDevices = myArrayController.scanSubModules()
+                        foundDevices = mergeDict(foundDevices, scannedDevices)
+                        myArrayController.close_connection()
                     except Exception as e:
                         logging.debug(e, exc_info=True)
                         logging.debug("Cannot get serial number. Quarch device may be in use by another program.")
                         foundDevices[k] = "DEVICE IN USE"
 
-    if (favouriteOnly):
+    if favouriteOnly:
 
         # 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
@@ -622,29 +663,29 @@ Requests the user to select one of the devices in the given list
 '''
 
 
-def userSelectDevice(scanDictionary=None, scanFilterStr=None, favouriteOnly=True, message=None, title=None, nice=False,
-                     additionalOptions=None, target_conn="all"):
+def userSelectDevice(scanDictionary=None, scanFilterStr=None, favouriteOnly=True, message=None, title=None, nice=False, additionalOptions=None, target_conn="all"):
     if User_interface.instance is not None and User_interface.instance.selectedInterface == "testcenter":
         nice = False
-    if message is None: message = "Please select a quarch device"
-    if title is None: title = "Select a Device"
+    if message is None:
+        message = "Please select a quarch device"
+    if title is None:
+        title = "Select a Device"
     ip_address = None
     while True:
         # Scan first, if no list is supplied
         if scanDictionary is None:
             printText("Scanning for devices...")
             if ip_address is None:
-                scanDictionary = scanDevices(filterStr=scanFilterStr, favouriteOnly=favouriteOnly,
-                                             target_conn=target_conn)
+                scanDictionary = scanDevices(filterStr=scanFilterStr, favouriteOnly=favouriteOnly, target_conn=target_conn)
             else:
-                scanDictionary = scanDevices(filterStr=scanFilterStr, favouriteOnly=favouriteOnly,
-                                             target_conn=target_conn, ipAddressLookup=ip_address)
+                scanDictionary = scanDevices(filterStr=scanFilterStr, favouriteOnly=favouriteOnly, target_conn=target_conn, ipAddressLookup=ip_address)
 
         if len(scanDictionary) < 1:
             scanDictionary["***No Devices Found***"] = "***No Devices Found***"
 
-        if nice:  #Prepair the data for niceListSelection using displayTable().
-            if additionalOptions is None: additionalOptions = ["Specify IP Address", "Rescan", "Quit"]
+        if nice:  # Prepare the data for niceListSelection using displayTable().
+            if additionalOptions is None:
+                additionalOptions = ["Specify IP Address", "Rescan", "Quit"]
             tempList = []
             for k, v in scanDictionary.items():
                 tempEl = [v]

quarchpy/docs/CHANGES.rst

@@ -14,6 +14,20 @@ Change Log
 ----------
 
 
+2.2.13
+------
+- New QPS 1.48 and QIS 1.50
+- Lightweight Quarchpy, QPS and QIS now downloaded on first use after install.
+- Minor bug fixes
+
+2.2.12
+------
+- Minor bug fix
+
+2.2.11
+------
+- Minor bug fix
+
 2.2.10
 ------
 - Fix for new HDPPM FW discovery over eithernet

quarchpy/install_qps.py

@@ -0,0 +1,347 @@
+import os
+import sys
+import zipfile
+import requests
+import shutil
+import xml.etree.ElementTree as ET
+
+# --- Configuration ---
+QPS_VERSION_FOR_DOWNLOAD = "1.48"
+# URLs for the separate ZIP files.
+QPS_DOWNLOAD_URL = f"https://quarch.com/software_update/qps/QPS_{QPS_VERSION_FOR_DOWNLOAD}.zip"
+JDK_JRE_DOWNLOAD_URL = "https://quarch.com/software_update/qps/jdk_jres.zip"
+QPS_DOWNLOAD_URL_LATEST = "https://quarch.com/software_update/qps/QPS.zip"
+
+# --- Path definitions using __file__ ---
+try:
+    current_file_path = os.path.abspath(__file__)
+except NameError:
+    # Fallback for interactive environments where __file__ is not defined.
+    current_file_path = os.path.abspath(os.getcwd())
+
+package_root = os.path.dirname(current_file_path)
+
+TARGET_DIR = os.path.join(package_root, "connection_specific")
+EXTRACTION_FOLDER_QPS = os.path.join(TARGET_DIR, "QPS")
+EXTRACTION_FOLDER_JDK_JRE = os.path.join(TARGET_DIR, "jdk_jres")
+
+
+def find_qps():
+    """
+    Checks for QPS and JDK/JRE. If any are missing, it attempts an online or
+    offline installation of the required components.
+    """
+    qps_jar = "qps.jar"
+    qps_path = os.path.join(EXTRACTION_FOLDER_QPS, qps_jar)
+
+    # --- Cross-platform JDK/JRE check ---
+    if sys.platform == "win32":
+        jdk_folder_name = "win_amd64_jdk_jre"
+        java_executable_name = "java.exe"
+    elif sys.platform == "linux":
+        jdk_folder_name = "lin_amd64_jdk_jre"
+        java_executable_name = "java"
+    elif sys.platform == "darwin":
+        jdk_folder_name = "mac_amd64_jdk_jre"
+        java_executable_name = "java"
+    else:
+        jdk_folder_name = None
+        java_executable_name = None
+
+    jdk_jre_check_file = None
+    if jdk_folder_name:
+        jdk_jre_check_file = os.path.join(EXTRACTION_FOLDER_JDK_JRE, jdk_folder_name, "bin", java_executable_name)
+
+    qps_found = os.path.exists(qps_path)
+    jdk_found = jdk_jre_check_file and os.path.exists(jdk_jre_check_file)
+
+    if qps_found and jdk_found:
+        return True
+
+    print("--- Missing Components Detected ---")
+    qps_needed = not qps_found
+    jdk_jre_needed = not jdk_found
+    if qps_needed:
+        print("Quarch Power Studio (QPS) is not installed.")
+    if jdk_jre_needed:
+        print("Required Java JDK/JRE Binaries are not installed.")
+
+    # --- Installation Logic ---
+    installation_successful = False
+    response = ""
+    if is_network_connection_available():
+        network_available = True
+        print("\nAttempting online installation...")
+        response = input("Would you like to download and install the missing components? (y/n): ").lower()
+
+        if response == 'y':
+            qps_url_to_use = QPS_DOWNLOAD_URL
+
+            if qps_needed and not is_download_url_valid(qps_url_to_use):
+                print(f"The download url {qps_url_to_use} is not valid.")
+                print(f"Defaulting to URL for the latest version of QPS: \n{QPS_DOWNLOAD_URL_LATEST}")
+
+                latest_version = get_latest_qps_version()
+                if latest_version != QPS_VERSION_FOR_DOWNLOAD:
+                    print(f"Warning! The version of QuarchPy you are using does not officially support the latest version of QPS ({latest_version}).")
+                    print("Please consider upgrading QuarchPy.")
+                    proceed = input("Would you like to proceed with downloading the latest version? (y/n): ").lower()
+
+                    if proceed != 'y':
+                        print("Installation cancelled by user.")
+                        qps_url_to_use = None
+                    else:
+                        qps_url_to_use = QPS_DOWNLOAD_URL_LATEST
+                else:
+                    qps_url_to_use = QPS_DOWNLOAD_URL_LATEST
+
+            if qps_needed and not qps_url_to_use:
+                # User cancelled the download of a needed component
+                installation_successful = False
+            else:
+                installation_successful = install_online(qps_url_to_use, JDK_JRE_DOWNLOAD_URL, qps_needed, jdk_jre_needed)
+    else:
+        print("\nNo internet connection detected.")
+        network_available = False
+
+    if response == 'n' or not network_available:
+        print("To install manually, download the required files:")
+        if qps_needed:
+            print(f"  - QPS: {QPS_DOWNLOAD_URL} (or latest: {QPS_DOWNLOAD_URL_LATEST})")
+        if jdk_jre_needed:
+            print(f"  - JDK/JRE: {JDK_JRE_DOWNLOAD_URL}")
+
+        input("\nPress Enter to Continue after downloading.")
+        response = input("Would you like to install from the manually downloaded ZIP file(s)? (y/n) ").lower()
+        if response == 'y':
+            installation_successful = install_offline(qps_needed, jdk_jre_needed)
+
+    if not installation_successful:
+        print("Installation was cancelled or failed.")
+        return False
+
+    # --- Final Check ---
+    qps_found = os.path.exists(qps_path)
+    jdk_found = jdk_jre_check_file and os.path.exists(jdk_jre_check_file)
+    if (qps_needed and not qps_found) or (jdk_jre_needed and not jdk_found):
+        print("\nInstallation failed. Some components are still missing.")
+        print("Please contact Quarch Support for further help: https://quarch.com/contact/")
+        return False
+    else:
+        print("\nAll required components are now installed.")
+        return True
+
+
+def install_online(qps_url, jdk_jre_url, qps_needed, jdk_jre_needed):
+    """Handles online download and extraction of required components."""
+    qps_success = not qps_needed
+    jdk_jre_success = not jdk_jre_needed
+
+    if qps_needed:
+        qps_zip_path = os.path.join(TARGET_DIR, "QPS_download.zip")
+        print("\n--- Installing QPS ---")
+        if download_file(qps_url, qps_zip_path):
+            qps_success = extract_and_move_qps(qps_zip_path)
+            os.remove(qps_zip_path)
+            print(f"Cleaned up {qps_zip_path}")
+        else:
+            qps_success = False
+
+    if jdk_jre_needed:
+        jdk_jre_zip_path = os.path.join(TARGET_DIR, "jdk_jre.zip")
+        print("\n--- Installing JDK/JRE ---")
+        if download_file(jdk_jre_url, jdk_jre_zip_path):
+            jdk_jre_success = extract_and_move_jdk_jre(jdk_jre_zip_path)
+            os.remove(jdk_jre_zip_path)
+            print(f"Cleaned up {jdk_jre_zip_path}")
+        else:
+            jdk_jre_success = False
+
+    return qps_success and jdk_jre_success
+
+
+def install_offline(qps_needed, jdk_jre_needed):
+    """Prompts user for local ZIP files and installs them."""
+    qps_success = not qps_needed
+    jdk_jre_success = not jdk_jre_needed
+
+    if qps_needed:
+        print("\nPlease select the QPS ZIP file (e.g., QPS_1.47.zip).")
+        qps_zip_filepath = prompt_for_zip_path("Select QPS ZIP File")
+        if qps_zip_filepath:
+            qps_success = extract_and_move_qps(qps_zip_filepath)
+        else:
+            return False  # User cancelled
+
+    if jdk_jre_needed:
+        print("\nPlease select the JDK/JRE ZIP file (jdk_jre.zip).")
+        jdk_jre_zip_filepath = prompt_for_zip_path("Select JDK/JRE ZIP File")
+        if jdk_jre_zip_filepath:
+            jdk_jre_success = extract_and_move_jdk_jre(jdk_jre_zip_filepath)
+        else:
+            return False  # User cancelled
+
+    return qps_success and jdk_jre_success
+
+
+def download_file(url, destination_path):
+    """Downloads a file from a URL to a destination path with a progress bar."""
+    try:
+        print(f"Downloading from {url}...")
+        with requests.get(url, stream=True, timeout=30) as r:
+            r.raise_for_status()
+            total_size = int(r.headers.get('content-length', 0))
+            with open(destination_path, 'wb') as f:
+                downloaded = 0
+                for chunk in r.iter_content(chunk_size=8192):
+                    f.write(chunk)
+                    downloaded += len(chunk)
+                    done = int(50 * downloaded / total_size) if total_size > 0 else 0
+                    sys.stdout.write(f"\r[{'=' * done}{' ' * (50 - done)}] {downloaded / (1024 * 1024):.2f} MB")
+                    sys.stdout.flush()
+        print("\nDownload complete.")
+        return True
+    except requests.RequestException as e:
+        print(f"\nError: Failed to download file. {e}")
+        return False
+
+def extract_and_move_qps(zip_filepath):
+    """Extracts QPS from its ZIP and moves it to ...quarchpy\\connection_specific\\QPS."""
+    temp_extract_path = os.path.join(TARGET_DIR, "temp_extract_qps")
+    print(f"Processing QPS ZIP file: {os.path.basename(zip_filepath)}")
+    try:
+        if os.path.exists(temp_extract_path):
+            shutil.rmtree(temp_extract_path)
+        os.makedirs(temp_extract_path)
+        with zipfile.ZipFile(zip_filepath, 'r') as zip_ref:
+            zip_ref.extractall(temp_extract_path)
+
+        src_qps_folder = temp_extract_path
+        if not os.path.exists(src_qps_folder):
+            print(f"  - Error: 'qps' folder not found in the ZIP. Extraction failed.")
+            return False
+
+        os.makedirs(EXTRACTION_FOLDER_QPS, exist_ok=True)
+        dest_qps_path = EXTRACTION_FOLDER_QPS
+        if os.path.exists(dest_qps_path):
+            print(f"  - Removing old 'qps' folder...")
+            shutil.rmtree(dest_qps_path)
+        print(f"  - Moving 'qps' to '{EXTRACTION_FOLDER_QPS}'...")
+        shutil.move(os.path.join(src_qps_folder,"qps"), EXTRACTION_FOLDER_QPS)
+        if os.path.exists(src_qps_folder):
+            shutil.rmtree(src_qps_folder)
+        print("QPS components moved successfully.")
+        return True
+    except (zipfile.BadZipFile, FileNotFoundError, OSError) as e:
+        print(f"\nError during QPS file operations: {e}")
+        return False
+    finally:
+        if os.path.exists(temp_extract_path):
+            shutil.rmtree(temp_extract_path)
+
+
+def extract_and_move_jdk_jre(zip_filepath):
+    """Extracts JDK/JRE from its ZIP and moves all component folders."""
+    temp_extract_path = os.path.join(TARGET_DIR, "temp_extract_jdk_jre")
+    print(f"Processing JDK/JRE ZIP file: {os.path.basename(zip_filepath)}")
+    try:
+        if os.path.exists(temp_extract_path):
+            shutil.rmtree(temp_extract_path)
+        os.makedirs(temp_extract_path)
+        with zipfile.ZipFile(zip_filepath, 'r') as zip_ref:
+            zip_ref.extractall(temp_extract_path)
+
+        os.makedirs(EXTRACTION_FOLDER_JDK_JRE, exist_ok=True)
+        print(f"  - Moving JDK/JRE contents to '{EXTRACTION_FOLDER_JDK_JRE}'...")
+        for item_name in os.listdir(temp_extract_path):
+            src_item = os.path.join(temp_extract_path, item_name)
+            dest_item = os.path.join(EXTRACTION_FOLDER_JDK_JRE, item_name)
+            if os.path.isdir(src_item):
+                if os.path.exists(dest_item):
+                    shutil.rmtree(dest_item)
+                shutil.move(src_item, dest_item)
+        print("JDK/JRE components moved successfully.")
+        return True
+    except (zipfile.BadZipFile, FileNotFoundError, OSError) as e:
+        print(f"\nError during JDK/JRE file operations: {e}")
+        return False
+    finally:
+        if os.path.exists(temp_extract_path):
+            shutil.rmtree(temp_extract_path)
+
+
+def prompt_for_zip_path(title="Select ZIP File"):
+    """Asks the user for the path to the zip file, trying a GUI first."""
+    try:
+        import tkinter as tk
+        from tkinter import filedialog
+        print("Opening file dialog...")
+        root = tk.Tk()
+        root.withdraw()
+        filepath = filedialog.askopenfilename(
+            title=title,
+            filetypes=[("Zip files", "*.zip")]
+        )
+        return filepath
+    except (ImportError, tk.TclError):
+        print("\nGUI not available. Please provide the path in the command line.")
+        filepath = input(f"Enter the full path to the '{title}' ZIP file: ")
+        if os.path.isfile(filepath):
+            return filepath
+        else:
+            print("Error: The provided path is not a valid file.")
+            return None
+
+
+def is_network_connection_available(timeout=5):
+    """Checks for a reliable internet connection."""
+    try:
+        requests.head("https://www.quarch.com", timeout=timeout)
+        return True
+    except requests.RequestException:
+        return False
+
+
+def get_latest_qps_version():
+    """Fetches the latest QPS version number from the Quarch XML file."""
+    version_xml_url = "https://quarch.com/software_update/qps/current_version_all.xml"
+    try:
+        print(f"Checking for the latest QPS version from {version_xml_url}...")
+        response = requests.get(version_xml_url, timeout=10)
+        response.raise_for_status()
+        root = ET.fromstring(response.text)
+        latest_version_element = root.find('LatestVersion')
+
+        if latest_version_element is not None:
+            latest_version = latest_version_element.text
+            print(f"  - Latest version found: {latest_version}")
+            return latest_version
+        else:
+            print("  - Could not find 'LatestVersion' tag in the XML.")
+    except (requests.RequestException, ET.ParseError) as e:
+        print(f"  - Error fetching or parsing version info: {e}")
+
+    print(f"  - Could not determine latest version. Falling back to {QPS_VERSION_FOR_DOWNLOAD}.")
+    return QPS_VERSION_FOR_DOWNLOAD
+
+
+def is_download_url_valid(url):
+    """Checks if the provided URL is valid using a HEAD request."""
+    try:
+        print(f"Checking URL: {url} ...")
+        response = requests.head(url, timeout=10)
+        response.raise_for_status()
+        print("  - URL is valid.")
+        return True
+    except requests.RequestException as e:
+        print(f"  - This URL is not valid: {e}")
+        return False
+
+
+if __name__ == "__main__":
+    print("--- Running Component Check ---")
+    is_installed = find_qps()
+    if is_installed:
+        print("\nSuccess! All required components are present.")
+    else:
+        print("\n--- Script finished: Not all components could be found or installed. ---")