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

quarchpy/connection_specific/mDNS.py

@@ -70,7 +70,7 @@ class MyListener:
         """
         Handle service addition event.
         """
-        logging.debug("Adding service: " +name)
+        logging.debug("Adding service: " + name)
         info = zc.get_service_info(type_, name)
         # Log the service name
         if "Quarch:" in str(info):
@@ -83,9 +83,6 @@ class MyListener:
             decoded_ip = ".".join(str(byte) for byte in info.addresses[0])
             self.get_instance().add_device(decoded_properties, decoded_ip)
 
-
-
-
     def add_device(self, properties_dict, ip_address):
         """
         Add a device to the found devices dictionary.
@@ -123,11 +120,11 @@ class MyListener:
         remove_device = False
         for key, value in list(temp_dict.items()):
             can_ping = ping(key[key.index(":") + 1:])
-            if can_ping is False:
+            if not can_ping:
                 remove_device=True # Remove the device if it can't be pinged
             elif self.get_instance().target_conn not in key.lower() and self.get_instance().target_conn.lower() != "all":
                 remove_device = True # or if its of the wrong connection type.
-            if remove_device is True:
+            if remove_device:
                 del self.get_instance().found_devices[key]
         logging.debug("Returning found devices "+str(self.get_instance().found_devices))
         return self.get_instance().found_devices

quarchpy/debug/SystemTest.py

@@ -2,6 +2,7 @@ import os
 import platform
 import sys
 import subprocess
+from typing import List
 
 from quarchpy import *
 from quarchpy.device import *
@@ -228,35 +229,47 @@ def fix_usb():
 
     print("USB rule added to file : /etc/udev/rules.d/20-quarchmodules.rules")
 
+def _check_fw():
+    print("")
+    print("FIRMWARE CHECK")
+    print("--------------")
+    print("")
+    discovered_devices: List[DiscoveredDevice] = []
+    scanDevices(discovered_devices=discovered_devices)
+    for module in discovered_devices:
+        module.is_update_available()
 
-def main (args=None):
+def main(args=None):
     """
     Main function to allow the system test to be called direct from the command line
     """
     bool_test_system_info = True
     bool_test_communication = True
-    bool_fixusb=False
+    bool_fix_usb = False
+    bool_check_fw = False
     if args is not None and len(args)>0:
         for arg in args:
             if "--fixusb" in str(arg).lower():
-                bool_fixusb=True
-                # todo: Should we still be running the debug info stuff after this?
+                bool_fix_usb = True
             if "--skipsysteminfo" in str(arg).lower():
-                bool_test_system_info=False
+                bool_test_system_info = False
             if "--skipcommstest" in str(arg).lower():
-                bool_test_communication=False
+                bool_test_communication = False
+            if "--checkfw" in str(arg).lower():
+                bool_check_fw = True
 
-    if bool_fixusb:
+    if bool_fix_usb:
         fix_usb()
     if bool_test_system_info:
         _test_system_info()
     if bool_test_communication:
         _test_communication()
-
+    if bool_check_fw:
+        _check_fw()
 
 
 if __name__ == "__main__":
     main([])
     #find_java_permissions()
     #main(["--skipSystemInfo","--skipCommsTest"])
-    #main(["--fixusb"])
+    #main(["--fixusb"])

quarchpy/device/__init__.py

@@ -1,8 +1,14 @@
 __all__ = ['quarchDevice', 'quarchArray', 'subDevice', 'quarchPPM', 'quarchQPS', 'quarchStream', 'qpsNowStr', 'scanDevices', 'listDevices',
-           'userSelectDevice', 'getQuarchDevice', 'get_connection_target', 'getSerialNumberFromConnectionTarget', 'get_quarch_device']
+           'userSelectDevice', 'getQuarchDevice', 'get_connection_target', 'getSerialNumberFromConnectionTarget', 'get_quarch_device', 'decode_locate_packet',
+           'IDNInfo', 'FixtureIDNInfo', 'DeviceNetworkInfo', 'DiscoveredDevice']
 
 from .device import quarchDevice, getQuarchDevice, get_quarch_device
 from .quarchArray import quarchArray, subDevice
 from .quarchPPM import quarchPPM
 from .quarchQPS import quarchQPS, quarchStream, qpsNowStr
 from .scanDevices import scanDevices, listDevices, userSelectDevice, get_connection_target, getSerialNumberFromConnectionTarget
+from .device_idn_info import IDNInfo
+from .device_fixture_idn_info import FixtureIDNInfo
+from .device_network_info import DeviceNetworkInfo
+from .packet_processing import decode_locate_packet
+from .discovered_device import DiscoveredDevice

quarchpy/device/device_fixture_idn_info.py

@@ -0,0 +1,8 @@
+class FixtureIDNInfo:
+    def __init__(self):
+        self.fixture_name = None
+        self.fixture_fpga = None
+
+    def set_fix_idn_info_fields_from_device_info_dict(self, device_info: {}):
+        self.fixture_name = device_info.get('fixture_name')
+        self.fixture_fpga = device_info.get('fixture_fpga')

quarchpy/device/device_idn_info.py

@@ -0,0 +1,100 @@
+from typing import Optional
+
+
+class IDNInfo:
+    def __init__(self):
+        self.family: Optional[str] = None
+        self.name: Optional[str] = None
+        self.part_number: Optional[str] = None
+        self.firmware: Optional[str] = None
+        self.alias: Optional[str] = None
+        self.enclosure_position: Optional[str] = None
+        self.enclosure_serial_number: Optional[str] = None
+        self.serial_number: Optional[str] = None
+        self.fpga_1: Optional[str] = None
+        self.fpga_2: Optional[str] = None
+        self.fpga_3: Optional[str] = None
+        self.fpga_4: Optional[str] = None
+        self.bootloader: Optional[str] = None
+        self.bootloader_mode: Optional[str] = None
+
+    def parse_idn_response(self, idn_response: str) -> bool:
+        """
+        Parses the '*idn?' response from the module.
+
+        Args:
+            idn_response: The textual response containing the idn information of the module.
+
+        Returns:
+            True if at least one line of the response was parsed successfully, False otherwise.
+        """
+        if not idn_response:
+            return False
+
+        was_successful = False
+
+        # A mapping of keys found in the IDN string to the class attribute names
+        key_to_attr_map = {
+            "Family": "family",
+            "Name": "name",
+            "Part#": "part_number",
+            "FW": "firmware",
+            "Bootloader": "bootloader",
+            "FPGA 1": "fpga_1",
+            "FPGA 2": "fpga_2",
+            "FPGA 3": "fpga_3",
+            "FPGA 4": "fpga_4",
+            "Serial#": "serial_number",
+            "Enclosure#": "enclosure_serial_number",
+            "Position#": "enclosure_position",
+            "Alias": "alias"
+        }
+
+        idn_string_list = idn_response.strip().split('\n')
+
+        for line in idn_string_list:
+            line = line.strip()
+
+            # Handle special case for bootloader mode
+            if line == "[Bootloader]":
+                self.bootloader_mode = True
+                was_successful = True
+                continue
+
+            # Skip lines without a colon separator
+            if ':' not in line:
+                continue
+
+            # Split only on the first colon to handle values that might contain colons
+            key, value = line.split(':', 1)
+            key = key.strip()
+            value = value.strip()
+
+            # The "Processor" key in Java sets both product string and firmware.
+            # Here we will just map it to firmware.
+            if key == "Processor":
+                self.firmware = value
+                was_successful = True
+                continue
+
+            # Use the dictionary to find the correct attribute to set
+            attr_name = key_to_attr_map.get(key)
+            if attr_name:
+                # Use setattr to dynamically set the class attribute
+                setattr(self, attr_name, value)
+                was_successful = True
+
+        return was_successful
+
+    def set_idn_info_fields_from_device_info_dict(self, device_info: dict):
+        self.family = None  # Unknown
+        self.name = device_info.get('legacy_name')
+        self.part_number = None  # Unknown
+        self.firmware = device_info.get('firmware_version')
+        self.alias = device_info.get('enclosure_alias')
+        self.enclosure_position = device_info.get('enclosure_position')
+        self.enclosure_serial_number = device_info.get('enclosure_serial_number')
+        self.serial_number = device_info.get('serial_number')
+        self.fpga_1 = device_info.get('fpga_1')
+        self.bootloader = device_info.get('bootloader')
+        self.bootloader_mode = None  # Unknown

quarchpy/device/device_network_info.py

@@ -0,0 +1,18 @@
+class DeviceNetworkInfo:
+    def __init__(self):
+        self.mac_address = None
+        self.mac_type = None
+        self.host_name = None
+        self.ip_address = None
+        self.tcp_port = None
+        self.rest_port = None
+        self.telnet_port = None
+
+    def set_network_info_fields_from_device_info_dict(self, device_info: dict):
+        self.mac_address = device_info.get('mac_address')
+        self.mac_type = device_info.get('mac_type')
+        self.host_name = device_info.get('host_name')
+        self.ip_address = device_info.get('ipv4_address')
+        self.tcp_port = device_info.get('tcp_port')
+        self.rest_port = device_info.get('rest_port')
+        self.telnet_port = device_info.get('telnet_port')

quarchpy/device/discovered_device.py

@@ -0,0 +1,150 @@
+from typing import Optional
+from urllib.request import urlopen
+
+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
+
+# A mapping of known codes to their corresponding dictionary keys.
+# This handles all fields that are simple string values.
+# Please refer to the below map for the device_info dict defined in this class.
+CODE_MAP = {
+    0x80: 'firmware',
+    0x81: 'bootloader',
+    0x82: 'fpga',
+    0x83: 'serial_number',
+    0x84: 'rest_port',
+    0x85: 'tcp_port',
+    0x86: 'enclosure_serial_number',
+    0x87: 'enclosure_position',
+    0x88: 'enclosure_alias',
+    0x89: 'product_string',
+    0x8a: 'telnet_port',
+    0x8c: 'fixture_name',
+    0x8d: 'fixture_fpga',
+    0x02: 'mac_address',
+    0x03: 'mac_type',
+    0x04: 'host_name',
+    0x05: 'ipv4_address'
+    # There are also some legacy fields with no code:
+    # legacy_name, legacy_mac_string
+}
+
+class DiscoveredDevice:
+    def __init__(self, idn: Optional[IDNInfo], fixture_idn: Optional[FixtureIDNInfo], device_net_info: Optional[DeviceNetworkInfo]):
+        """
+
+        Args:
+            idn:
+            fixture_idn:
+            device_net_info:
+        """
+        self.is_update_required = False
+        self.device_name = None
+        self.device_info: {} = {}
+        self.idn_info: Optional[IDNInfo] = idn
+        self.fixture_idn_info: Optional[FixtureIDNInfo] = fixture_idn
+        self.device_network_info: Optional[DeviceNetworkInfo] = device_net_info
+        self.product_check_url = 'https://quarch.com/product-check/firmware-search/?field_part_number_value='
+
+    def is_update_available(self):
+        """Checks for firmware and FPGA updates by scraping a product webpage.
+
+        This method determines the device's model number from its serial number,
+        fetches the corresponding product page from a URL, and scrapes the page
+        to find the latest available firmware and FPGA versions. It then compares
+        these against the versions currently on the device.
+
+        An instance attribute `self.is_update_required` is set to True if
+        either the firmware or FPGA version is found to be outdated.
+
+        Returns:
+            bool: True if an update is available, False otherwise.
+        """
+        # Extract the base device name (model number) from the full serial number.
+        self.device_name = self.get_serial_from_device()
+        part_no = self.get_serial_from_device().split('-', 1)[0]
+        # Fetch the product webpage content using the constructed URL.
+        prod_search_page = urlopen(f'{self.product_check_url}{part_no}')
+
+        # Read the raw byte data from the webpage and decode it into a string.
+        data: str = prod_search_page.read().decode()
+        # If the version marker isn't on the page, exit early as we can't proceed.
+        if 'Ver:' not in data:
+            return False
+        # Find the start and end of the HTML block containing version information.
+        start_index = data.find('Ver:')
+        end_index = data.find('</div>', start_index)
+
+        # Slice the HTML string to get only the relevant version info block.
+        scraped_device_info = data[start_index:end_index]
+        # Split the block into a list of individual lines for easier parsing.
+        scraped_device_info_list = scraped_device_info.split('\r\n')
+        # Initialize variables to hold the scraped version numbers.
+        scraped_fw_version = None
+        scraped_fpga_version = None
+        scraped_download_link_zip = None
+
+        # Get the current FW and FPGA versions from the connected device's info.
+        # Assumes a format like "Some Text,12345".
+        current_fw_version = self.idn_info.firmware.split(',')[1]
+        current_fpga_version = self.idn_info.fpga_1.split(',')[1]
+
+        # Loop through each line of the scraped text to find version details.
+        for entry in scraped_device_info_list:
+            # Check for the line containing the firmware version.
+            if 'FW' in entry:
+                # Extract the version number part of the string.
+                scraped_fw_version = entry.split(',')[1]
+                # Immediately compare versions and set the update flag if needed.
+                if float(scraped_fw_version) > float(current_fw_version):
+                    self.is_update_required = True
+            # Check for the line containing the FPGA version.
+            if 'FPGA' in entry:
+                # Extract the version number part of the string.
+                scraped_fpga_version = entry.split(',')[1]
+                # Immediately compare versions and set the update flag if needed.
+                if float(scraped_fpga_version) > float(current_fpga_version):
+                    self.is_update_required = True
+            # Extract the required link to download the zip file if required.
+            if 'Link' in entry:
+                scraped_download_link_zip = entry.split(':', 1)[1]
+
+        # After checking all lines, if the update flag has been set...
+        if self.is_update_required:
+            # ...print a helpful message to the user and return True.
+            print(f"\nThe module: {self.device_name} is not up-to-date. Current (FW: {current_fw_version}, FPGA: {current_fpga_version}) -> Latest (FW: {scraped_fw_version}, FPGA: {scraped_fpga_version})")
+            print(f"Please download the update pack at the following link: {scraped_download_link_zip}")
+            return True
+
+        # If the flag was never set, no update is needed.
+        return False
+
+    def populate_device_info(self):
+        self.idn_info.set_idn_info_fields_from_device_info_dict(self.device_info)
+        self.fixture_idn_info.set_fix_idn_info_fields_from_device_info_dict(self.device_info)
+        self.device_network_info.set_network_info_fields_from_device_info_dict(self.device_info)
+
+    def get_serial_from_device(self):
+        """
+
+        Returns:
+
+        """
+        serialNo = self.idn_info.serial_number
+        # Special case for IEC PAM
+        if ('2582' in serialNo) or ('2751' in serialNo) or ('2789' in serialNo) or ('2843' in serialNo):
+            response = serialNo
+            device_string = response.rsplit(':', 1)[1].strip() if ':' in response else response
+            return device_string
+        # Special case for PPM+
+        if '1944' in serialNo:
+            response = self.idn_info.enclosure_serial_number
+            device_string = response.split(':', 1)[1].strip() if ':' in response else response
+            return device_string
+
+        response = self.idn_info.enclosure_serial_number
+        if response is None:
+            response = serialNo
+        device_string = response.rsplit(':', 1)[1].strip() if ':' in response else response
+        return device_string

quarchpy/device/packet_processing.py

@@ -0,0 +1,87 @@
+import socket
+from quarchpy.device.discovered_device import CODE_MAP
+
+def decode_locate_packet(packet_fields: list[bytes]) -> dict:
+    """
+    Parses a device location packet and returns a dictionary of its properties.
+
+    This function is designed to work with a packet that has already been
+    split into a list of fields (byte strings). It interprets each field
+    based on a leading code byte.
+
+    Args:
+        packet_fields: A list of bytes objects, where each object is a
+                       field from the packet, typically prefixed with a code.
+
+    Returns:
+        A dictionary containing the parsed device information.
+    """
+    device_info = {}
+
+    for field in packet_fields:
+        if not field:
+            continue
+
+        code = field[0]
+        data = field[1:]
+
+        # Handle special cases with unique formatting
+        if code == 0x02:  # MAC Address (binary)
+            device_info['mac_address'] = _format_mac_address(data)
+        elif code == 0x03:  # MAC Type
+            device_info['mac_type'] = data.decode('ascii', errors='ignore').strip()
+        elif code == 0x04:  # Host Name
+            device_info['host_name'] = data.decode('ascii', errors='ignore').strip()
+        elif code == 0x05:  # IPv4 Address
+            try:
+                # Use standard library to format the 4-byte IP address
+                device_info['ipv4_address'] = socket.inet_ntoa(data)
+            except (OSError, ValueError):
+                # Fallback if data is not 4 bytes
+                device_info['ipv4_address'] = "Invalid IP format"
+        # Handle all standard string-based fields using the map
+        elif code in CODE_MAP:
+            key = CODE_MAP[code]
+            device_info[key] = data.decode('ascii', errors='ignore').strip()
+
+    # The first two fields in your example are a legacy header without codes.
+    # We can add them based on their position if they exist.
+    if len(packet_fields) > 1:
+        device_info['legacy_name'] = packet_fields[0].decode('ascii', errors='ignore').strip()
+        # The MAC address string from the legacy header is redundant if code 0x02 exists,
+        # but we can include it for completeness.
+        device_info['legacy_mac_string'] = packet_fields[1].decode('ascii', errors='ignore').strip()
+
+    return device_info
+
+
+def _format_mac_address(data: bytes) -> str:
+    """
+    Converts a 6-byte sequence into a standard MAC address string.
+
+    This is a verbose implementation for maximum clarity.
+    """
+
+    # 1. Create an empty list to hold each hexadecimal part of the address.
+    hex_parts = []
+
+    # 2. Loop through each byte in the raw byte sequence.
+    #    A 'byte' in this context is just a number from 0 to 255.
+    for byte in data:
+        # 3. For each number, format it as a two-digit, lowercase hexadecimal string.
+        #    - The 'x' converts the number to hex.
+        #    - The '02' ensures it's always two digits, adding a leading
+        #      zero if needed (e.g., the number 10 becomes '0a').
+        hex_part = f'{byte:02x}'
+
+        # 4. Add the newly formatted two-character string to our list.
+        hex_parts.append(hex_part)
+
+    # After the loop, the `hex_parts` list will look like this:
+    # ['9c', '95', '6e', '59', 'f0', 'e5']
+
+    # 5. Join all the individual parts in the list together, using a colon
+    #    as the separator.
+    mac_address = ':'.join(hex_parts)
+
+    return mac_address

quarchpy/device/quarchPPM.py

@@ -56,9 +56,7 @@ class quarchPPM(quarchDevice):
         self,
         file_name: str = 'streamData.txt',
         file_max_mb: int = 200000,
-        stream_name: str = 'Stream With No Name',
         stream_duration: Optional[float] = None,
-        stream_average: Optional[int] = None,
         release_on_data: bool = False,
         separator: str = ",",
         in_memory_data: Optional[StringIO] = None,
@@ -90,8 +88,7 @@ class quarchPPM(quarchDevice):
             str: The response from the device after starting the stream.
         """
         return self.connectionObj.qis.startStream(
-            self.ConString, file_name, file_max_mb, stream_name,
-            stream_average, release_on_data, separator, stream_duration,
+            self.ConString, file_name, file_max_mb, release_on_data, separator, stream_duration,
             in_memory_data, output_file_handle, use_gzip
         )
 
@@ -297,8 +294,8 @@ class quarchPPM(quarchDevice):
             str: The response from the device after starting the stream.
         """
         return self.start_stream(
-            file_name=fileName, file_max_mb=fileMaxMB, stream_name=streamName,
-            stream_duration=streamDuration, stream_average=streamAverage,
+            file_name=fileName, file_max_mb=fileMaxMB,
+            stream_duration=streamDuration,
             release_on_data=releaseOnData, separator=separator,
             in_memory_data=inMemoryData, output_file_handle=outputFileHandle,
             use_gzip=useGzip