pycfdp 0.2.2__py3-none-any.whl

cfdp/pdu/ack.py

@@ -0,0 +1,90 @@
+from cfdp.checksum import finalize_pdu, strip_pdu_crc
+from cfdp.constants import DirectiveCode, PduTypeCode
+
+from .header import PduHeader
+
+
+class AckPdu:
+    def __init__(
+        self,
+        # pdu header parameters
+        direction=None,
+        transmission_mode=None,
+        crc_flag=0,
+        large_file_flag=0,
+        pdu_data_field_length=None,
+        segmentation_control=0,
+        length_of_entity_ids=0,
+        segmentation_metadata_flag=0,
+        length_of_seq_number=0,
+        source_entity_id=None,
+        transaction_seq_number=None,
+        destination_entity_id=None,
+        # ack pdu parameters
+        directive_code_ack=None,
+        directive_subtype_code=None,
+        condition_code=None,
+        transaction_status=None,
+    ):
+        self.directive_code = DirectiveCode.ACK
+        self.directive_code_ack = directive_code_ack
+        self.directive_subtype_code = directive_subtype_code
+        self.condition_code = condition_code
+        self.transaction_status = transaction_status
+
+        self.pdu_header = PduHeader(
+            pdu_type=PduTypeCode.FILE_DIRECTIVE,
+            direction=direction,
+            transmission_mode=transmission_mode,
+            crc_flag=crc_flag,
+            large_file_flag=large_file_flag,
+            pdu_data_field_length=pdu_data_field_length,
+            segmentation_control=segmentation_control,
+            length_of_entity_ids=length_of_entity_ids,
+            segmentation_metadata_flag=segmentation_metadata_flag,
+            length_of_seq_number=length_of_seq_number,
+            source_entity_id=source_entity_id,
+            transaction_seq_number=transaction_seq_number,
+            destination_entity_id=destination_entity_id,
+        )
+
+    def encode(self):
+        databytes = bytes(
+            [
+                self.directive_code,
+                (self.directive_code_ack << 4) + (self.directive_subtype_code),
+                (self.condition_code << 4) + (self.transaction_status),
+            ]
+        )
+
+        return finalize_pdu(self.pdu_header, databytes)
+
+    @classmethod
+    def decode(cls, pdu):
+        """ref: CCSDS 720.2-G-3 Page 2-10"""
+
+        pdu = strip_pdu_crc(pdu)
+        pdu_header = PduHeader.decode(pdu)
+        pdu_data = pdu[len(pdu_header) :]
+        pdu_data_field_length = len(pdu_data)
+
+        return cls(
+            # pdu header parameters
+            direction=pdu_header.direction,
+            transmission_mode=pdu_header.transmission_mode,
+            crc_flag=pdu_header.crc_flag,
+            large_file_flag=pdu_header.large_file_flag,
+            pdu_data_field_length=pdu_data_field_length,
+            segmentation_control=pdu_header.segmentation_control,
+            length_of_entity_ids=pdu_header.length_of_entity_ids,
+            segmentation_metadata_flag=pdu_header.segmentation_metadata_flag,
+            length_of_seq_number=pdu_header.length_of_seq_number,
+            source_entity_id=pdu_header.source_entity_id,
+            transaction_seq_number=pdu_header.transaction_seq_number,
+            destination_entity_id=pdu_header.destination_entity_id,
+            # ack pdu parameters
+            directive_code_ack=(pdu_data[1] >> 4),
+            directive_subtype_code=(pdu_data[1] & 0x0F),
+            condition_code=(pdu_data[2] >> 4),
+            transaction_status=(pdu_data[2] & 0x03),
+        )

cfdp/pdu/eof.py

@@ -0,0 +1,123 @@
+from cfdp.checksum import finalize_pdu, strip_pdu_crc
+from cfdp.constants import ConditionCode, DirectiveCode, PduTypeCode, TypeFieldCode
+
+from .header import PduHeader
+
+
+class EofPdu:
+    def __init__(
+        self,
+        # pdu header parameters
+        direction=None,
+        transmission_mode=None,
+        crc_flag=0,
+        large_file_flag=0,
+        pdu_data_field_length=None,
+        segmentation_control=0,
+        length_of_entity_ids=0,
+        segmentation_metadata_flag=0,
+        length_of_seq_number=0,
+        source_entity_id=None,
+        transaction_seq_number=None,
+        destination_entity_id=None,
+        # eof pdu parameters
+        condition_code=None,
+        file_checksum=None,
+        file_size=None,
+        fault_location=None,
+    ):
+        self.directive_code = DirectiveCode.EOF
+        self.condition_code = condition_code
+        self.file_checksum = file_checksum
+        self.file_size = file_size
+        self.fault_location = fault_location
+
+        if file_size is not None and file_size > 0xFFFFFFFF:
+            large_file_flag = 1
+
+        self.pdu_header = PduHeader(
+            pdu_type=PduTypeCode.FILE_DIRECTIVE,
+            direction=direction,
+            transmission_mode=transmission_mode,
+            crc_flag=crc_flag,
+            large_file_flag=large_file_flag,
+            pdu_data_field_length=pdu_data_field_length,
+            segmentation_control=segmentation_control,
+            length_of_entity_ids=length_of_entity_ids,
+            segmentation_metadata_flag=segmentation_metadata_flag,
+            length_of_seq_number=length_of_seq_number,
+            source_entity_id=source_entity_id,
+            transaction_seq_number=transaction_seq_number,
+            destination_entity_id=destination_entity_id,
+        )
+
+    def encode(self):
+        # Reference: CCSDS 727.0-B-5, 5.2.2, Table 5-6: End-of-File PDU Contents
+
+        databytes = bytes(
+            [
+                self.directive_code,
+                self.condition_code << 4,
+            ]
+        )
+
+        databytes += int(self.file_checksum).to_bytes(4, "big")
+
+        file_size_length = 8 if self.pdu_header.large_file_flag else 4
+        databytes += int(self.file_size).to_bytes(file_size_length, "big")
+
+        if self.condition_code != ConditionCode.NO_ERROR:
+            id_len = self.pdu_header.length_of_entity_ids + 1
+            databytes += bytes(
+                [
+                    TypeFieldCode.ENTITY_ID,
+                    id_len,
+                ]
+            )
+            # Not sure: is it correct to send our own entity ID here?
+            databytes += int(self.pdu_header.source_entity_id).to_bytes(id_len, "big")
+
+        return finalize_pdu(self.pdu_header, databytes)
+
+    @classmethod
+    def decode(cls, pdu):
+        pdu = strip_pdu_crc(pdu)
+        pdu_header = PduHeader.decode(pdu)
+        pdu_data = pdu[len(pdu_header) :]
+        pdu_data_field_length = len(pdu_data)
+
+        file_size_length = 8 if pdu_header.large_file_flag else 4
+        file_size = int.from_bytes(pdu_data[6 : 6 + file_size_length], "big")
+
+        # Parse optional fault_location TLV that follows the file_size field
+        # when condition_code != NO_ERROR (TypeFieldCode.ENTITY_ID = 0x06)
+        fault_location = None
+        tlv_offset = 6 + file_size_length
+        if tlv_offset + 2 <= len(pdu_data):
+            if pdu_data[tlv_offset] == TypeFieldCode.ENTITY_ID:
+                id_len = pdu_data[tlv_offset + 1]
+                if tlv_offset + 2 + id_len <= len(pdu_data):
+                    fault_location = int.from_bytes(
+                        pdu_data[tlv_offset + 2 : tlv_offset + 2 + id_len], "big"
+                    )
+
+        return cls(
+            # pdu header parameters
+            direction=pdu_header.direction,
+            transmission_mode=pdu_header.transmission_mode,
+            crc_flag=pdu_header.crc_flag,
+            large_file_flag=pdu_header.large_file_flag,
+            pdu_data_field_length=pdu_data_field_length,
+            segmentation_control=pdu_header.segmentation_control,
+            length_of_entity_ids=pdu_header.length_of_entity_ids,
+            segmentation_metadata_flag=pdu_header.segmentation_metadata_flag,
+            length_of_seq_number=pdu_header.length_of_seq_number,
+            source_entity_id=pdu_header.source_entity_id,
+            transaction_seq_number=pdu_header.transaction_seq_number,
+            destination_entity_id=pdu_header.destination_entity_id,
+            # eof pdu parameters
+            condition_code=pdu_data[1] >> 4,
+            file_checksum=int.from_bytes(pdu_data[2:6], "big"),
+            file_size=file_size,
+            fault_location=fault_location,
+        )

cfdp/pdu/filedata.py

@@ -0,0 +1,90 @@
+from cfdp.checksum import finalize_pdu, strip_pdu_crc
+from cfdp.constants import PduTypeCode
+
+from .header import PduHeader
+
+
+class FiledataPdu:
+    def __init__(
+        self,
+        # pdu header parameters
+        direction=None,
+        transmission_mode=None,
+        crc_flag=0,
+        large_file_flag=0,
+        pdu_data_field_length=None,
+        segmentation_control=0,
+        length_of_entity_ids=0,
+        segmentation_metadata_flag=0,
+        length_of_seq_number=0,
+        source_entity_id=None,
+        transaction_seq_number=None,
+        destination_entity_id=None,
+        # filedata pdu parameters
+        record_continuation_state=None,
+        segment_metadata_length=None,
+        segment_metadata=None,
+        segment_offset=None,
+        file_data=None,
+    ):
+        if None in [segment_offset, file_data]:
+            raise Exception("Must provide all required parameters")
+
+        self.segment_offset = segment_offset
+        self.file_data = file_data
+
+        self.pdu_header = PduHeader(
+            pdu_type=PduTypeCode.FILE_DATA,
+            direction=direction,
+            transmission_mode=transmission_mode,
+            crc_flag=crc_flag,
+            large_file_flag=large_file_flag,
+            pdu_data_field_length=pdu_data_field_length,
+            segmentation_control=segmentation_control,
+            length_of_entity_ids=length_of_entity_ids,
+            segmentation_metadata_flag=segmentation_metadata_flag,
+            length_of_seq_number=length_of_seq_number,
+            source_entity_id=source_entity_id,
+            transaction_seq_number=transaction_seq_number,
+            destination_entity_id=destination_entity_id,
+        )
+
+    def encode(self):
+        if self.pdu_header.segmentation_metadata_flag:
+            raise NotImplementedError
+        databytes = bytes(
+            [
+                (self.segment_offset >> 24) & 0xFF,
+                (self.segment_offset >> 16) & 0xFF,
+                (self.segment_offset >> 8) & 0xFF,
+                (self.segment_offset) & 0xFF,
+            ]
+        )
+        databytes += self.file_data
+        return finalize_pdu(self.pdu_header, databytes)
+
+    @classmethod
+    def decode(cls, pdu):
+        pdu = strip_pdu_crc(pdu)
+        pdu_header = PduHeader.decode(pdu)
+        pdu_data = pdu[len(pdu_header) :]
+        pdu_data_field_length = len(pdu_data)
+
+        return cls(
+            # pdu header parameters
+            direction=pdu_header.direction,
+            transmission_mode=pdu_header.transmission_mode,
+            crc_flag=pdu_header.crc_flag,
+            large_file_flag=pdu_header.large_file_flag,
+            pdu_data_field_length=pdu_data_field_length,
+            segmentation_control=pdu_header.segmentation_control,
+            length_of_entity_ids=pdu_header.length_of_entity_ids,
+            segmentation_metadata_flag=pdu_header.segmentation_metadata_flag,
+            length_of_seq_number=pdu_header.length_of_seq_number,
+            source_entity_id=pdu_header.source_entity_id,
+            transaction_seq_number=pdu_header.transaction_seq_number,
+            destination_entity_id=pdu_header.destination_entity_id,
+            # filedata pdu parameters
+            segment_offset=int.from_bytes(pdu_data[0:4], "big"),
+            file_data=pdu_data[4:],
+        )

cfdp/pdu/finished.py

@@ -0,0 +1,99 @@
+from cfdp.checksum import finalize_pdu, strip_pdu_crc
+from cfdp.constants import DirectiveCode, PduTypeCode
+
+from .header import PduHeader
+
+
+class FinishedPdu:
+    def __init__(
+        self,
+        # pdu header parameters
+        direction=None,
+        transmission_mode=None,
+        crc_flag=0,
+        large_file_flag=0,
+        pdu_data_field_length=None,
+        segmentation_control=0,
+        length_of_entity_ids=0,
+        segmentation_metadata_flag=0,
+        length_of_seq_number=0,
+        source_entity_id=None,
+        transaction_seq_number=None,
+        destination_entity_id=None,
+        # finished pdu parameters
+        condition_code=None,
+        delivery_code=None,
+        file_status=None,
+        filestore_responses=None,
+        fault_location=None,
+    ):
+        self.directive_code = DirectiveCode.FINISHED
+        self.condition_code = condition_code
+        self.delivery_code = delivery_code
+        self.file_status = file_status
+        self.filestore_responses = filestore_responses
+
+        self.pdu_header = PduHeader(
+            pdu_type=PduTypeCode.FILE_DIRECTIVE,
+            direction=direction,
+            transmission_mode=transmission_mode,
+            crc_flag=crc_flag,
+            large_file_flag=large_file_flag,
+            pdu_data_field_length=pdu_data_field_length,
+            segmentation_control=segmentation_control,
+            length_of_entity_ids=length_of_entity_ids,
+            segmentation_metadata_flag=segmentation_metadata_flag,
+            length_of_seq_number=length_of_seq_number,
+            source_entity_id=source_entity_id,
+            transaction_seq_number=transaction_seq_number,
+            destination_entity_id=destination_entity_id,
+        )
+
+    def encode(self):
+        databytes = bytes(
+            [
+                (self.directive_code),
+                (self.condition_code << 4)
+                + (1 << 3)
+                + (self.delivery_code << 2)  # end system status must be 1
+                + (self.file_status),
+            ]
+        )
+
+        if self.filestore_responses:
+            for filestore_responses in self.filestore_responses:
+                databytes += filestore_responses.encode()
+            raise NotImplementedError
+
+        return finalize_pdu(self.pdu_header, databytes)
+
+    @classmethod
+    def decode(cls, pdu):
+        """ref: CCSDS 720.2-G-3 Page 2-9"""
+
+        pdu = strip_pdu_crc(pdu)
+        pdu_header = PduHeader.decode(pdu)
+        pdu_data = pdu[len(pdu_header) :]
+        pdu_data_field_length = len(pdu_data)
+
+        return cls(
+            # pdu header parameters
+            direction=pdu_header.direction,
+            transmission_mode=pdu_header.transmission_mode,
+            crc_flag=pdu_header.crc_flag,
+            large_file_flag=pdu_header.large_file_flag,
+            pdu_data_field_length=pdu_data_field_length,
+            segmentation_control=pdu_header.segmentation_control,
+            length_of_entity_ids=pdu_header.length_of_entity_ids,
+            segmentation_metadata_flag=pdu_header.segmentation_metadata_flag,
+            length_of_seq_number=pdu_header.length_of_seq_number,
+            source_entity_id=pdu_header.source_entity_id,
+            transaction_seq_number=pdu_header.transaction_seq_number,
+            destination_entity_id=pdu_header.destination_entity_id,
+            # finished pdu parameters
+            condition_code=pdu_data[1] >> 4,
+            delivery_code=(pdu_data[1] >> 2) & 0x01,
+            file_status=pdu_data[1] & 0x03,
+            filestore_responses=0,  # TODO
+            fault_location=None,
+        )

cfdp/pdu/header.py

@@ -0,0 +1,159 @@
+from typing import TYPE_CHECKING
+
+from cfdp.meta import get_required_octets
+
+if TYPE_CHECKING:
+    from cfdp.pure.transaction import TransactionId
+
+CFDP_PROTOCOL_VERSION = 1
+
+
+class PduHeader:
+    def __init__(
+        self,
+        pdu_type=None,
+        direction=None,
+        transmission_mode=None,
+        crc_flag=0,
+        large_file_flag=0,
+        pdu_data_field_length=None,
+        segmentation_control=0,
+        length_of_entity_ids=0,
+        segmentation_metadata_flag=0,
+        length_of_seq_number=0,
+        source_entity_id=None,
+        transaction_seq_number=None,
+        destination_entity_id=None,
+    ):
+        if None in [
+            pdu_type,
+            direction,
+            transmission_mode,
+            source_entity_id,
+            transaction_seq_number,
+            destination_entity_id,
+        ]:
+            raise Exception("Must provide all required parameters")
+
+        self.version = CFDP_PROTOCOL_VERSION
+        self.pdu_type = pdu_type
+        self.direction = direction
+        self.transmission_mode = transmission_mode
+        self.crc_flag = crc_flag
+        self.large_file_flag = large_file_flag
+        self.pdu_data_field_length = pdu_data_field_length
+        self.segmentation_control = segmentation_control
+        self.length_of_entity_ids = length_of_entity_ids
+        self.segmentation_metadata_flag = segmentation_metadata_flag
+        self.length_of_seq_number = length_of_seq_number
+        self.source_entity_id = source_entity_id
+        self.transaction_seq_number = transaction_seq_number
+        self.destination_entity_id = destination_entity_id
+
+    @property
+    def transaction_id(self) -> "TransactionId":
+        """The owning transaction id: ``(source_entity_id, seq_number)``.
+
+        Collapses the repeated two-field reach used to key the machine map, so
+        callers write ``pdu.pdu_header.transaction_id`` instead of rebuilding
+        ``(h.source_entity_id, h.transaction_seq_number)`` at each site.
+        """
+        return (self.source_entity_id, self.transaction_seq_number)
+
+    def encode(self):
+        if self.pdu_data_field_length is None:
+            raise ValueError("PDU data field length not defined")
+
+        self.length_of_entity_ids = max(
+            get_required_octets(self.source_entity_id) - 1,
+            get_required_octets(self.destination_entity_id) - 1,
+        )
+
+        databytes = bytes(
+            [
+                (self.version << 5)
+                + (self.pdu_type << 4)
+                + (self.direction << 3)
+                + (self.transmission_mode << 2)
+                + (self.crc_flag << 1)
+                + (self.large_file_flag),
+                (self.pdu_data_field_length >> 8),
+                (self.pdu_data_field_length & 0xFF),
+                (self.segmentation_control << 7)
+                + (self.length_of_entity_ids << 4)
+                + (self.segmentation_metadata_flag << 3)
+                + self.length_of_seq_number,
+            ]
+        )
+
+        x = []
+        for i in range(self.length_of_entity_ids + 1):
+            x.append((self.source_entity_id >> (8 * i)) & 0xFF)
+        x.reverse()
+        databytes += bytes(x)
+
+        x = []
+        for i in range(self.length_of_seq_number + 1):
+            x.append((self.transaction_seq_number >> (8 * i)) & 0xFF)
+        x.reverse()
+        databytes += bytes(x)
+
+        x = []
+        for i in range(self.length_of_entity_ids + 1):
+            x.append((self.destination_entity_id >> (8 * i)) & 0xFF)
+        x.reverse()
+        databytes += bytes(x)
+
+        return databytes
+
+    def __len__(self):
+        entity_id_field_length = 2 * (self.length_of_entity_ids + 1)
+        transaction_seq_number_field_length = self.length_of_seq_number + 1
+        return 4 + entity_id_field_length + transaction_seq_number_field_length
+
+    @classmethod
+    def decode(cls, pdu):
+        pdu_data_field_length = int.from_bytes(pdu[1:3], "big")
+        length_of_entity_ids = (pdu[3] >> 4) & 0x07
+        length_of_seq_number = pdu[3] & 0x07
+
+        fixed_pdu_end = (
+            32 + (2 * (8 + 8 * length_of_entity_ids)) + (8 + 8 * length_of_seq_number)
+        )
+        source_entity_id = int.from_bytes(
+            pdu[4 : (32 + (8 + 8 * length_of_entity_ids)) // 8], "big"
+        )
+        transaction_seq_number = int.from_bytes(
+            pdu[
+                (32 + (8 + 8 * length_of_entity_ids)) // 8 : (
+                    32 + (8 + 8 * length_of_entity_ids) + (8 + 8 * length_of_seq_number)
+                )
+                // 8
+            ],
+            "big",
+        )
+        destination_entity_id = int.from_bytes(
+            pdu[
+                (32 + (8 + 8 * length_of_entity_ids) + (8 + 8 * length_of_seq_number))
+                // 8 : fixed_pdu_end // 8
+            ],
+            "big",
+        )
+
+        crc_flag = (pdu[0] >> 1) & 0x01
+
+        return cls(
+            pdu_type=(pdu[0] >> 4) & 0x01,
+            direction=(pdu[0] >> 3) & 0x01,
+            transmission_mode=(pdu[0] >> 2) & 0x01,
+            crc_flag=crc_flag,
+            large_file_flag=pdu[0] & 0x01,
+            pdu_data_field_length=pdu_data_field_length,
+            segmentation_control=(pdu[3] >> 7) & 0x01,
+            length_of_entity_ids=length_of_entity_ids,
+            segmentation_metadata_flag=(pdu[3] >> 3) & 0x01,
+            length_of_seq_number=length_of_seq_number,
+            source_entity_id=source_entity_id,
+            transaction_seq_number=transaction_seq_number,
+            destination_entity_id=destination_entity_id,
+        )

cfdp/pdu/keep_alive.py

@@ -0,0 +1,108 @@
+from cfdp.checksum import finalize_pdu, strip_pdu_crc
+from cfdp.constants import DirectiveCode, PduTypeCode
+
+from .header import PduHeader
+
+
+class KeepAlivePdu:
+    def __init__(
+        self,
+        # pdu header parameters
+        direction=None,
+        transmission_mode=None,
+        crc_flag=0,
+        large_file_flag=0,
+        pdu_data_field_length=None,
+        segmentation_control=0,
+        length_of_entity_ids=0,
+        segmentation_metadata_flag=0,
+        length_of_seq_number=0,
+        source_entity_id=None,
+        transaction_seq_number=None,
+        destination_entity_id=None,
+        # keep alive pdu parameters
+        progress=None,
+    ):
+        self.directive_code = DirectiveCode.KEEP_ALIVE
+        self.progress = progress
+
+        if progress is not None and progress > 0xFFFFFFFF:
+            large_file_flag = 1
+
+        self.pdu_header = PduHeader(
+            pdu_type=PduTypeCode.FILE_DIRECTIVE,
+            direction=direction,
+            transmission_mode=transmission_mode,
+            crc_flag=crc_flag,
+            large_file_flag=large_file_flag,
+            pdu_data_field_length=pdu_data_field_length,
+            segmentation_control=segmentation_control,
+            length_of_entity_ids=length_of_entity_ids,
+            segmentation_metadata_flag=segmentation_metadata_flag,
+            length_of_seq_number=length_of_seq_number,
+            source_entity_id=source_entity_id,
+            transaction_seq_number=transaction_seq_number,
+            destination_entity_id=destination_entity_id,
+        )
+
+    def encode(self):
+        databytes = bytes([self.directive_code])
+
+        if not self.pdu_header.large_file_flag:
+            databytes += bytes(
+                [
+                    (self.progress >> 24) & 0xFF,
+                    (self.progress >> 16) & 0xFF,
+                    (self.progress >> 8) & 0xFF,
+                    (self.progress) & 0xFF,
+                ]
+            )
+
+        else:
+            databytes += bytes(
+                [
+                    (self.progress >> 56) & 0xFF,
+                    (self.progress >> 48) & 0xFF,
+                    (self.progress >> 40) & 0xFF,
+                    (self.progress >> 32) & 0xFF,
+                    (self.progress >> 24) & 0xFF,
+                    (self.progress >> 16) & 0xFF,
+                    (self.progress >> 8) & 0xFF,
+                    (self.progress) & 0xFF,
+                ]
+            )
+
+        return finalize_pdu(self.pdu_header, databytes)
+
+    @classmethod
+    def decode(cls, pdu):
+        """ref: CCSDS 720.2-G-3 Page 2-12"""
+
+        pdu = strip_pdu_crc(pdu)
+        pdu_header = PduHeader.decode(pdu)
+        pdu_data = pdu[len(pdu_header) :]
+        pdu_data_field_length = len(pdu_data)
+
+        progress = (
+            int.from_bytes(pdu_data[1:5], "big")
+            if not pdu_header.large_file_flag
+            else int.from_bytes(pdu_data[1:9], "big")
+        )
+
+        return cls(
+            # pdu header parameters
+            direction=pdu_header.direction,
+            transmission_mode=pdu_header.transmission_mode,
+            crc_flag=pdu_header.crc_flag,
+            large_file_flag=pdu_header.large_file_flag,
+            pdu_data_field_length=pdu_data_field_length,
+            segmentation_control=pdu_header.segmentation_control,
+            length_of_entity_ids=pdu_header.length_of_entity_ids,
+            segmentation_metadata_flag=pdu_header.segmentation_metadata_flag,
+            length_of_seq_number=pdu_header.length_of_seq_number,
+            source_entity_id=pdu_header.source_entity_id,
+            transaction_seq_number=pdu_header.transaction_seq_number,
+            destination_entity_id=pdu_header.destination_entity_id,
+            # keep alive pdu parameters
+            progress=progress,
+        )