reader-integration-kit 1.4.2__py3-none-win_amd64.whl

reader_integration_kit/structures/__init__.py

@@ -0,0 +1,36 @@
+from reader_integration_kit.structures.device_id import DeviceId
+from reader_integration_kit.structures.reader_definition import ReaderDefinition
+from reader_integration_kit.structures.rik_result import RikResult
+from reader_integration_kit.structures.serial_port_settings import SerialPortSettings
+from reader_integration_kit.structures.reader_metadata_struct import ReaderMetadataStruct
+from reader_integration_kit.structures.microcontroller_firmware_version import \
+    MicrocontrollerFirmwareVersion
+from reader_integration_kit.structures.bluetooth_firmware_version import BluetoothFirmwareVersion
+from reader_integration_kit.structures.hid_se_sam_firmware_version import HidSeSamFirmwareVersion
+from reader_integration_kit.structures.nxp_sam_firmware_version import NxpSamFirmwareVersion
+from reader_integration_kit.structures.felica_sam_firmware_version import FelicaSamFirmwareVersion
+from reader_integration_kit.structures.library_info import LibraryInfo
+from reader_integration_kit.structures.card_data import CardData
+from reader_integration_kit.structures.led_configuration import LedConfiguration
+from reader_integration_kit.structures.reader_configuration import ReaderConfigurationStruct
+from reader_integration_kit.structures.reader_data import ReaderData
+from reader_integration_kit.structures.field_entry import FieldEntry
+from reader_integration_kit.structures.separator_entry import SeparatorEntry
+from reader_integration_kit.structures.field_separator_data_header import FieldSeparatorDataHeader
+from reader_integration_kit.structures.separator_character import SeparatorCharacter
+from reader_integration_kit.structures.extended_configuration import ExtendedConfiguration
+from reader_integration_kit.structures.hash_data import HashData
+from reader_integration_kit.structures.luid_response_information import LuidResponseInformation
+from reader_integration_kit.structures.card_type_info import CardTypeInfo, SupportedCardTypesResult
+from reader_integration_kit.structures.blob_header import BlobHeader
+from reader_integration_kit.structures.smart_card_configuration import SmartCardConfigurationStruct
+
+__all__ = [
+    'DeviceId', 'ReaderDefinition', 'RikResult', 'SerialPortSettings',
+    'ReaderMetadataStruct', 'MicrocontrollerFirmwareVersion', 'BluetoothFirmwareVersion',
+    'HidSeSamFirmwareVersion', 'NxpSamFirmwareVersion', 'FelicaSamFirmwareVersion', 'LibraryInfo',
+    'CardData', 'LedConfiguration', 'ReaderConfigurationStruct', 'ReaderData', 'FieldEntry',
+    'LuidResponseInformation', 'SeparatorEntry', 'FieldSeparatorDataHeader', 'SeparatorCharacter',
+    'ExtendedConfiguration', 'HashData',
+    'CardData', 'CardTypeInfo', 'SupportedCardTypesResult', 'BlobHeader', 'SmartCardConfigurationStruct'
+]

reader_integration_kit/structures/blob_header.py

@@ -0,0 +1,54 @@
+import struct
+from ctypes import Structure, c_uint8, c_uint16
+from typing import Any
+
+from reader_integration_kit.enum import BlobType
+
+class BlobHeader(Structure):
+    _pack_ = 1
+    _fields_ = [
+        ("Type", c_uint8),
+        ("ID", c_uint8),
+        ("DataLength", c_uint16),
+        ("BSV", c_uint8),
+    ]
+
+    def __init__(self, *args: Any, **kw: Any):
+        super().__init__()
+        self.Type = kw.get("Type", args[0] if len(args) > 0 else BlobType.LEGACY_KEY.value)
+        self.ID = kw.get("ID", args[1] if len(args) > 1 else 0)
+        self.DataLength = kw.get("DataLength", args[2] if len(args) > 2 else 0)
+        self.BSV = kw.get("BSV", args[3] if len(args) > 3 else 0)
+
+    def __str__(self):
+        return (f"Blob type: {BlobType(self.Type).name}\n" +
+                f"ID: {self.ID}\n" +
+                f"Data length: {self.DataLength}\n" +
+                f"BSV: {self.BSV}\n"
+                )
+
+    def __repr__(self):
+        return self.__str__()
+
+    def __eq__(self, other):
+        return self.Type == other.Type and self.ID == other.ID and self.DataLength == other.DataLength and self.BSV == other.BSV
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def to_dict(self):
+        return {
+            "Type": BlobType(self.Type).name,
+            "ID": self.ID,
+            "DataLength": self.DataLength,
+            "BSV": self.BSV,
+        }
+
+    def to_bytes(self):
+        # Pack as: Type(u8), ID(u8), DataLength(u16 LE), BSV(u8) = 5 bytes
+        return struct.pack('<BBHB', self.Type, self.ID, self.DataLength, self.BSV)
+
+    @classmethod
+    def from_bytes(cls, byte_array):
+        type_, id_, data_length, bsv = struct.unpack('<BBHB', bytes(byte_array[:5]))
+        return cls(Type=type_, ID=id_, DataLength=data_length, BSV=bsv)

reader_integration_kit/structures/bluetooth_firmware_version.py

@@ -0,0 +1,35 @@
+from ctypes import Structure, c_uint32, c_uint8, c_int32
+from typing import Any
+
+
+class BluetoothFirmwareVersion(Structure):
+    _pack_ = 1  # Ensure no padding between fields for native compatibility
+    _fields_ = [
+        ("Major", c_uint32),
+        ("Minor", c_uint32),
+        ("Build", c_uint32),
+        ("MicrocontrollerType", c_int32),  # enum class in C++ uses int (4 bytes)
+        ("ModuleType", c_int32),  # enum class in C++ uses int (4 bytes)
+    ]
+
+    def __init__(self, *args: Any, **kw: Any):
+        super().__init__()
+        self.ModuleType = kw.get("ModuleType", 0)
+        self.MicrocontrollerType = kw.get("MicrocontrollerType", 0)
+        self.Build = kw.get("Build", 0)
+        self.Minor = kw.get("Minor", 0)
+        self.Major = kw.get("Major", 0)
+
+    def to_dict(self):
+        """Convert to dictionary."""
+        return {
+            "Major": self.Major,
+            "Minor": self.Minor,
+            "Build": self.Build,
+            "MicrocontrollerType": self.MicrocontrollerType,
+            "ModuleType": self.ModuleType,
+        }
+
+    def __str__(self):
+        return f"{self.Major}.{self.Minor}.{self.Build}"
+

reader_integration_kit/structures/card_data.py

@@ -0,0 +1,77 @@
+"""CardData structure for the Reader Integration Kit."""
+
+from typing import List
+
+
+class CardData:
+    """
+    Represents card data read from an RFID reader.
+    
+    This structure contains the raw card data bytes and associated metadata
+    such as the bit count of the data read.
+    """
+    
+    def __init__(self):
+        """Initialize a new CardData instance with empty data."""
+        self.data = [0] * 32  # 32-byte array for card data
+        self._bit_count = 0
+    
+    @property
+    def bit_count(self) -> int:
+        """Get the bit count of the card data."""
+        return self._bit_count
+    
+    @bit_count.setter
+    def bit_count(self, value: int):
+        """Set the bit count of the card data."""
+        self._bit_count = value
+    
+    def is_empty(self) -> bool:
+        """
+        Check if the card data is empty.
+        
+        Returns:
+            True if the bit count is zero and the data is empty or all bytes are zero, False otherwise.
+        """
+        if self._bit_count != 0:
+            return False
+        if not self.data:
+            return True
+        return all(byte == 0 for byte in self.data)
+    
+    def as_bytes(self) -> bytes:
+        """
+        Get the card data as a bytes object.
+        
+        Returns:
+            The card data as a bytes object.
+        """
+        return bytes(self.data)
+    
+    def as_list(self) -> List[int]:
+        """
+        Get the card data as a list of integers.
+        
+        Returns:
+            The card data as a list of integers (0-255).
+        """
+        return list(self.data)
+    
+    def as_hex_string(self) -> str:
+        """
+        Get the card data as a hexadecimal string.
+        
+        Returns:
+            The card data as a hex string (e.g., "12 34 56 78 ...").
+        """
+        return ' '.join(f'{byte:02X}' for byte in self.data)
+    
+    def __repr__(self) -> str:
+        """Return a string representation of the CardData."""
+        valid = "Empty" if self.is_empty() else "Not Empty"
+        return f"CardData(bit_count={self.bit_count}, {valid}, data={self.as_hex_string()[:24]}...)"
+    
+    def __str__(self) -> str:
+        """Return a user-friendly string representation."""
+        return self.__repr__()
+

reader_integration_kit/structures/card_type_info.py

@@ -0,0 +1,51 @@
+"""
+CardTypeInfo ctypes structure matching the C ABI CardTypeInfo struct from RikCommon.
+"""
+import ctypes
+
+
+class CardTypeInfo(ctypes.Structure):
+    """ABI-safe structure describing a single card type.
+
+    Attributes:
+        Value: The 16-bit card type value as used by the reader protocol.
+        Name: Human-readable display name (e.g., "DESFire CSN (Oyster, NFC 4)").
+        EnumName: Enum/identifier name (e.g., "DESFIRE").
+    """
+    _pack_ = 1
+    _fields_ = [
+        ("Value", ctypes.c_uint16),
+        ("Name", ctypes.c_char * 128),
+        ("EnumName", ctypes.c_char * 64),
+    ]
+
+    def to_dict(self) -> dict:
+        """Convert to a Python dictionary with decoded strings."""
+        return {
+            "Value": self.Value,
+            "Name": self.Name.decode("utf-8", errors="replace").rstrip("\x00"),
+            "EnumName": self.EnumName.decode("utf-8", errors="replace").rstrip("\x00"),
+        }
+
+    def __repr__(self) -> str:
+        name = self.Name.decode("utf-8", errors="replace").rstrip("\x00")
+        enum_name = self.EnumName.decode("utf-8", errors="replace").rstrip("\x00")
+        return f"CardTypeInfo(Value=0x{self.Value:04X}, Name='{name}', EnumName='{enum_name}')"
+
+
+# Maximum number of supported card types - must match RIK_MAX_SUPPORTED_CARD_TYPES in C header
+RIK_MAX_SUPPORTED_CARD_TYPES = 256
+
+
+class SupportedCardTypesResult(ctypes.Structure):
+    """Fixed-size, ABI-safe result structure for GetSupportedCardTypes.
+
+    Attributes:
+        Count: The number of valid CardTypeInfo entries in the CardTypes array.
+        CardTypes: Fixed-size array of CardTypeInfo structs.
+    """
+    _pack_ = 1
+    _fields_ = [
+        ("Count", ctypes.c_uint32),
+        ("CardTypes", CardTypeInfo * RIK_MAX_SUPPORTED_CARD_TYPES),
+    ]

reader_integration_kit/structures/device_id.py

@@ -0,0 +1,12 @@
+from ctypes import Structure, c_ushort, c_char
+
+
+class DeviceId(Structure):
+    _pack_ = 1
+    _fields_ = [
+        ("VendorId", c_ushort),
+        ("ProductId", c_ushort),
+        ("UsbPath", c_char * 512),
+        ("SerialNumber", c_char * 256),
+    ]
+

reader_integration_kit/structures/extended_configuration.py

@@ -0,0 +1,32 @@
+import ctypes
+from typing import Any
+from reader_integration_kit.structures.field_separator_data_header import FieldSeparatorDataHeader
+from reader_integration_kit.structures.field_entry import FieldEntry
+from reader_integration_kit.structures.separator_entry import SeparatorEntry
+from reader_integration_kit.structures.reader_data import ReaderData
+
+class ExtendedConfiguration(ctypes.Structure):
+    _fields_ = [
+        ("Header", FieldSeparatorDataHeader),
+        ("FieldEntries", FieldEntry * 31),
+        ("SeparatorEntries", SeparatorEntry * 31),
+        ("AppData", ReaderData)
+    ]
+
+    def __init__(self, *args: Any, **kw: Any):
+        super().__init__()
+        self.Header = kw.get("Header", args[0] if len(args) > 0 else FieldSeparatorDataHeader())
+        self.FieldEntries = kw.get("FieldEntries", args[1] if len(args) > 1 else (FieldEntry * 31)())
+        self.SeparatorEntries = kw.get("SeparatorEntries", args[2] if len(args) > 2 else (SeparatorEntry * 31)())
+        self.AppData = kw.get("AppData", args[3] if len(args) > 3 else ReaderData())
+
+    def __eq__(self, other):
+        return (
+            self.Header == other.Header and
+            all(self.FieldEntries[i] == other.FieldEntries[i] for i in range(31)) and
+            all(self.SeparatorEntries[i] == other.SeparatorEntries[i] for i in range(31)) and
+            self.AppData == other.AppData
+        )
+    
+    def __ne__(self, other):
+        return not self.__eq__(other)

reader_integration_kit/structures/felica_sam_firmware_version.py

@@ -0,0 +1,38 @@
+from ctypes import Structure, c_uint8, c_int32
+from typing import Any
+
+
+class FelicaSamFirmwareVersion(Structure):
+    _pack_ = 1  # Ensure no padding between fields for native compatibility
+    _fields_ = [
+        ("Byte3", c_uint8),
+        ("Byte2", c_uint8),
+        ("VersionHigh", c_uint8),
+        ("VersionLow", c_uint8),
+        ("MicrocontrollerType", c_int32),  # enum class in C++ uses int (4 bytes)
+        ("SamType", c_int32),  # enum class in C++ uses int (4 bytes)
+    ]
+
+    def __init__(self, *args: Any, **kw: Any):
+        super().__init__()
+        self.SamType = kw.get("SamType", 0)
+        self.MicrocontrollerType = kw.get("MicrocontrollerType", 0)
+        self.VersionLow = kw.get("VersionLow", 0)
+        self.VersionHigh = kw.get("VersionHigh", 0)
+        self.Byte2 = kw.get("Byte2", 0)
+        self.Byte3 = kw.get("Byte3", 0)
+
+    def to_dict(self):
+        """Convert to dictionary."""
+        return {
+            "Byte3": self.Byte3,
+            "Byte2": self.Byte2,
+            "VersionHigh": self.VersionHigh,
+            "VersionLow": self.VersionLow,
+            "MicrocontrollerType": self.MicrocontrollerType,
+            "SamType": self.SamType,
+        }
+
+    def __str__(self):
+        return f"{self.Byte3}.{self.Byte2}.{self.VersionHigh}.{self.VersionLow}"
+

reader_integration_kit/structures/field_entry.py

@@ -0,0 +1,120 @@
+from ctypes import Structure, c_uint8
+from typing import Any
+
+from reader_integration_kit.enum import DataConversionType
+
+class FieldEntry(Structure):    
+    _fields_ = [
+        ("FieldValid", c_uint8),
+        ("ConversionType", c_uint8),
+        ("FixedFieldOutputLength", c_uint8),
+        ("ReverseBits", c_uint8),
+        ("ReverseBytes", c_uint8),
+        ("FiveBMS", c_uint8),
+        ("InvertBits", c_uint8),
+        ("ReverseAllBytes", c_uint8),
+        ("UseHash", c_uint8),
+        ("HashKey", c_uint8),
+        ("StartingBitPosition", c_uint8),
+        ("BitCountOfField", c_uint8)
+    ]
+
+    def __init__(self, *args: Any, **kw: Any):
+        super().__init__()
+        self.FieldValid = kw.get("FieldValid", args[0] if len(args) > 0 else 0)
+        self.ConversionType = kw.get("ConversionType", args[1] if len(args) > 1 else DataConversionType.DECIMAL.value)
+        self.FixedFieldOutputLength = kw.get("FixedFieldOutputLength", args[2] if len(args) > 2 else 0)
+        self.ReverseBits = kw.get("ReverseBits", args[3] if len(args) > 3 else 0)
+        self.ReverseBytes = kw.get("ReverseBytes", args[4] if len(args) > 4 else 0)
+        self.FiveBMS = kw.get("FiveBMS", args[5] if len(args) > 5 else 0)
+        self.InvertBits = kw.get("InvertBits", args[6] if len(args) > 6 else 0)
+        self.ReverseAllBytes = kw.get("ReverseAllBytes", args[7] if len(args) > 7 else 0)
+        self.UseHash = kw.get("UseHash", args[8] if len(args) > 8 else 0)
+        self.HashKey = kw.get("HashKey", args[9] if len(args) > 9 else 0)
+        self.StartingBitPosition = kw.get("StartingBitPosition", args[10] if len(args) > 10 else 0)
+        self.BitCountOfField = kw.get("BitCountOfField", args[11] if len(args) > 11 else 0)
+
+    def __str__(self):
+        return (
+            f"FieldValid: {self.FieldValid}\n"
+            f"ConversionType: {DataConversionType(self.ConversionType).name}\n"
+            f"FixedFieldOutputLength: {self.FixedFieldOutputLength}\n"
+            f"ReverseBits: {self.ReverseBits}\n"
+            f"ReverseBytes: {self.ReverseBytes}\n"
+            f"FiveBMS: {self.FiveBMS}\n"
+            f"InvertBits: {self.InvertBits}\n"
+            f"ReverseAllBytes: {self.ReverseAllBytes}\n"
+            f"UseHash: {self.UseHash}\n"
+            f"HashKey: {self.HashKey}\n"
+            f"StartingBitPosition: {self.StartingBitPosition}\n"
+            f"BitCountOfField: {self.BitCountOfField}\n"
+        )
+
+    def __repr__(self):
+        return self.__str__()
+
+    def __eq__(self, other):
+        return (
+            self.FieldValid == other.FieldValid
+            and self.ConversionType == other.ConversionType
+            and self.FixedFieldOutputLength == other.FixedFieldOutputLength
+            and self.ReverseBits == other.ReverseBits
+            and self.ReverseBytes == other.ReverseBytes
+            and self.FiveBMS == other.FiveBMS
+            and self.InvertBits == other.InvertBits
+            and self.ReverseAllBytes == other.ReverseAllBytes
+            and self.UseHash == other.UseHash
+            and self.HashKey == other.HashKey
+            and self.StartingBitPosition == other.StartingBitPosition
+            and self.BitCountOfField == other.BitCountOfField
+        )
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+    
+    def to_dict(self):
+        return {
+            "FieldValid": self.FieldValid,
+            "ConversionType": DataConversionType(self.ConversionType).name,
+            "FixedFieldOutputLength": self.FixedFieldOutputLength,
+            "ReverseBits": self.ReverseBits,
+            "ReverseBytes": self.ReverseBytes,
+            "FiveBMS": self.FiveBMS,
+            "InvertBits": self.InvertBits,
+            "ReverseAllBytes": self.ReverseAllBytes,
+            "UseHash": self.UseHash,
+            "HashKey": self.HashKey,
+            "StartingBitPosition": self.StartingBitPosition,
+            "BitCountOfField": self.BitCountOfField
+        }
+
+    @classmethod
+    def from_bytes(cls, byte_array):
+        return cls(
+            FieldValid=byte_array[0],
+            ConversionType=byte_array[1],
+            FixedFieldOutputLength=byte_array[2],
+            ReverseBits=byte_array[3],
+            ReverseBytes=byte_array[4],
+            FiveBMS=byte_array[5],
+            InvertBits=byte_array[6],
+            ReverseAllBytes=byte_array[7],
+            UseHash=byte_array[8],
+            HashKey=byte_array[9],
+            StartingBitPosition=byte_array[10],
+            BitCountOfField=byte_array[11]
+        )
+
+    def to_bytes(self):
+        return bytes([self.FieldValid,
+                      self.ConversionType,
+                      self.FixedFieldOutputLength,
+                      self.ReverseBits,
+                      self.ReverseBytes,
+                      self.FiveBMS,
+                      self.InvertBits,
+                      self.ReverseAllBytes,
+                      self.UseHash,
+                      self.HashKey,
+                      self.StartingBitPosition,
+                      self.BitCountOfField])

reader_integration_kit/structures/field_separator_data_header.py

@@ -0,0 +1,83 @@
+from ctypes import Structure, c_uint8
+from typing import Any
+
+class FieldSeparatorDataHeader(Structure):    
+    _fields_ = [
+        ("FieldSeparatorStructureVersion", c_uint8),
+        ("HeaderSize", c_uint8),
+        ("FieldEntrySize", c_uint8),
+        ("FieldEntryCount", c_uint8),
+        ("SeparatorEntrySize", c_uint8),
+        ("SeparatorEntryCount", c_uint8),
+        ("MaxStorageSize", c_uint8)
+    ]
+
+    def __init__(self, *args: Any, **kw: Any):
+        super().__init__()
+        self.FieldSeparatorStructureVersion = kw.get("FieldSeparatorStructureVersion", args[0] if len(args) > 0 else 1)
+        self.HeaderSize = kw.get("HeaderSize", args[1] if len(args) > 1 else 4)
+        self.FieldEntrySize = kw.get("FieldEntrySize", args[2] if len(args) > 2 else 4)
+        self.FieldEntryCount = kw.get("FieldEntryCount", args[3] if len(args) > 3 else 0)
+        self.SeparatorEntrySize = kw.get("SeparatorEntrySize", args[4] if len(args) > 4 else 2)
+        self.SeparatorEntryCount = kw.get("SeparatorEntryCount", args[5] if len(args) > 5 else 0)
+        self.MaxStorageSize = kw.get("MaxStorageSize", args[6] if len(args) > 6 else 16)
+
+    def __str__(self):
+        return (
+            f"FieldSeparatorStructureVersion: {self.FieldSeparatorStructureVersion}\n" +
+            f"HeaderSize: {self.HeaderSize}\n"
+            f"FieldEntrySize: {self.FieldEntrySize}\n"
+            f"FieldEntryCount: {self.FieldEntryCount}\n"
+            f"SeparatorEntrySize: {self.SeparatorEntrySize}\n"
+            f"SeparatorEntryCount: {self.SeparatorEntryCount}\n"
+            f"MaxStorageSize: {self.MaxStorageSize}\n"
+        )
+
+    def __repr__(self):
+        return self.__str__()
+
+    def __eq__(self, other):
+        return (
+            self.FieldSeparatorStructureVersion == other.FieldSeparatorStructureVersion
+            and self.HeaderSize == other.HeaderSize
+            and self.FieldEntrySize == other.FieldEntrySize
+            and self.FieldEntryCount == other.FieldEntryCount
+            and self.SeparatorEntrySize == other.SeparatorEntrySize
+            and self.SeparatorEntryCount == other.SeparatorEntryCount
+            and self.MaxStorageSize == other.MaxStorageSize
+        )
+    
+    def __ne__(self, other):
+        return not self.__eq__(other)
+    
+    def to_dict(self):
+        return {
+            "FieldSeparatorStructureVersion": self.FieldSeparatorStructureVersion,
+            "HeaderSize": self.HeaderSize,
+            "FieldEntrySize": self.FieldEntrySize,
+            "FieldEntryCount": self.FieldEntryCount,
+            "SeparatorEntrySize": self.SeparatorEntrySize,
+            "SeparatorEntryCount": self.SeparatorEntryCount,
+            "MaxStorageSize": self.MaxStorageSize
+        }
+
+    @classmethod
+    def from_bytes(cls, byte_array):
+        return cls(
+            FieldSeparatorStructureVersion=byte_array[0],
+            HeaderSize=byte_array[1],
+            FieldEntrySize=byte_array[2],
+            FieldEntryCount=byte_array[3],
+            SeparatorEntrySize=byte_array[4],
+            SeparatorEntryCount=byte_array[5],
+            MaxStorageSize=byte_array[6]
+        )
+
+    def to_bytes(self):
+        return bytes([self.FieldSeparatorStructureVersion,
+                      self.HeaderSize,
+                      self.FieldEntrySize,
+                      self.FieldEntryCount,
+                      self.SeparatorEntrySize,
+                      self.SeparatorEntryCount,
+                      self.MaxStorageSize])

reader_integration_kit/structures/hash_data.py

@@ -0,0 +1,55 @@
+from ctypes import Structure, c_uint8
+from typing import Any
+
+class HashData(Structure):    
+    _fields_ = [
+        ("HashKeyA", c_uint8 * 16),
+        ("HashKeyB", c_uint8 * 16),
+        ("EnhanceSecurityFirmwareState", c_uint8)
+    ]
+
+    def __init__(self, *args: Any, **kw: Any):
+        super().__init__()
+        self.HashKeyA = (c_uint8 * 16)(*(kw.get("HashKeyA") or (args[0] if len(args) > 0 else [0]*16)))
+        self.HashKeyB = (c_uint8 * 16)(*(kw.get("HashKeyB") or (args[1] if len(args) > 1 else [0]*16)))
+        self.EnhanceSecurityFirmwareState = kw.get("EnhanceSecurityFirmwareState", args[2] if len(args) > 2 else 0)
+
+    def __str__(self):
+        hash_key_a_str = ', '.join([f'0x{b:02x}' for b in self.HashKeyA])
+        hash_key_b_str = ', '.join([f'0x{b:02x}' for b in self.HashKeyB])
+        return (
+            f"HashKeyA: [{hash_key_a_str}]\n"
+            f"HashKeyB: [{hash_key_b_str}]\n"
+            f"EnhanceSecurityFirmwareState: {self.EnhanceSecurityFirmwareState}\n"
+        )
+
+    def __repr__(self):
+        return self.__str__()
+
+    def __eq__(self, other):
+        return (
+            all(self.HashKeyA[i] == other.HashKeyA[i] for i in range(16))
+            and all(self.HashKeyB[i] == other.HashKeyB[i] for i in range(16))
+            and self.EnhanceSecurityFirmwareState == other.EnhanceSecurityFirmwareState
+        )
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def to_dict(self):
+        return {
+            "HashKeyA": [b for b in self.HashKeyA],
+            "HashKeyB": [b for b in self.HashKeyB],
+            "EnhanceSecurityFirmwareState": self.EnhanceSecurityFirmwareState
+        }
+    
+    @classmethod
+    def from_bytes(cls, byte_array):
+        return cls(
+            HashKeyA=byte_array[0:16],
+            HashKeyB=byte_array[16:32],
+            EnhanceSecurityFirmwareState=byte_array[32]
+        )
+
+    def to_bytes(self):
+        return bytes(self.HashKeyA) + bytes(self.HashKeyB) + bytes([self.EnhanceSecurityFirmwareState])

reader_integration_kit/structures/hid_se_sam_firmware_version.py

@@ -0,0 +1,38 @@
+from ctypes import Structure, c_uint8, c_int32
+from typing import Any
+
+
+class HidSeSamFirmwareVersion(Structure):
+    _pack_ = 1  # Ensure no padding between fields for native compatibility
+    _fields_ = [
+        ("Byte3", c_uint8),
+        ("Byte2", c_uint8),
+        ("Major", c_uint8),
+        ("Minor", c_uint8),
+        ("MicrocontrollerType", c_int32),  # enum class in C++ uses int (4 bytes)
+        ("SamType", c_int32),  # enum class in C++ uses int (4 bytes)
+    ]
+
+    def __init__(self, *args: Any, **kw: Any):
+        super().__init__()
+        self.Major = kw.get("Major", 0)
+        self.Minor = kw.get("Minor", 0)
+        self.Byte3 = kw.get("Byte3", 0)
+        self.Byte2 = kw.get("Byte2", 0)
+        self.MicrocontrollerType = kw.get("MicrocontrollerType", 0)
+        self.SamType = kw.get("SamType", 0)
+
+    def to_dict(self):
+        """Convert to dictionary."""
+        return {
+            "Byte3": self.Byte3,
+            "Byte2": self.Byte2,
+            "Major": self.Major,
+            "Minor": self.Minor,
+            "MicrocontrollerType": self.MicrocontrollerType,
+            "SamType": self.SamType,
+        }
+
+    def __str__(self):
+        return f"{self.Byte3}.{self.Byte2}.{self.Major}.{self.Minor}"
+

reader_integration_kit/structures/led_configuration.py

@@ -0,0 +1,13 @@
+from ctypes import Structure, c_uint8, c_bool
+from reader_integration_kit.enum.led_color import LedColor
+
+
+class LedConfiguration(Structure):
+    _pack_ = 1
+    _fields_ = [
+        ("color", c_uint8),
+        ("software_control_enabled", c_bool),
+    ]
+
+    def __repr__(self):
+        return f"LedConfiguration(color={LedColor(self.color).name}, software_control_enabled={self.software_control_enabled})"