iqrfpy.objects

  7class BinaryOutputState:
  8    """Binary Output State class."""
  9
 10    __slots__ = '_index', '_state'
 11
 12    def __init__(self, index: int, state: int):
 13        """Binary Output State constructor.
 14
 15        Each binary output can be configured using the :obj:`state` value as follows:
 16        - 0 - sets output to OFF state
 17        - 1 - sets output to ON state
 18        - 2-127 - sets output to ON state for the next 2-127 minutes
 19        - 128 - reserved
 20        - 129-255 - sets output to ON state for the next 1-127 seconds
 21
 22        Args:
 23            index (int): Binary output index.
 24            state (int): State to set.
 25        """
 26        self._validate(index=index, state=state)
 27        self._index = index
 28        self._state = state
 29
 30    def _validate(self, index: int, state: int):
 31        """Validate binary output state parameters.
 32
 33        Args:
 34            index (int): Binary output index.
 35            state (int): State to set.
 36        """
 37        self._validate_index(index=index)
 38        self._validate_state(state=state)
 39
 40    @staticmethod
 41    def _validate_index(index: int):
 42        """Validate binary output index parameter.
 43
 44        Args:
 45            index (int): Binary output index.
 46
 47        Raises:
 48            RequestParameterInvalidValueError: If index is less than 0 or greater than 31.
 49        """
 50        if not dpa_constants.BINOUT_INDEX_MIN <= index <= dpa_constants.BINOUT_INDEX_MAX:
 51            raise RequestParameterInvalidValueError('Index value should be between 0 and 31.')
 52
 53    @property
 54    def index(self) -> int:
 55        """:obj:`int`: Binary output index.
 56
 57        Getter and setter.
 58        """
 59        return self._index
 60
 61    @index.setter
 62    def index(self, value: int):
 63        self._validate_index(index=value)
 64        self._index = value
 65
 66    @staticmethod
 67    def _validate_state(state: int):
 68        """Validate binary output state parameter.
 69
 70        Args:
 71            state (int): State to set.
 72
 73        Raises:
 74            RequestParameterInvalidValueError: If state is less than 0 or greater than 255.
 75        """
 76        if not dpa_constants.BYTE_MIN <= state <= dpa_constants.BYTE_MAX:
 77            raise RequestParameterInvalidValueError('State value should be between 0 and 255.')
 78
 79    @property
 80    def state(self) -> int:
 81        """:obj:`int`: Binary output state.
 82
 83        Getter and setter.
 84        """
 85        return self._state
 86
 87    @state.setter
 88    def state(self, value: int):
 89        self._validate_state(state=value)
 90        self._state = value
 91
 92    def to_json(self) -> dict:
 93        """Serialize Binary Output State to JSON API param.
 94
 95        Returns:
 96            dict: JSON-serialized Binary Output State
 97        """
 98        record = {
 99            'index': self.index,
100            'state': self.state > 0,
101        }
102        if 2 <= self.state <= 127:
103            record['time'] = self.state * 60
104        elif 128 <= self.state <= 255:
105            record['time'] = self.state - 128
106        return record

 7class CoordinatorAuthorizeBondParams:
 8    """AuthorizeBondParams class.
 9
10    Parameters for AuthorizeBond request. Each object represents a single
11    pair of device address and MID.
12    """
13
14    __slots__ = '_req_addr', '_mid'
15
16    def __init__(self, req_addr: int, mid: int):
17        """AuthorizeBondParams constructor.
18
19        Args:
20            req_addr (int): Device address
21            mid (int): Module ID
22        """
23        self._validate(req_addr=req_addr, mid=mid)
24        self._req_addr = req_addr
25        self._mid = mid
26
27    def _validate(self, req_addr: int, mid: int):
28        """Validates pair parameters.
29
30        Args:
31            req_addr (int): Requested node address.
32            mid (int): Module ID.
33        """
34        self._validate_req_addr(req_addr=req_addr)
35        self._validate_mid(mid=mid)
36
37    @staticmethod
38    def _validate_req_addr(req_addr: int):
39        """Validates requested node address.
40
41        Args:
42            req_addr (int): Requested node address.
43
44        Raises:
45            RequestParameterInvalidValueError: If req_addr is less than 0 or greater than 255.
46        """
47        if not dpa_constants.BYTE_MIN <= req_addr <= dpa_constants.BYTE_MAX:
48            raise RequestParameterInvalidValueError('Requested address value should be between 1 and 239.')
49
50    @property
51    def req_addr(self) -> int:
52        """:obj:`int`: Requested node address.
53
54        Getter and setter.
55        """
56        return self._req_addr
57
58    @req_addr.setter
59    def req_addr(self, value: int):
60        self._validate_req_addr(req_addr=value)
61        self._req_addr = value
62
63    @staticmethod
64    def _validate_mid(mid: int):
65        """Validates module ID.
66
67        Args:
68            mid (int): Module ID.
69
70        Raises:
71            RequestParameterInvalidValueError: If mid is less than 0 or greater than 4294967295.
72        """
73        if not dpa_constants.MID_MIN <= mid <= dpa_constants.MID_MAX:
74            raise RequestParameterInvalidValueError('MID value should be an unsigned 32bit integer.')
75
76    @property
77    def mid(self) -> int:
78        """:obj:`int`: Module ID.
79
80        Getter and setter.
81        """
82        return self._mid
83
84    @mid.setter
85    def mid(self, value: int):
86        self._validate_mid(mid=value)
87        self._mid = value

 6class CoordinatorDpaParam(IntEnum):
 7    """DpaParam class.
 8
 9    Parameters for SetDpaParams request.
10    """
11    LAST_RSSI = 0
12    VOLTAGE = 1
13    SYSTEM = 2
14    USER_SPECIFIED = 3

 7@dataclass
 8class ExplorationPerEnumData:
 9    """Exploration Peripheral Enumeration Data class."""
10
11    __slots__ = 'dpa_version', 'user_per_nr', 'embedded_pers', 'hwpid', 'hwpid_ver', 'flags', 'user_per'
12
13    def __init__(self, result: dict, os_read: bool = False):
14        """Peripheral Enumeration Data constructor.
15
16        Args:
17            result (dict): Peripheral enumeration result.
18            os_read (boolean): Data parsed from OS Read response.
19        """
20        self.dpa_version: int = result['dpaVer']
21        """DPA version."""
22        self.user_per_nr: int = result['perNr']
23        """Number of non-embedded peripherals implemented by custom DPA handler."""
24        self.embedded_pers: List[int] = result['embeddedPers']
25        """List of embedded peripherals implemented by device."""
26        self.hwpid: int = result['hwpid']
27        """Hardware profile ID."""
28        self.hwpid_ver: int = result['hwpidVer']
29        """Hardware profile version."""
30        self.flags: int = result['flagsEnum' if os_read else 'flags']
31        """Device function flags."""
32        self.user_per: List[int] = result['userPer']
33        """List of non-embedded peripherals implemented by device."""

 8@dataclass
 9class ExplorationPerInfoData:
10    """Exploration Peripheral Information Data class."""
11
12    __slots__ = 'perte', 'pert', 'par1', 'par2'
13
14    def __init__(self, result: dict):
15        """Peripheral Information Data constructor.
16
17        Args:
18            result (dict): Peripheral enumeration result.
19        """
20        self.perte: int = result['perTe']
21        """Extended peripheral characteristic."""
22        self.pert: Union[PeripheralTypes, int] = result['perT']
23        """Peripheral type. If the peripheral is not supported or enabled, value is equal
24        to :obj:`PERIPHERAL_TYPE_DUMMY`."""
25        self.par1 = result['par1']
26        """Optional peripheral specific information."""
27        self.par2 = result['par2']
28        """Optional peripheral specific information."""

 7@dataclass
 8class FrcParams:
 9    """FRC Params class."""
10
11    __slots__ = 'offline_frc', 'frc_response_time'
12
13    def __init__(self, offline_frc: bool = False, frc_response_time: FrcResponseTimes = FrcResponseTimes.MS40):
14        """FRC Params constructor.
15
16        Args:
17            offline_frc (bool): Offline FRC.
18            frc_response_time (FrcResponseTimes): FRC response time.
19        """
20        self.offline_frc: bool = offline_frc
21        """Offline FRC."""
22        self.frc_response_time: FrcResponseTimes = frc_response_time
23        """FRC response time."""
24
25    @classmethod
26    def from_int(cls, value: int) -> 'FrcParams':
27        """Deserializes FRC Params integer value into FRC Params object.
28
29        Args:
30            value (int): FRC params integer value.
31        """
32        return cls(
33            offline_frc=bool(value & 0x08),
34            frc_response_time=FrcResponseTimes(value & 0x70)
35        )
36
37    def to_data(self) -> int:
38        """Serialize FRC Params object into an integer value.
39
40        Returns:
41            :obj:`int`: Serialized FRC params value.
42        """
43        return self.frc_response_time | int(self.offline_frc) << 3

10@dataclass
11class InitPhyData:
12    """TR configuration InitPhy data class."""
13
14    __slots__ = 'rf_band', 'thermometer_present', 'serial_eeprom_present', 'il_type', 'value'
15
16    def __init__(self, val: int):
17        """TR configuration InitPhy data constructor.
18
19        Args:
20            val (int): InitPhy value.
21        """
22        rf_band = val & 0x03
23        self.rf_band: Optional[RfBands] = RfBands(rf_band) if rf_band in RfBands else None
24        """RF Band."""
25        self.thermometer_present = bool(val & 0x10)
26        """Thermometer chip is present."""
27        self.serial_eeprom_present = bool(val & 0x20)
28        """Serial EEPROM chip is present."""
29        self.il_type = bool(val & 0x40)
30        """Transceiver for Israel region."""
31        self.value: int = val
32        """Raw value."""

  8class IoTriplet:
  9    """IO Triplet parameter class."""
 10
 11    __slots__ = '_port', '_mask', '_value'
 12
 13    def __init__(self, port: Union[IoConstants, int], mask: int, value: int):
 14        """IO Triplet constructor.
 15
 16        Args:
 17            port (Union[IoConstants, int]): Port number.
 18            mask (int): Port pin mask.
 19            value (int): Value to write.
 20        """
 21        self._validate(port=port, mask=mask, value=value)
 22        self._port = port
 23        self._mask = mask
 24        self._value = value
 25
 26    def _validate(self, port: int, mask: int, value: int):
 27        """Validate IO triplet parameters.
 28
 29        Args:
 30            port (int): Port number.
 31            mask (int): Port pin mask.
 32            value (int): Value to write.
 33        """
 34        self._validate_port(port=port)
 35        self._validate_mask(mask=mask)
 36        self._validate_value(value=value)
 37
 38    @staticmethod
 39    def _validate_port(port: Union[IoConstants, int]):
 40        """Validate port number.
 41
 42        Args:
 43            port (Union[IoConstants, int]): Port number.
 44
 45        Raises:
 46            RequestParameterInvalidValueError: If port is less than 0 or greater than 255.
 47        """
 48        if not BYTE_MIN <= port <= BYTE_MAX:
 49            raise RequestParameterInvalidValueError('Port should be between 0 and 255.')
 50
 51    @property
 52    def port(self) -> Union[IoConstants, int]:
 53        """:obj:`int` or :obj:`IoConstants`: Port number.
 54
 55        Getter and setter.
 56        """
 57        return self._port
 58
 59    @port.setter
 60    def port(self, val: Union[IoConstants, int]):
 61        self._validate_port(port=val)
 62        self._value = val
 63
 64    @staticmethod
 65    def _validate_mask(mask: int):
 66        """Validate port pin mask.
 67
 68        Args:
 69            mask (int): Port pin mask.
 70
 71        Raises:
 72            RequestParameterInvalidValueError: If mask is less than 0 or greater than 255.
 73        """
 74        if not BYTE_MIN <= mask <= BYTE_MAX:
 75            raise RequestParameterInvalidValueError('Mask should be between 0 and 255.')
 76
 77    @property
 78    def mask(self) -> int:
 79        """:obj:`int`: Port pin mask.
 80
 81        Getter and setter.
 82        """
 83        return self._mask
 84
 85    @mask.setter
 86    def mask(self, val: int):
 87        self._validate_mask(mask=val)
 88        self._mask = val
 89
 90    @staticmethod
 91    def _validate_value(value: int):
 92        """Validate value to write.
 93
 94        Args:
 95            value (int): Value to write.
 96
 97        Raises:
 98            RequestParameterInvalidValueError: If value is less than 0 or greater than 255.
 99        """
100        if not BYTE_MIN <= value <= BYTE_MAX:
101            raise RequestParameterInvalidValueError('Value should be between 0 and 255.')
102
103    @property
104    def value(self) -> int:
105        """:obj:`int`: Value to write.
106
107        Getter and setter.
108        """
109        return self._value
110
111    @value.setter
112    def value(self, val: int):
113        self._validate_value(value=val)
114        self._value = val

 6@dataclass
 7class NodeReadData:
 8    """Node Read Data class."""
 9
10    __slots__ = 'ntw_addr', 'ntw_vrn', 'ntw_zin', 'ntw_did', 'ntw_pvrn', 'ntw_useraddr', 'ntw_id', 'ntw_vrnfnz', \
11        'ntw_cfg', 'flags'
12
13    def __init__(self, data: dict):
14        """Node Read Data constructor.
15
16        Args:
17            data (dict): Node read result.
18        """
19        self.ntw_addr: int = data['ntwADDR']
20        """Logical node address."""
21        self.ntw_vrn: int = data['ntwVRN']
22        """Virtual routing number."""
23        self.ntw_zin: int = data['ntwZIN']
24        """Zone index (zone number + 1)."""
25        self.ntw_did: int = data['ntwDID']
26        """Discovery ID."""
27        self.ntw_pvrn: int = data['ntwPVRN']
28        """Parent virtual routing number."""
29        self.ntw_useraddr: int = data['ntwUSERADDRESS']
30        """User address."""
31        self.ntw_id: int = data['ntwID']
32        """Network identification."""
33        self.ntw_vrnfnz: int = data['ntwVRNFNZ']
34        """Virtual routing number of first node in zone."""
35        self.ntw_cfg: int = data['ntwCFG']
36        """Network configuration."""
37        self.flags: int = data['flags']
38        """Node flags."""

 7class NodeValidateBondsParams:
 8    """Node Validate Bonds parameters class."""
 9
10    __slots__ = '_bond_addr', '_mid'
11
12    def __init__(self, bond_addr: int, mid: int):
13        """Validate Bonds parameters constructor.
14
15        Args:
16            bond_addr (int): Node device address.
17            mid (int): Node module ID.
18        """
19        self._validate(bond_addr=bond_addr, mid=mid)
20        self._bond_addr = bond_addr
21        self._mid = mid
22
23    def _validate(self, bond_addr: int, mid: int):
24        """Validate parameters.
25
26        Args:
27            bond_addr (int): Node device address.
28            mid (int): Node module ID.
29        """
30        self._validate_bond_addr(bond_addr)
31        self._validate_mid(mid)
32
33    @staticmethod
34    def _validate_bond_addr(bond_addr: int):
35        """Validate node device address parameter.
36
37        Args:
38            bond_addr (int): Node device address.
39
40        Raises:
41            RequestParameterInvalidValueError: If bond_addr is less than 0 or greater than 255.
42        """
43        if not dpa_constants.BYTE_MIN <= bond_addr <= dpa_constants.BYTE_MAX:
44            raise RequestParameterInvalidValueError('Bond address value should be between 0 and 255.')
45
46    @property
47    def bond_addr(self) -> int:
48        """:obj:`int`: Node device address.
49
50        Getter and setter.
51        """
52        return self._bond_addr
53
54    @bond_addr.setter
55    def bond_addr(self, value: int):
56        self._validate_bond_addr(value)
57        self._bond_addr = value
58
59    @staticmethod
60    def _validate_mid(mid: int):
61        """Validate module ID parameter.
62
63        Args:
64            mid (int): Node module ID.
65
66        Raises:
67            RequestParameterInvalidValueError: If mid is less than 0 or greater than 4294967295.
68        """
69        if not dpa_constants.MID_MIN <= mid <= dpa_constants.MID_MAX:
70            raise RequestParameterInvalidValueError('MID value should be an unsigned 32bit integer.')
71
72    @property
73    def mid(self):
74        """:obj:`int`: Module ID.
75
76        Getter and setter.
77        """
78        return self._mid
79
80    @mid.setter
81    def mid(self, value):
82        self._validate_mid(value)
83        self._mid = value

 11class OsBatchData:
 12    """Batch Data class."""
 13
 14    __slots__ = '_pnum', '_pcmd', '_hwpid', '_pdata'
 15
 16    def __init__(self, pnum: Union[Peripheral, int], pcmd: Union[Command, int], hwpid: int = dpa_constants.HWPID_MAX,
 17                 pdata: Optional[List[int]] = None):
 18        """Batch Data constructor.
 19
 20        Args:
 21            pnum (Union[Peripheral, int]): Peripheral number.
 22            pcmd (Union[Command, int]): Peripheral command.
 23            hwpid (int): Hardware profile ID. Defaults to 65535, this value ignores HWPID check.
 24            pdata (List[int], optional): Request data.
 25        """
 26        self._validate(pnum=pnum, pcmd=pcmd, hwpid=hwpid, pdata=pdata)
 27        self._pnum = pnum
 28        self._pcmd = pcmd
 29        self._hwpid = hwpid
 30        self._pdata = pdata if pdata is not None else []
 31
 32    def _validate(self, pnum: Union[Peripheral, int], pcmd: Union[Command, int], hwpid: int,
 33                  pdata: Optional[List[int]] = None):
 34        """Validate batch parameters.
 35
 36        Args:
 37            pnum (Union[Peripheral, int]): Peripheral number.
 38            pcmd (Union[Command, int]): Peripheral command.
 39            hwpid (int): Hardware profile ID. Defaults to 65535, this value ignores HWPID check.
 40            pdata (List[int], optional): Request data.
 41        """
 42        self._validate_pnum(pnum)
 43        self._validate_pcmd(pcmd)
 44        self._validate_hwpid(hwpid)
 45        self._validate_pdata(pdata)
 46
 47    @staticmethod
 48    def _validate_pnum(pnum: Union[Peripheral, int]):
 49        """Validate peripheral number parameter.
 50
 51        Args:
 52            pnum (Union[Peripheral, int]): Peripheral number.
 53
 54        Raises:
 55            RequestParameterInvalidValueError: If pnum is less than 0 or greater than 255.
 56        """
 57        if not dpa_constants.BYTE_MIN <= pnum <= dpa_constants.BYTE_MAX:
 58            raise RequestParameterInvalidValueError('PNUM value should be between 0 and 255.')
 59
 60    @property
 61    def pnum(self) -> Union[Peripheral, int]:
 62        """:obj:`Peripheral` or :obj:`int`: Peripheral number.
 63
 64        Getter and setter.
 65        """
 66        return self._pnum
 67
 68    @pnum.setter
 69    def pnum(self, value: Union[Peripheral, int]):
 70        self._validate_pnum(value)
 71        self._pnum = value
 72
 73    @staticmethod
 74    def _validate_pcmd(pcmd: Union[Command, int]):
 75        """Validate peripheral command parameter.
 76
 77        Args:
 78            pcmd (Union[Command, int]): Peripheral command.
 79
 80        Raises:
 81            RequestParameterInvalidValueError: If pcmd is less than 0 or greater than 255.
 82        """
 83        if not dpa_constants.BYTE_MIN <= pcmd <= dpa_constants.BYTE_MAX:
 84            raise RequestParameterInvalidValueError('PCMD value should be between 0 and 255.')
 85
 86    @property
 87    def pcmd(self) -> Union[Command, int]:
 88        """:obj:`Command` or :obj:`int`: Peripheral command.
 89
 90        Getter and setter.
 91        """
 92        return self._pcmd
 93
 94    @pcmd.setter
 95    def pcmd(self, value: Union[Command, int]):
 96        self._validate_pcmd(value)
 97        self._pcmd = value
 98
 99    @staticmethod
100    def _validate_hwpid(hwpid: int):
101        """Validate hardware profile ID parameter.
102
103        Args:
104            hwpid (int): Hardware profile ID. Defaults to 65535, this value ignores HWPID check.
105
106        Raises:
107            RequestParameterInvalidValueError: If hwpid is less than 0 or greater than 65535.
108        """
109        if not dpa_constants.HWPID_MIN <= hwpid <= dpa_constants.HWPID_MAX:
110            raise RequestParameterInvalidValueError('HWPID value should be between 0 and 65535.')
111
112    @property
113    def hwpid(self) -> int:
114        """:obj:`int`: Hardware profile ID.
115
116        Getter and setter.
117        """
118        return self._hwpid
119
120    @hwpid.setter
121    def hwpid(self, value: int):
122        self._validate_hwpid(value)
123        self._hwpid = value
124
125    @staticmethod
126    def _validate_pdata(pdata: Optional[List[int]] = None):
127        """Validate pdata parameter.
128
129        Args:
130            pdata (List[int], optional): Request data.
131        """
132        if pdata is None:
133            return
134        if not Common.values_in_byte_range(pdata):
135            raise RequestParameterInvalidValueError('PDATA values should be between 0 and 255.')
136
137    @property
138    def pdata(self) -> Optional[List[int]]:
139        """:obj:`list` of :obj:`int` or :obj:`None`: Request data.
140
141        Getter and setter.
142        """
143        return self._pdata
144
145    @pdata.setter
146    def pdata(self, value: Optional[List[int]] = None):
147        self._validate_pdata(value)
148        self._pdata = value if value is not None else []
149
150    def to_pdata(self) -> List[int]:
151        """Serialize batch data into DPA request pdata.
152
153        Returns:
154            :obj:`list` of :obj:`int`: Serialized DPA request pdata.
155        """
156        data = [self._pnum, self._pcmd, self._hwpid & 0xFF, (self._hwpid >> 8) & 0xFF] + self._pdata
157        return [len(data) + 1] + data
158
159    def to_json(self) -> dict:
160        """Serialize batch data into JSON API request data.
161
162        Returns:
163            :obj:`dict`: Serialized JSON API request data.
164        """
165        data = {
166            'pnum': f'{self._pnum:02x}',
167            'pcmd': f'{self._pcmd:02x}',
168            'hwpid': f'{self._hwpid:04x}',
169        }
170        if self._pdata is not None and len(self._pdata) > 0:
171            data['rdata'] = '.'.join([f'{x:02x}' for x in self._pdata])
172        return data

 6class OsIndicateParam(IntEnumMember):
 7    """OS Indicate control params enum."""
 8
 9    OFF = 0
10    ON = 1
11    INDICATE_1S = 2
12    INDICATE_10S = 3

 6class OsLoadCodeFlags:
 7    """OS Load Code flags class."""
 8    __slots__ = '_action', '_code_type'
 9
10    def __init__(self, action: OsLoadCodeAction, code_type: OsLoadCodeType):
11        """Load Code flags constructor.
12
13        Args:
14            action (OsLoadCodeAction): Load code action.
15            code_type (OsLoadCodeType): Load code code type.
16        """
17        self._action = action
18        self._code_type = code_type
19
20    @property
21    def action(self) -> OsLoadCodeAction:
22        """:obj:`OsLoadCodeAction`: Load Code action.
23
24        Getter and setter.
25        """
26        return self._action
27
28    @action.setter
29    def action(self, value: OsLoadCodeAction):
30        self._action = value
31
32    @property
33    def code_type(self) -> OsLoadCodeType:
34        """:obj:`OsLoadCodeType`: Load Code code type.
35
36        Getter and setter.
37        """
38        return self._code_type
39
40    @code_type.setter
41    def code_type(self, value: OsLoadCodeType):
42        self._code_type = value
43
44    def serialize(self) -> int:
45        """Serialize flags into an integer value.
46
47        Returns:
48            :obj:`int`: Flags value.
49        """
50        return self._action | (self._code_type << 1)

 8@dataclass
 9class OsReadData:
10    """OS Read Data class."""
11
12    __slots__ = 'mid', 'os_version', 'tr_mcu_type', 'os_build', 'rssi', 'supply_voltage', 'flags', 'slot_limits', 'ibk', \
13        'per_enum'
14
15    def __init__(self, data: dict):
16        """Read Data constructor.
17
18        Args:
19            data (dict): OS Read data.
20        """
21        self.mid: int = data['mid']
22        """Module ID."""
23        self.os_version: int = data['osVersion']
24        """OS version."""
25        self.tr_mcu_type: TrMcuTypeData = TrMcuTypeData(data['trMcuType'])
26        """MCU type and TR series."""
27        self.os_build: int = data['osBuild']
28        """OS build."""
29        self.rssi: int = data['rssi']
30        """RSSI."""
31        self.supply_voltage: int = data['supplyVoltage']
32        """Supply voltage."""
33        self.flags: int = data['flags']
34        """OS flags."""
35        self.slot_limits: int = data['slotLimits']
36        """Slot limits."""
37        self.ibk: int = data['ibk']
38        """Individual bonding key."""
39        self.per_enum: ExplorationPerEnumData = ExplorationPerEnumData(data, os_read=True)
40        """Peripheral enumeration data."""