quarchpy 2.1.11.dev8__py3-none-any.whl → 2.2.17.dev1__py3-none-any.whl

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,88 @@
+import socket
+from quarchpy.device.discovered_device import CODE_MAP
+from typing import List
+
+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/quarchArray.py

@@ -14,6 +14,7 @@ class quarchArray(quarchDevice):
 
         self.ConType=baseDevice.ConType
         self.connectionObj=baseDevice.connectionObj
+        self.baseDevice = baseDevice
         pass
 
     def getSubDevice(self, port):
@@ -23,7 +24,7 @@ class quarchArray(quarchDevice):
         moduleList = dict()
 
         # Query the attached devices
-        responseText = self.sendCommand("conf:list:mod?")
+        responseText = self.send_command("conf:list:mod?")
         if responseText == "":
             return dict()
         responseList = responseText.split("\n")
@@ -51,23 +52,23 @@ class quarchArray(quarchDevice):
 
         return moduleList
 
-
+    def close_connection(self) -> str:
+        self.baseDevice.close_connection()
      
 
 class subDevice(quarchDevice):
 
     def __init__(self, baseDevice, port):
-        self.port = port
+        self.port = str(port)
         self.connectionObj = baseDevice.connectionObj
         self.ConType = baseDevice.ConType
         self.baseDevice = baseDevice
 
-    def sendCommand(self, CommandString, expectedResponse = True):
-        portNumb = str(self.port)
+    def send_command(self, CommandString, expectedResponse = True):
         returnStr = ''
         
         # Run the base device command
-        respStr = quarchDevice.sendCommand(self, CommandString + " <" + portNumb + ">")
+        respStr = quarchDevice.send_command(self, CommandString + " <" + str(self.port) + ">")
         # Split into lines, remove the line number sections then reform the string (removing the wanted 'x.y:' section at the start of each line
         respLines = respStr.split('\n')
         for x in respLines:            
@@ -77,3 +78,6 @@ class subDevice(quarchDevice):
         returnStr = returnStr.strip()
         return returnStr
 
+    def close_connection(self) -> str:
+        self.baseDevice.close_connection()
+