iqrfpy.messages

 17class IRequest(ABC):
 18    """This abstract class serves as an interface for embedded peripherals and standards request messages.
 19
 20    The class provides getters and setters for shared request properties in the form of the @property decorator.
 21    Shared properties such as device address, peripheral, peripheral command and hwpid are validated here.
 22    The class also provides generic DPA and JSON serialization methods for derived classes to amend.
 23    While the abstract class cannot be instantiated, it's methods can be called from a derived class using super.
 24
 25    Network address (nadr) specifies target device: 0 (coordinator), 1-239 (node), 252 (local device),
 26    254 (temporary address) and 255 (broadcast), other values are reserved. Values in range 0-255.
 27
 28    Peripheral number (pnum) specifies peripheral to use: 0-31 are served for embedded peripherals and
 29    64-127 are reserved for IQRF standard peripherals. Peripheral number can be passed as a member of one
 30    of the peripheral enum class members (see iqrfpy.enums.peripherals) or plain integer. Values in range 0-255.
 31
 32    Peripheral command (pcmd) specifies a command to execute, each peripheral implements different commands.
 33    See DPA framework document for specific command numbers. Peripheral command can be passed as a member of one
 34    of the peripheral command enum class members (see iqrfpy.enums.commands) or plain integer.
 35    Peripheral number and peripheral command are pre-defined for each command message this library implements,
 36    however they will be required for user-defined messages. Values in range 0-255, but note that only values
 37    0-127 are used for request commands, as response command value is equal to request command value plus 128 (0x80).
 38
 39    Hardware profile ID (hwpid) specifies a unique device (by its functionality), this argument can be used to filter
 40    which devices execute a commend specified by request message. Only devices with matching hwpid will execute
 41    a command, unless the value 65535 (0xFFFF) is used, which ignores hwpid checking. Values in range 0-65535.
 42
 43    Packet data (pdata) can be required or optional data sent with the request message, depending on the command.
 44    On a general level, packet data is treated as list of unsigned 1B integers. This means that when defining a user
 45    command and a request message, request data should be serialized into a list of previously mentioned
 46    format and stored in the pdata member.
 47
 48    For more detailed information, see the IQRF DPA Framework documentation.
 49
 50    Message type (m_type) is an optional argument, however, it is required when using JSON API as message type
 51    is equivalent to a combination of peripheral number and peripheral command (see iqrfpy.enums.message_types).
 52    For example, `OSMessages.READ` (iqrfEmbedOs_Read) is equivalent to `EmbedPeripherals.OS` (2) and
 53    `OSRequestCommands.READ` (0).
 54
 55    Request parameters (params) is an optional dictionary argument, that is used when constructing a JSON API request.
 56    When creating a user message, use the params member to propagate your request parameters into the final
 57    JSON request object.
 58
 59    DPA response time (dpa_rsp_time) is an optional argument specifying DPA request timeout, not time between reception
 60    of a request and delivery of response. Note that handling of this argument is the responsibility of a transport
 61    and system facilitating communication between the library and devices of the IQRF network.
 62
 63    Device processing time (dev_process_time) is an optional argument used to specify time allotted to the device
 64    executing a task beyond simple data processing. For example, a device may need to measure some quantity
 65    for certain amount of time for the measured value to be valid. Note that handling of this argument
 66    is the responsibility of a transport and system facilitating communication between the library and devices
 67    of the IQRF network.
 68
 69    Message ID (msgid) is an optional argument used only by the JSON API at this time. It is used to pair
 70    JSON API requests and responses as the message type argument only allows to pair requests of the same type,
 71    but not pairing a specific request and response, given the asynchronous nature of the JSON API.
 72    """
 73
 74    __slots__ = '_nadr', '_pnum', '_pcmd', '_mtype', '_hwpid', '_pdata', '_msgid', '_params', '_dpa_rsp_time', \
 75        '_dev_process_time'
 76
 77    def __init__(self, nadr: int, pnum: Union[Peripheral, int], pcmd: Union[Command, int],
 78                 hwpid: int = dpa_constants.HWPID_MAX, pdata: Optional[List[int]] = None,
 79                 m_type: Optional[MessageType] = None, msgid: Optional[str] = None,
 80                 params: Optional[dict] = None, dpa_rsp_time: Optional[float] = None,
 81                 dev_process_time: Optional[float] = None):
 82        """IRequest constructor.
 83
 84        Args:
 85            nadr (int): Network address.
 86            pnum (Union[Peripheral, int]): Peripheral number.
 87            pcmd (Union[Command, int]): Peripheral command.
 88            hwpid (int, optional): Hardware profile ID. Defaults to 65535 (Ignore HWPID check).
 89            pdata (List[int], optional): DPA request data. Defaults to None.
 90            m_type (MessageType, optional): JSON API message type. Defaults to None.
 91            msgid (str, optional): JSON API message ID. Defaults to None. If the parameter is not specified, a random
 92                UUIDv4 string is generated and used.
 93            params (dict, optional): JSON API request data. Defaults to None.
 94            dpa_rsp_time (float, optional): DPA request timeout in seconds. Defaults to None.
 95            dev_process_time (float, optional): Device processing time. Defaults to None.
 96        """
 97        self._nadr = nadr
 98        self._pnum = pnum
 99        self._pcmd = pcmd
100        self._hwpid = hwpid
101        self._pdata = pdata
102        self._mtype = m_type
103        self._msgid = msgid if msgid is not None else str(uuid4())
104        self._params = params if params is not None else {}
105        self._dpa_rsp_time = dpa_rsp_time
106        self._dev_process_time = dev_process_time
107        self._validate_base(nadr, pnum, pcmd, hwpid, dpa_rsp_time, dev_process_time)
108
109    def _validate_base(self, nadr: int, pnum: Union[Peripheral, int], pcmd: Union[Command, int], hwpid: int,
110                       dpa_rsp_time: Optional[float], dev_process_time: Optional[float]) -> None:
111        """Shared members validation method.
112
113        Validates shared request members to ensure the data can fit into the DPA packet and JSON request
114        object and do not violate rules for expected format of these properties.
115
116        Args:
117            nadr (int): Network address.
118            pnum (Union[Peripheral, int]): Peripheral number.
119            pcmd (Union[Command, int]): Peripheral command.
120            hwpid (int, optional): Hardware profile ID. Defaults to 65535 (Ignore HWPID check).
121            dpa_rsp_time (float, optional): DPA request timeout in seconds. Defaults to None.
122            dev_process_time (float, optional): Device processing time. Defaults to None.
123        """
124        self._validate_nadr(nadr)
125        self._validate_pnum(pnum)
126        self._validate_pcmd(pcmd)
127        self._validate_hwpid(hwpid)
128        self._validate_dpa_rsp_time(dpa_rsp_time)
129        self._validate_dev_process_time(dev_process_time)
130
131    @staticmethod
132    def _validate_nadr(nadr: int):
133        """Validates network address parameter.
134
135        Args:
136            nadr (int): Network address value.
137
138        Raises:
139            RequestNadrInvalidError: If nadr is less than 0 or greater than 255.
140        """
141        if not dpa_constants.BYTE_MIN <= nadr <= dpa_constants.BYTE_MAX:
142            raise RequestNadrInvalidError('NADR should be between 0 and 255.')
143
144    @property
145    def nadr(self) -> int:
146        """:obj:`int`: Network address.
147
148        Getter and setter.
149        """
150        return self._nadr
151
152    @nadr.setter
153    def nadr(self, value: int):
154        self._validate_nadr(value)
155        self._nadr = value
156
157    @staticmethod
158    def _validate_pnum(pnum: Union[Peripheral, int]):
159        """Validates peripheral number parameter.
160
161        Args:
162            pnum (Union[Peripheral, int]): Peripheral number value.
163
164        Raises:
165            RequestPnumInvalidError: If pnum is less than 0 or greater than 255.
166        """
167        if not dpa_constants.BYTE_MIN <= pnum <= dpa_constants.BYTE_MAX:
168            raise RequestPnumInvalidError('PNUM should be between 0 and 255.')
169
170    @property
171    def pnum(self) -> Union[Peripheral, int]:
172        """:obj:`iqrfpy.enums.peripherals.Peripheral` of :obj:`int`: Peripheral number.
173
174        Getter and setter.
175        """
176        return self._pnum
177
178    @pnum.setter
179    def pnum(self, value: Union[Peripheral, int]):
180        self._validate_pnum(pnum=value)
181        self._pnum = value
182
183    @staticmethod
184    def _validate_pcmd(pcmd: Union[Command, int]):
185        """Validates peripheral command parameter.
186
187        Args:
188            pcmd (Union[Command, int]): Peripheral command value.
189
190        Raises:
191            RequestPcmdInvalidError: If pcmd is less than 0 or greater than 255.
192        """
193        if not dpa_constants.BYTE_MIN <= pcmd <= dpa_constants.BYTE_MAX:
194            raise RequestPcmdInvalidError('PCMD should be between 0 and 255.')
195
196    @property
197    def pcmd(self) -> Union[Command, int]:
198        """:obj:`iqrfpy.enums.commands.Command` or :obj:`int`: Peripheral command.
199
200        Getter and setter.
201        """
202        return self._pcmd
203
204    @pcmd.setter
205    def pcmd(self, value: Union[Command, int]):
206        self._validate_pcmd(pcmd=value)
207        self._pcmd = value
208
209    @staticmethod
210    def _validate_hwpid(hwpid: int):
211        """Validates Hardware profile ID parameter.
212
213        Args:
214            hwpid (int): Hardware profile ID value.
215
216        Raises:
217            RequestHwpidInvalidError: If hwpid is less than 0 or greater than 65535.
218        """
219        if not dpa_constants.HWPID_MIN <= hwpid <= dpa_constants.HWPID_MAX:
220            raise RequestHwpidInvalidError('HWPID should be between 0 and 65535.')
221
222    @property
223    def hwpid(self) -> int:
224        """:obj:`int`: Hardware profile ID.
225
226        Getter and setter.
227        """
228        return self._hwpid
229
230    @staticmethod
231    def _validate_dpa_rsp_time(dpa_rsp_time: Optional[float] = None):
232        """Validates dpa timeout parameter.
233
234        Args:
235            dpa_rsp_time (float, optional): DPA timeout value in seconds. Defaults to None.
236
237        Raises:
238            RequestParameterInvalidValueError: If dpa_rsp_time is not None and is less than 0.
239        """
240        if dpa_rsp_time is None:
241            return
242        if dpa_rsp_time < 0:
243            raise RequestParameterInvalidValueError('DPA response time should a positive integer.')
244
245    @property
246    def dpa_rsp_time(self) -> Optional[float]:
247        """:obj:`float` or :obj:`None`: DPA timeout.
248
249        Getter and setter.
250        """
251        return self._dpa_rsp_time
252
253    @dpa_rsp_time.setter
254    def dpa_rsp_time(self, value: Optional[float] = None):
255        self._validate_dpa_rsp_time(value)
256        self._dpa_rsp_time = value
257
258    @staticmethod
259    def _validate_dev_process_time(dev_process_time: Optional[float] = None):
260        """Validates device processing time parameter.
261
262        Args:
263            dev_process_time (float, optional): Device processing time value. Defaults to None.
264
265        Raises:
266            RequestParameterInvalidValueError: If dev_process_time is not None and is less than 0.
267        """
268        if dev_process_time is None:
269            return
270        if dev_process_time < 0:
271            raise RequestParameterInvalidValueError('Device processing time should be a positive integer.')
272
273    @property
274    def dev_process_time(self) -> Optional[float]:
275        """:obj:`float` or :obj:`None`: Device processing time.
276
277        Getter and setter.
278        """
279        return self._dev_process_time
280
281    @dev_process_time.setter
282    def dev_process_time(self, value: Optional[float] = None):
283        self._validate_dev_process_time(value)
284        self._dev_process_time = value
285
286    @property
287    def msgid(self) -> str:
288        """:obj:`str`: Message ID.
289
290        Getter and setter.
291        """
292        return self._msgid
293
294    @msgid.setter
295    def msgid(self, value: str):
296        self._msgid = value
297
298    @property
299    def mtype(self) -> MessageType:
300        """:obj:`MessageType` Message type.
301
302        Getter only.
303        """
304        return self._mtype
305
306    @abstractmethod
307    def to_dpa(self, mutable: bool = False) -> Union[bytes, bytearray]:
308        """DPA request serialization method.
309
310        Serializes a request to DPA request packet format. Each request contains the DPA request header.
311        If pdata is specified, it is appended to the DPA request header. The request can be serialized
312        into both mutable and immutable (default) byte formats.
313
314        Args:
315            mutable (bool, optional): Serialize into mutable byte representation of DPA request packet.
316                Defaults to False.
317
318        Returns:
319            :obj:`bytes`: Immutable byte representation of DPA request packet.\n
320            :obj:`bytearray`: Mutable byte representation of DPA request packet (if argument mutable is True).
321        """
322        raise NotImplementedError('Abstract method not implemented.')
323
324    @abstractmethod
325    def to_json(self) -> dict:
326        """JSON API request serialization method.
327
328        Serializes a request to JSON API request object. Each request contains message type and data.
329        Data carries message ID for pairing requests with responses, and `req` object that contains network address,
330        hwpid and optional request parameters (equivalent to DPA packet data) if `params` is not None.
331        If DPA timeout is specified, the value is multiplied by 1000 as JSON API accepts timeout in milliseconds.
332
333        Returns:
334            :obj:`dict`: JSON API request object.
335        """
336        raise NotImplementedError('Abstract method not implemented')

 15class IResponse(ABC):
 16    """This class serves as an interface for embedded peripherals and standards response messages.
 17
 18    This class does not provide any deserialization logic in its factory methods as they simply serve as abstracts.
 19
 20    Once a factory method is implemented, it should be used to parse responses and create response message objects.
 21    """
 22
 23    ASYNC_MSGID = 'async'
 24
 25    def __init__(self, nadr: int, pnum: Union[Peripheral, int], pcmd: Union[Command, int],
 26                 hwpid: int = dpa_constants.HWPID_MAX, rcode: int = 0, dpa_value: int = 0,
 27                 pdata: Optional[List[int]] = None, m_type: Optional[Union[MessageType, str]] = None,
 28                 msgid: Optional[str] = None, result: Optional[dict] = None):
 29        self._nadr = nadr
 30        self._pnum = pnum
 31        self._pcmd = pcmd
 32        self._mtype = m_type
 33        self._hwpid = hwpid
 34        self._rcode = rcode
 35        self._dpa_value = dpa_value
 36        self._pdata = pdata
 37        self._msgid = msgid
 38        self._result = result
 39
 40    @property
 41    @abstractmethod
 42    def nadr(self) -> int:
 43        """:obj:`int`: Device address.
 44
 45        Getter only.
 46        """
 47        return self._nadr
 48
 49    @property
 50    @abstractmethod
 51    def pnum(self) -> Union[Peripheral, int]:
 52        """:obj:`Peripheral` or :obj:`int`: Peripheral number.
 53
 54        Getter only.
 55        """
 56        return self._pnum
 57
 58    @property
 59    @abstractmethod
 60    def pcmd(self) -> Union[Command, int]:
 61        """:obj:`Command` or :obj:`int`: Peripheral command.
 62
 63        Getter only.
 64        """
 65        return self._pcmd
 66
 67    @property
 68    @abstractmethod
 69    def mtype(self) -> Optional[Union[MessageType, str]]:
 70        """:obj:`MessageType` or :obj:`str` or :obj:`None`: Message type.
 71
 72        Getter only.
 73        """
 74        return self._mtype
 75
 76    @property
 77    @abstractmethod
 78    def hwpid(self) -> int:
 79        """:obj:`int`: Hardware profile ID.
 80
 81        Getter only.
 82        """
 83        return self._hwpid
 84
 85    @property
 86    @abstractmethod
 87    def rcode(self) -> int:
 88        """:obj:`int`: DPA error code.
 89
 90        Getter only.
 91        """
 92        return self._rcode
 93
 94    @property
 95    @abstractmethod
 96    def dpa_value(self) -> int:
 97        """:obj:`int`: DPA value.
 98
 99        Getter only.
100        """
101        return self._dpa_value
102
103    @property
104    @abstractmethod
105    def pdata(self) -> Optional[List[int]]:
106        """:obj:`list` of :obj:`int`: DPA response data.
107
108        Getter only.
109        """
110        return self._pdata
111
112    @property
113    @abstractmethod
114    def result(self) -> Optional[dict]:
115        """:obj:`dict` or :obj:`None`: JSON API response data.
116
117        Getter only.
118        """
119        return self._result
120
121    @property
122    @abstractmethod
123    def msgid(self) -> Optional[str]:
124        """:obj:`str` or :obj:`None`: Message ID.
125
126        Getter only.
127        """
128        return self._msgid
129
130    @staticmethod
131    def validate_dpa_response(data: bytes) -> None:
132        """Validate DPA response for base response length.
133
134        Args:
135            data (bytes): DPA response.
136        """
137        DpaValidator.base_response_length(data)
138
139    @classmethod
140    @abstractmethod
141    def from_dpa(cls, dpa: bytes) -> 'IResponse':
142        """Factory method. Parse DPA response into Response object.
143
144        Args:
145            dpa (bytes): DPA response.
146        """
147
148    @classmethod
149    @abstractmethod
150    def from_json(cls, json: dict) -> 'IResponse':
151        """Factory method. Parse JSON response into Response object.
152
153        Args:
154            json (dict): JSON API response.
155        """

 20class AsyncResponse(IResponseGetterMixin):
 21    """Asynchronous response class.
 22
 23    This class is used to capture and resolve asynchronous responses,
 24    as this is a generic response class, the data is only sent as string of bytes in hexadecimal
 25    representation separated by dots.
 26    """
 27
 28    def __init__(self, nadr: int, pnum: Peripheral, pcmd: Command, hwpid: int = dpa_constants.HWPID_MAX,
 29                 rcode: int = 0x80, dpa_value: int = 0, pdata: Union[List[int], None] = None,
 30                 msgid: Optional[str] = None, result: Optional[dict] = None):
 31        """AsyncResponse constructor.
 32
 33        Args:
 34            nadr (int): Device address.
 35            pnum (Peripheral): Peripheral.
 36            pcmd (Command): Peripheral command.
 37            hwpid (int, optional): Hardware profile ID. Defaults to 65535, this value ignores HWPID check.
 38            rcode (int, optional): Response code. Defaults to 128.
 39            dpa_value (int, optional): DPA value. Defaults to 0.
 40            pdata (List[int], optional): DPA response data. Defaults to None.
 41            msgid (str, optional): Message ID. Defaults to None.
 42            result (dict, optional): JSON response data. Defaults to None.
 43        """
 44        super().__init__(
 45            nadr=nadr,
 46            pnum=pnum,
 47            pcmd=pcmd,
 48            m_type=GenericMessages.RAW,
 49            hwpid=hwpid,
 50            rcode=rcode,
 51            dpa_value=dpa_value,
 52            pdata=pdata,
 53            msgid=msgid,
 54            result=result
 55        )
 56
 57    @classmethod
 58    def from_dpa(cls, dpa: bytes) -> 'AsyncResponse':
 59        """Asynchronous response DPA factory method.
 60
 61        Parses DPA data and constructs :obj:`AsyncResponse` object.
 62
 63        Args:
 64            dpa (bytes): DPA response bytes.
 65
 66        Returns:
 67            :obj:`AsyncResponse`: Asynchronous response message object.
 68        """
 69        DpaValidator.base_response_length(dpa=dpa)
 70        nadr = dpa[ResponsePacketMembers.NADR]
 71        hwpid = Common.hwpid_from_dpa(dpa[ResponsePacketMembers.HWPID_HI], dpa[ResponsePacketMembers.HWPID_LO])
 72        pnum = Common.pnum_from_dpa(dpa[ResponsePacketMembers.PNUM])
 73        pcmd = Common.request_pcmd_from_dpa(pnum, dpa[ResponsePacketMembers.PCMD])
 74        rcode = dpa[ResponsePacketMembers.RCODE]
 75        dpa_value = dpa[ResponsePacketMembers.DPA_VALUE]
 76        result = None
 77        if rcode == ResponseCodes.ASYNC_RESPONSE:
 78            if len(dpa) > 8:
 79                result = {'rData': list(dpa)}
 80        return cls(nadr=nadr, pnum=pnum, pcmd=pcmd, hwpid=hwpid, rcode=rcode, dpa_value=dpa_value,
 81                   pdata=list(dpa), result=result)
 82
 83    @classmethod
 84    def from_json(cls, json: dict) -> 'AsyncResponse':
 85        """Asynchronous response JSON factory method.
 86
 87        Parses JSON API response and constructs :obj:`AsyncResponse` object.
 88
 89        Args:
 90            json (dict): JSON API response.
 91
 92        Returns:
 93            :obj:`AsyncResponse`: Asynchronous response message object.
 94        """
 95        msgid = Common.msgid_from_json(json)
 96        result = json['data']['rsp']
 97        packet = result['rData'].replace('.', '')
 98        pdata = bytes.fromhex(packet)
 99        ldata = Common.hex_string_to_list(packet)
100        nadr = ldata[ResponsePacketMembers.NADR]
101        hwpid = Common.hwpid_from_dpa(ldata[ResponsePacketMembers.HWPID_HI], ldata[ResponsePacketMembers.HWPID_LO])
102        pnum = Common.pnum_from_dpa(ldata[ResponsePacketMembers.PNUM])
103        pcmd = Common.request_pcmd_from_dpa(pnum, ldata[ResponsePacketMembers.PCMD])
104        rcode = ldata[ResponsePacketMembers.RCODE]
105        dpa_value = ldata[ResponsePacketMembers.DPA_VALUE]
106        return cls(nadr=nadr, pnum=pnum, pcmd=pcmd, hwpid=hwpid, rcode=rcode, dpa_value=dpa_value,
107                   pdata=list(pdata), msgid=msgid, result=result)

 18class Confirmation(IResponseGetterMixin):
 19    """Confirmation message class.
 20
 21    DPA confirmation is used to confirm reception of DPA request by node device at coordinator.
 22    The message carries DPA value, request hops (number of hops used to deliver DPA request to node device),
 23    response hops (number of hops used to deliver DPA response from node device to coordinator),
 24    and timeslot (see DPA documentation for timeslot length calculation).
 25    """
 26
 27    __slots__ = '_request_hops', '_response_hops', '_timeslot'
 28
 29    def __init__(self, nadr: int, pnum: Union[Peripheral, int], pcmd: Union[Command, int], hwpid: int, dpa_value: int,
 30                 rcode: int, pdata: Optional[List[int]] = None, result: Optional[dict] = None):
 31        """Confirmation constructor.
 32
 33        Args:
 34            nadr (int): Device address.
 35            pnum (Union[Peripheral, int]): Peripheral.
 36            pcmd (Union[Command, int]): Peripheral command.
 37            hwpid (int, optional): Hardware profile ID. Defaults to 65535, this value ignores HWPID check.
 38            rcode (int, optional): Response code. Defaults to 128.
 39            dpa_value (int, optional): DPA value. Defaults to 0.
 40            pdata (List[int], optional): DPA response data. Defaults to None.
 41            result (dict, optional): JSON response data. Defaults to None.
 42        """
 43        super().__init__(
 44            nadr=nadr,
 45            pcmd=pcmd,
 46            pnum=pnum,
 47            hwpid=hwpid,
 48            rcode=rcode,
 49            dpa_value=dpa_value,
 50            pdata=pdata,
 51            result=result
 52        )
 53        self._request_hops: int = result['requestHops']
 54        self._response_hops: int = result['responseHops']
 55        self._timeslot: int = result['timeslot']
 56
 57    @property
 58    def request_hops(self) -> int:
 59        """:obj:`int`: Request hops.
 60
 61        Getter only.
 62        """
 63        return self._request_hops
 64
 65    @property
 66    def response_hops(self) -> int:
 67        """:obj:`int`: Response hops.
 68
 69        Getter only.
 70        """
 71        return self._response_hops
 72
 73    @property
 74    def timeslot(self) -> int:
 75        """:obj:`int`: Timeslot.
 76
 77        Getter only.
 78        """
 79        return self._timeslot
 80
 81    @classmethod
 82    def from_dpa(cls, dpa: bytes) -> 'Confirmation':
 83        """Confirmation DPA factory method.
 84
 85        Parses DPA confirmation message and constructs :obj:`Confirmation` object.
 86
 87        Args:
 88            dpa (bytes): DPA confirmation bytes.
 89
 90        Returns:
 91            :obj:`Confirmation`: Confirmation message object.
 92        """
 93        DpaValidator.confirmation_length(dpa=dpa)
 94        DpaValidator.confirmation_code(dpa=dpa)
 95        nadr = dpa[ResponsePacketMembers.NADR]
 96        pnum = Common.pnum_from_dpa(dpa[ResponsePacketMembers.PNUM])
 97        pcmd = Common.request_pcmd_from_dpa(pnum, dpa[ResponsePacketMembers.PCMD])
 98        hwpid = Common.hwpid_from_dpa(dpa[ResponsePacketMembers.HWPID_HI], dpa[ResponsePacketMembers.HWPID_LO])
 99        rcode = dpa[ResponsePacketMembers.RCODE]
100        dpa_value = dpa[ResponsePacketMembers.DPA_VALUE]
101        pdata = list(dpa[8:])
102        result = {'requestHops': dpa[8], 'responseHops': dpa[10], 'timeslot': dpa[9]}
103        return cls(nadr=nadr, pnum=pnum, pcmd=pcmd, hwpid=hwpid, rcode=rcode, dpa_value=dpa_value,
104                   pdata=pdata, result=result)
105
106    @classmethod
107    def from_json(cls, json: dict) -> 'Confirmation':
108        """Confirmation JSON factory method.
109
110        This method is not implemented as JSON API does not support standalone Confirmation messages.
111
112        Raises:
113            NotImplementedError: This method is not implemented.
114        """
115        raise NotImplementedError('from_json() method not implemented.')