fprime-gds 4.0.0a1__py3-none-any.whl → 4.0.0a3__py3-none-any.whl

fprime_gds/common/communication/adapters/uart.py

@@ -59,7 +59,7 @@ class SerialAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
         4000000,
     ]
 
-    def __init__(self, device, baud):
+    def __init__(self, device, baud, skip_check):
         """
         Initialize the serial adapter using the default settings. This does not open the serial port, but sets up all
         the internal variables used when opening the device.
@@ -77,9 +77,14 @@ class SerialAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
         Opens the serial port based on previously supplied settings. If the port is already open, then close it first.
         Then open the port up again.
         """
-        self.close()
-        self.serial = serial.Serial(self.device, self.baud)
-        return self.serial is not None
+        try:
+            self.close()
+            self.serial = serial.Serial(self.device, self.baud)
+            return self.serial is not None
+        except serial.serialutil.SerialException as exc:
+            LOGGER.warning("Serial exception caught: %s. Reconnecting.", (str(exc)))
+            self.close()
+            return False
 
     def close(self):
         """
@@ -100,12 +105,11 @@ class SerialAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
         :return: True, when data was sent through the UART. False otherwise.
         """
         try:
-            if self.serial is None:
-                self.open()
-            written = self.serial.write(frame)
-            # Not believed to be possible to not send everything without getting a timeout exception
-            assert written == len(frame)
-            return True
+            if self.serial is not None or self.open():
+                written = self.serial.write(frame)
+                # Not believed to be possible to not send everything without getting a timeout exception
+                assert written == len(frame)
+                return True
         except serial.serialutil.SerialException as exc:
             LOGGER.warning("Serial exception caught: %s. Reconnecting.", (str(exc)))
             self.close()
@@ -121,17 +125,16 @@ class SerialAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
         """
         data = b""
         try:
-            if self.serial is None:
-                self.open()
-            # Read as much data as possible, while ensuring to block if no data is available at this time. Note: as much
-            # data is read as possible to avoid a long-return time to this call. Minimum data to read is one byte in
-            # order to block this function while data is incoming.
-            self.serial.timeout = timeout
-            data = self.serial.read(1)  # Force a block for at least 1 character
-            while self.serial.in_waiting:
-                data += self.serial.read(
-                    self.serial.in_waiting
-                )  # Drain the incoming data queue
+            if self.serial is not None or self.open():                
+                # Read as much data as possible, while ensuring to block if no data is available at this time. Note: as much
+                # data is read as possible to avoid a long-return time to this call. Minimum data to read is one byte in
+                # order to block this function while data is incoming.
+                self.serial.timeout = timeout
+                data = self.serial.read(1)  # Force a block for at least 1 character
+                while self.serial.in_waiting:
+                    data += self.serial.read(
+                        self.serial.in_waiting
+                    )  # Drain the incoming data queue
         except serial.serialutil.SerialException as exc:
             LOGGER.warning("Serial exception caught: %s. Reconnecting.", (str(exc)))
             self.close()
@@ -161,6 +164,12 @@ class SerialAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
                 "default": 9600,
                 "help": "Baud rate of the serial device.",
             },
+            ("--uart-skip-port-check",): {
+                "dest": "skip_check",
+                "default": False,
+                "action": "store_true",
+                "help": "Skip checking that the port exists"
+            }
         }
 
     @classmethod
@@ -175,20 +184,20 @@ class SerialAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
         return cls
 
     @classmethod
-    def check_arguments(cls, device, baud):
+    def check_arguments(cls, device, baud, skip_check):
         """
         Code that should check arguments of this adapter. If there is a problem with this code, then a "ValueError"
         should be raised describing the problem with these arguments.
 
         :param args: arguments as dictionary
         """
-        ports = map(lambda info: info.device, list_ports.comports(include_links=True))
-        if device not in ports:
+        ports = list(map(lambda info: info.device, list_ports.comports(include_links=True)))
+        if not skip_check and device not in ports:
             msg = f"Serial port '{device}' not valid. Available ports: {ports}"
             raise ValueError(
                 msg
             )
-        # Note: baud rate may not *always* work. These are a superset
+        # Note: baud rate may not *always* work. These are a superset.
         try:
             baud = int(baud)
         except ValueError:

fprime_gds/common/communication/ccsds/apid.py

@@ -0,0 +1,19 @@
+""" ccsds.apid: APID mapping functions for F´ data """
+from fprime_gds.common.utils.data_desc_type import DataDescType
+from fprime.common.models.serialize.numerical_types import U32Type
+
+class APID(object):
+    """ APID implementations """
+    #TODO: use the DataDescType configured by loading the dictionary
+
+    @classmethod
+    def from_type(cls, data_type: DataDescType):
+        """ Map from data description type to APID """
+        return data_type.value
+
+    @classmethod
+    def from_data(cls, data):
+        """ Map from data bytes to APID """
+        u32_type = U32Type()
+        u32_type.deserialize(data, offset=0)
+        return cls.from_type(DataDescType(u32_type.val))

fprime_gds/common/communication/ccsds/chain.py

@@ -0,0 +1,106 @@
+""" fprime_encryption.framing.chain: implementation of a chained framer/deframer """
+from abc import ABC, abstractmethod
+from functools import reduce
+from typing import Any, Dict, List, Type
+from fprime_gds.common.communication.framing import FramerDeframer
+from fprime_gds.common.communication.ccsds.space_data_link import SpaceDataLinkFramerDeframer
+from fprime_gds.common.communication.ccsds.space_packet import SpacePacketFramerDeframer
+from fprime_gds.plugin.definitions import gds_plugin
+
+
+
+class ChainedFramerDeframer(FramerDeframer, ABC):
+    """ Framer/deframer that is a composite of chained framer/deframers
+
+    This Framer/Deframer will wrap a set of framer/deframers where the result of the frame and deframe options will pass
+    from one to the other subsequently. The order is specified via the framing path and deframing will use the reverse
+    order from specified.
+    """
+    def __init__(self, **kwargs):
+        """ Initialize the chained framer/deframer from a framing-ordered set of children """
+        frame_order_framer_deframers = [
+            composite(**self.get_argument_subset(composite, kwargs))
+            for composite in self.get_composites()
+        ]
+        self.framers = frame_order_framer_deframers[::1]
+        self.deframers = frame_order_framer_deframers[::-1]
+
+    @classmethod
+    @abstractmethod
+    def get_composites(cls) -> List[Type[FramerDeframer]]:
+        """ Return a list of composites 
+        Innermost FramerDeframer should be first in the list. """
+        raise NotImplementedError(f"Subclasses of {cls.__name__} must implement get_composites")
+
+    @staticmethod
+    def get_argument_subset(composite: Type[FramerDeframer], argument_dictionary: Dict[str, Any]) -> Dict[str, Any]:
+        """ Get an argument subset that is needed by composite
+
+        For the composite, find the set of arguments that is needed by this composite and pull those out of the complete
+        argument dictionary.
+
+        Args:
+            composite: class of a subtype of FramerDeframer
+            argument_dictionary: dictionary of all input arguments
+        """
+        if not hasattr(composite, "get_arguments"):
+            return {}
+        needed_arguments = composite.get_arguments()
+        needed_argument_destinations = [
+            description["destination"] if "destination" in description else
+                [dash_dash for dash_dash in flag if dash_dash.startswith("--")][0].lstrip("-").replace("-", "_")
+            for flag, description in needed_arguments.items()
+        ]
+        return {name: argument_dictionary[name] for name in needed_argument_destinations}
+
+    @classmethod
+    def get_arguments(cls):
+        """ Arguments to request from the CLI """
+        all_arguments = {}
+        for composite in cls.get_composites():
+            all_arguments.update(composite.get_arguments() if hasattr(composite, "get_arguments") else {})
+        return all_arguments
+
+    @classmethod
+    def check_arguments(cls, **kwargs):
+        """ Check arguments from the CLI """
+        for composite in cls.get_composites():
+            subset_arguments = cls.get_argument_subset(composite, kwargs)
+            if hasattr(composite, "check_arguments"):
+                composite.check_arguments(**subset_arguments)
+
+    def deframe(self, data, no_copy=False):
+        """ Deframe via a chain of children deframers """
+        packet = data[:] if not no_copy else data
+        remaining = None
+        discarded = b""
+
+        for deframer in self.deframers:
+            new_packet, new_remaining, new_discarded = deframer.deframe(packet, True)
+            discarded += new_discarded
+            remaining = new_remaining if remaining is None else remaining
+            packet = new_packet
+        return packet, remaining, discarded
+
+    def frame(self, data):
+        """ Frame via a chain of children framers """
+        return reduce(lambda framed_data, framer: framer.frame(framed_data), self.framers, data)
+
+
+@gds_plugin(FramerDeframer)
+class SpacePacketSpaceDataLinkFramerDeframer(ChainedFramerDeframer):
+    """ Space Data Link Protocol framing and deframing that has a data unit of Space Packets as the central """
+
+    @classmethod
+    def get_composites(cls) -> List[Type[FramerDeframer]]:
+        """ Return the composite list of this chain 
+        Innermost FramerDeframer should be first in the list. """
+        return [
+            SpacePacketFramerDeframer,
+            SpaceDataLinkFramerDeframer
+        ]
+
+    @classmethod
+    def get_name(cls):
+        """ Name of this implementation provided to CLI """
+        return "space-packet-space-data-link"

fprime_gds/common/communication/ccsds/space_data_link.py

@@ -0,0 +1,196 @@
+"""F Prime Framer/Deframer Implementation of the CCSDS Space Data Link (TC/TM) Protocols"""
+import sys
+import struct
+import copy
+
+from fprime_gds.common.communication.framing import FramerDeframer
+from fprime_gds.plugin.definitions import gds_plugin_implementation
+
+import crc
+
+
+class SpaceDataLinkFramerDeframer(FramerDeframer):
+    """CCSDS Framer/Deframer Implementation for the TC (uplink / framing) and TM (downlink / deframing)
+    protocols. This FramerDeframer is used for framing TC data for uplink and deframing TM data for downlink.
+    """
+
+    SEQUENCE_NUMBER_MAXIMUM = 256
+    TC_HEADER_SIZE = 5
+    TM_HEADER_SIZE = 6
+    TM_FIXED_FRAME_SIZE = 1024
+    TM_TRAILER_SIZE = 2
+    TC_TRAILER_SIZE = 2
+
+    # As per CCSDS standard, use CRC-16 CCITT config with init value
+    # all 1s and final XOR value of 0x0000
+    CRC_CCITT_CONFIG = crc.Configuration(
+        width=16,
+        polynomial=0x1021,
+        init_value=0xFFFF,
+        final_xor_value=0x0000,
+    )
+    CRC_CALCULATOR = crc.Calculator(CRC_CCITT_CONFIG)
+
+    def __init__(self, scid, vcid):
+        """ """
+        self.scid = scid
+        self.vcid = vcid
+        self.sequence_number = 0
+
+    def frame(self, data):
+        """Frame the supplied data in a TC frame"""
+        space_packet_bytes = data
+        # CCSDS TC protocol defines the length token as number of bytes in full frame, minus 1
+        # so we add to packet size the size of the header and trailer and subtract 1
+        length = (
+            len(space_packet_bytes) + self.TC_HEADER_SIZE + self.TC_TRAILER_SIZE - 1
+        )
+        assert length < (pow(2, 10) - 1), "Length too-large for CCSDS format"
+
+        # CCSDS TC Header:
+        #  2b -  00 - TF version number
+        #  1b - 0/1 - 0 enable FARM checks, 1 bypass FARM
+        #  1b - 0/1 - 0 = data (Type-D), 1 = control information (Type-C)
+        #  2b -  00 - Reserved
+        # 10b -  XX - Spacecraft id
+        #  6b -  XX - Virtual Channel ID
+        # 10b -  XX - Frame length
+        #  8b -  XX - Frame sequence number
+
+        # First 16 bits:
+        header_val1_u16 = (
+            (0 << 14) |  # TF version number (2 bits)
+            (1 << 13) |  # Bypass FARM (1 bit)
+            (0 << 12) |  # Type-D (1 bit)
+            (0 << 10) |  # Reserved (2 bits)
+            ((self.scid & 0x3FF))  # SCID (10 bits)
+        )
+        # Second 16 bits:
+        header_val2_u16 = (
+            ((self.vcid & 0x3F) << 10) |  # VCID (6 bits)
+            (length & 0x3FF)              # Frame length (10 bits)
+        )
+        # 8 bit sequence number - always 0 in bypass FARM mode
+        header_val3_u8 = 0
+        header_bytes = struct.pack(">HHB", header_val1_u16, header_val2_u16, header_val3_u8)
+        full_bytes_no_crc = header_bytes + space_packet_bytes
+        assert (
+            len(header_bytes) == self.TC_HEADER_SIZE
+        ), "CCSDS primary header must be 5 octets long"
+        assert len(full_bytes_no_crc) == self.TC_HEADER_SIZE + len(
+            data
+        ), "Malformed packet generated"
+
+        full_bytes = full_bytes_no_crc + struct.pack(
+            ">H", self.CRC_CALCULATOR.checksum(full_bytes_no_crc)
+        )
+        return full_bytes
+
+    def get_sequence_number(self):
+        """Get the sequence number and increment - used for TM deframing
+
+        This function will return the current sequence number and then increment the sequence number for the next round.
+
+        Return:
+            current sequence number
+        """
+        sequence = self.sequence_number
+        self.sequence_number = (self.sequence_number + 1) % self.SEQUENCE_NUMBER_MAXIMUM
+        return sequence
+
+    def deframe(self, data, no_copy=False):
+        """Deframe TM frames"""
+        discarded = b""
+        if not no_copy:
+            data = copy.copy(data)
+        # Continue until there is not enough data for the header, or until a packet is found (return)
+        while len(data) >= self.TM_FIXED_FRAME_SIZE:
+            # Read header information
+            sc_and_channel_ids = struct.unpack_from(">H", data)
+            spacecraft_id = (sc_and_channel_ids[0] & 0x3FF0) >> 4
+            virtual_channel_id = (sc_and_channel_ids[0] & 0x000E) >> 1
+            # Check if the header is correct with regards to expected spacecraft and VC IDs
+            if spacecraft_id != self.scid or virtual_channel_id != self.vcid:
+                # If the header is invalid, rotate away a Byte and keep processing
+                discarded += data[0:1]
+                data = data[1:]
+                continue
+            # Spacecraft ID and Virtual Channel ID match, so we look at end of frame for CRC
+            crc_offset = self.TM_FIXED_FRAME_SIZE - self.TM_TRAILER_SIZE
+            transmitted_crc = struct.unpack_from(">H", data, crc_offset)[0]
+            if transmitted_crc == self.CRC_CALCULATOR.checksum(data[:crc_offset]):
+                # CRC is valid, so we return the deframed data
+                deframed_data_len = (
+                    self.TM_FIXED_FRAME_SIZE
+                    - self.TM_TRAILER_SIZE
+                    - self.TM_HEADER_SIZE
+                )
+                deframed = struct.unpack_from(
+                    f">{deframed_data_len}s", data, self.TM_HEADER_SIZE
+                )[0]
+                # Consume the fixed size frame
+                data = data[self.TM_FIXED_FRAME_SIZE :]
+                return deframed, data, discarded
+
+            print(
+                "[WARNING] Checksum validation failed.",
+                file=sys.stderr,
+            )
+            # Bad checksum, rotate 1 and keep looking for non-garbage
+            discarded += data[0:1]
+            data = data[1:]
+            continue
+        return None, data, discarded
+
+    @classmethod
+    def get_arguments(cls):
+        """Arguments to request from the CLI"""
+        return {
+            ("--scid",): {
+                "type": lambda input_arg: int(input_arg, 0),
+                "help": "Spacecraft ID",
+                "default": 0x44,
+                "required": False,
+            },
+            ("--vcid",): {
+                "type": lambda input_arg: int(input_arg, 0),
+                "help": "Virtual channel ID",
+                "default": 1,
+                "required": False,
+            },
+        }
+
+    @classmethod
+    def check_arguments(cls, scid, vcid):
+        """Check arguments from the CLI
+
+        Confirms that the input arguments are valid for this framer/deframer.
+
+        Args:
+            scid: spacecraft id
+            vcid: virtual channel id
+        """
+        if scid is None:
+            raise TypeError(f"Spacecraft ID not specified")
+        if scid < 0:
+            raise TypeError(f"Spacecraft ID {scid} is negative")
+        if scid > 0x3FF:
+            raise TypeError(f"Spacecraft ID {scid} is larger than {0x3FF}")
+
+        if vcid is None:
+            raise TypeError(f"Virtual Channel ID not specified")
+        if vcid < 0:
+            raise TypeError(f"Virtual Channel ID {vcid} is negative")
+        if vcid > 0x3F:
+            raise TypeError(f"Virtual Channel ID {vcid} is larger than {0x3FF}")
+
+    @classmethod
+    def get_name(cls):
+        """Name of this implementation provided to CLI"""
+        return "raw-space-data-link"
+
+    @classmethod
+    @gds_plugin_implementation
+    def register_framing_plugin(cls):
+        """Register the MyPlugin plugin"""
+        return cls

fprime_gds/common/communication/ccsds/space_packet.py

@@ -0,0 +1,130 @@
+"""F Prime Framer/Deframer Implementation of the CCSDS Space Packet Protocol"""
+
+from __future__ import annotations
+
+import struct
+import copy
+
+from spacepackets.ccsds.spacepacket import SpacePacketHeader, PacketType, SpacePacket
+
+from fprime_gds.common.communication.framing import FramerDeframer
+from fprime_gds.plugin.definitions import gds_plugin_implementation, gds_plugin
+from fprime_gds.common.utils.data_desc_type import DataDescType
+
+from .apid import APID
+import logging
+
+LOGGER = logging.getLogger("framing")
+LOGGER.setLevel(logging.DEBUG)
+
+
+@gds_plugin(FramerDeframer)
+class SpacePacketFramerDeframer(FramerDeframer):
+    """Concrete implementation of FramerDeframer supporting SpacePacket protocol
+
+    This implementation is registered as a "framing" plugin to support encryption within the GDS layer.
+    """
+
+    SEQUENCE_COUNT_MAXIMUM = 16384  # 2^14
+    HEADER_SIZE = 6
+    IDLE_APID = 0x7FF  # max 11 bit value per protocol specification
+
+    def __init__(self):
+        # self.sequence_number = 0
+        # Map APID to sequence counts
+        self.apid_to_sequence_count_map = dict()
+        for key in DataDescType:
+            self.apid_to_sequence_count_map[key.value] = 0
+
+    def frame(self, data):
+        """Frame the supplied data in Space Packet"""
+        # The protocol defines length token to be number of bytes minus 1
+        data_length_token = len(data) - 1
+        apid = APID.from_data(data)
+        space_header = SpacePacketHeader(
+            packet_type=PacketType.TC,
+            apid=apid,
+            seq_count=self.get_sequence_count(apid),
+            data_len=data_length_token,
+        )
+        space_packet = SpacePacket(space_header, sec_header=None, user_data=data)
+        return space_packet.pack()
+
+    def deframe(self, data, no_copy=False):
+        """Deframe the supplied data according to Space Packet protocol"""
+        discarded = b""
+        if data is None:
+            return None, None, discarded
+        if not no_copy:
+            data = copy.copy(data)
+        # Deframe all packets until there is not enough data for a header
+        while len(data) >= self.HEADER_SIZE:
+            # Read header information including start token and size and check if we have enough for the total size
+            try:
+                sp_header = SpacePacketHeader.unpack(data)
+            except ValueError:
+                # If the header is invalid, rotate away a byte and keep processing
+                discarded += data[0:1]
+                data = data[1:]
+                continue
+            if sp_header.ccsds_version != 0 or sp_header.packet_type != PacketType.TM:
+                # Space Packet version is specified as 0 per protocol
+                discarded += data[0:1]
+                data = data[1:]
+                continue
+            # Skip Idle Packets as they are not meaningful
+            if sp_header.apid == self.IDLE_APID:
+                data = data[sp_header.packet_len :]
+                continue
+            # Check sequence count and warn if not expected value (don't drop the packet)
+            if sp_header.seq_count != self.get_sequence_count(sp_header.apid):
+                LOGGER.warning(
+                    f"APID {sp_header.apid} received sequence count: {sp_header.seq_count}"
+                    f" (expected: {self.get_sequence_count(sp_header.apid)})"
+                )
+                # Set the sequence count to the next expected value (consider missing packets have been lost)
+                self.apid_to_sequence_count_map[sp_header.apid] = (
+                    sp_header.seq_count + 1
+                )
+            # If the pool is large enough to read the whole packet, then read it
+            if len(data) >= sp_header.packet_len:
+                deframed = struct.unpack_from(
+                    # data_len is number of bytes minus 1 per SpacePacket spec
+                    f">{sp_header.data_len + 1}s",
+                    data,
+                    self.HEADER_SIZE,
+                )[0]
+                data = data[sp_header.packet_len :]
+                LOGGER.debug(f"Deframed packet: {sp_header}")
+                return deframed, data, discarded
+            else:
+                # If we don't have enough data, then break out of the loop
+                break
+        return None, data, discarded
+
+    def get_sequence_count(self, apid: int):
+        """Get the sequence number and increment
+
+        This function will return the current sequence number and then increment the sequence number for the next round.
+        Should an APID not be registered already, it will be initialized to 0.
+
+        Return:
+            current sequence number
+        """
+        # If APID is not registered, initialize it to 0
+        sequence = self.apid_to_sequence_count_map.get(apid, 0)
+        self.apid_to_sequence_count_map[apid] = (
+            sequence + 1
+        ) % self.SEQUENCE_COUNT_MAXIMUM
+        return sequence
+
+    @classmethod
+    def get_name(cls):
+        """Name of this implementation provided to CLI"""
+        return "raw-space-packet"
+
+    @classmethod
+    @gds_plugin_implementation
+    def register_framing_plugin(cls):
+        """Register the MyPlugin plugin"""
+        return cls

fprime_gds/common/communication/framing.py

@@ -11,6 +11,8 @@ that implement this pattern. The current list of implementation classes are:
 
 @author lestarch
 """
+
+from __future__ import annotations
 import abc
 import copy
 import struct
@@ -18,7 +20,10 @@ import sys
 from typing import Type
 
 from .checksum import calculate_checksum, CHECKSUM_MAPPING
-from fprime_gds.plugin.definitions import gds_plugin_implementation, gds_plugin_specification
+from fprime_gds.plugin.definitions import (
+    gds_plugin_implementation,
+    gds_plugin_specification,
+)
 
 
 class FramerDeframer(abc.ABC):
@@ -28,7 +33,7 @@ class FramerDeframer(abc.ABC):
     """
 
     @abc.abstractmethod
-    def frame(self, data):
+    def frame(self, data: bytes) -> bytes:
         """
         Frames outgoing data in the specified format. Expects incoming raw bytes to frame, and adds on the needed header
         and footer bytes. This new array of bytes is returned from the method.
@@ -38,20 +43,27 @@ class FramerDeframer(abc.ABC):
         """
 
     @abc.abstractmethod
-    def deframe(self, data, no_copy=False):
+    def deframe(
+        self, data: bytes, no_copy=False
+    ) -> tuple[(bytes | None), bytes, bytes]:
         """
-        Deframes the incoming data from the specified format. Produces exactly one packet, and leftover bytes. Users
-        wanting all packets to be deframed should call "deframe_all". If no full packet is available, this method
+        Deframes the incoming data from the specified format. 
+        Produces:
+        - One packet, or None if no packet found
+        - leftover bytes (not consumed yet)
+        - Discarded data (consumed and determined not to be valid)
+
+        Users wanting all packets to be deframed should call "deframe_all". If no full packet is available, this method
         returns None. Expects incoming raw bytes to deframe, and returns a deframed packet or None, the leftover
         bytes that were unused, and any bytes discarded from the existing data stream. Will search and discard data up
         until a start token is found. Note: data will be consumed up to the first start token found.
 
         :param data: framed data bytes
         :param no_copy: (optional) will prevent extra copy if True, but "data" input will be destroyed.
-        :return: (packet as array of bytes or None, leftover bytes, any discarded data)
+        :return: (packet as bytes or None, leftover bytes, any discarded data)
         """
 
-    def deframe_all(self, data, no_copy):
+    def deframe_all(self, data: bytes, no_copy: bool):
         """
         Deframes all available packets found in a single set of bytes by calling deframe until a None packet is
         retrieved. This list of packets, and the remaining bytes are returned
@@ -66,11 +78,11 @@ class FramerDeframer(abc.ABC):
         discarded_aggregate = b""
         while True:
             # Deframe and return only on None
-            (packet, data, discarded) = self.deframe(data, no_copy=True)
+            (deframed, data, discarded) = self.deframe(data, no_copy=True)
             discarded_aggregate += discarded
-            if packet is None:
+            if deframed is None: # No more packets available, return aggregate
                 return packets, data, discarded_aggregate
-            packets.append(packet)
+            packets.append(deframed)
 
     @classmethod
     @gds_plugin_specification
@@ -117,7 +129,7 @@ class FpFramerDeframer(FramerDeframer):
     HEADER_FORMAT = None
     START_TOKEN = None
 
-    def __init__(self, checksum_type):
+    def __init__(self, checksum_type="crc32"):
         """Sets constants on construction."""
         # Setup the constants as soon as possible.
         FpFramerDeframer.set_constants()
@@ -197,13 +209,12 @@ class FpFramerDeframer(FramerDeframer):
                 )
                 # If the checksum is valid, return the packet. Otherwise continue to rotate
                 if check == calculate_checksum(
-                    data[: data_size + FpFramerDeframer.HEADER_SIZE],
-                    self.checksum
+                    data[: data_size + FpFramerDeframer.HEADER_SIZE], self.checksum
                 ):
                     data = data[total_size:]
                     return deframed, data, discarded
                 print(
-                    "[WARNING] Checksum validation failed. Have you correctly set '--comm-checksum-type'",
+                    "[WARNING] Checksum validation failed.",
                     file=sys.stderr,
                 )
                 # Bad checksum, rotate 1 and keep looking for non-garbage
@@ -216,29 +227,13 @@ class FpFramerDeframer(FramerDeframer):
 
     @classmethod
     def get_name(cls):
-        """ Get the name of this plugin """
+        """Get the name of this plugin"""
         return "fprime"
 
-    @classmethod
-    def get_arguments(cls):
-        """ Get arguments for the framer/deframer """
-        return {("--comm-checksum-type",): {
-            "dest": "checksum_type",
-            "action": "store",
-            "type": str,
-            "help": "Setup the checksum algorithm. [default: %(default)s]",
-            "choices": [
-                item
-                for item in CHECKSUM_MAPPING.keys()
-                if item != "default"
-            ],
-            "default": "crc32",
-        }}
-
     @classmethod
     @gds_plugin_implementation
     def register_framing_plugin(cls):
-        """ Register a bad plugin """
+        """Register a bad plugin"""
         return cls
 
 

fprime_gds/common/utils/data_desc_type.py

@@ -5,10 +5,13 @@ Defines an enumeration that represents each type of data packet that can be down
 """
 from enum import Enum
 
+
+# TODO: these values should be read from the dictionary instead of hardcoded here
+
 DataDescType = Enum(
     "DataDescType",
-    # Command packet type - incoming
     {
+        # Command packet type - incoming
         "FW_PACKET_COMMAND": 0,
         # Telemetry packet type - outgoing
         "FW_PACKET_TELEM": 1,
@@ -24,5 +27,7 @@ DataDescType = Enum(
         "FW_PACKET_HAND": 0xFE,
         # Unknown packet
         "FW_PACKET_UNKNOWN": 0xFF,
+        # Space Packet Idle APID
+        "CCSDS_SPACE_PACKET_IDLE_APID": 0x7FF,
     },
 )

fprime_gds/executables/cli.py

@@ -19,6 +19,9 @@ import os
 import platform
 import re
 import sys
+
+import yaml
+
 from abc import ABC, abstractmethod
 from pathlib import Path
 from typing import Any, Dict, List, Tuple
@@ -185,8 +188,32 @@ class ParserBase(ABC):
         Returns: namespace with processed results of arguments.
         """
 
-    @staticmethod
+    @classmethod
+    def parse_known_args(
+        cls,
+        parser_classes,
+        description="No tool description provided",
+        arguments=None,
+        **kwargs,
+    ):
+        """Parse and post-process arguments
+
+        Create a parser for the given application using the description provided. This will then add all specified
+        ParserBase subclasses' get_parser output as parent parses for the created parser. Then all of the handle
+        arguments methods will be called, and the final namespace will be returned. This will allow unknown arguments
+        which are returned as the last tuple result.
+
+        Args:
+            parser_classes: a list of ParserBase subclasses that will be used to
+            description: description passed ot the argument parser
+            arguments: arguments to process, None to use command line input
+        Returns: namespace with all parsed arguments from all provided ParserBase subclasses
+        """
+        return cls._parse_args(parser_classes, description, arguments, use_parse_known=True, **kwargs)
+
+    @classmethod
     def parse_args(
+        cls,
         parser_classes,
         description="No tool description provided",
         arguments=None,
@@ -194,20 +221,53 @@ class ParserBase(ABC):
     ):
         """Parse and post-process arguments
 
+        Create a parser for the given application using the description provided. This will then add all specified
+        ParserBase subclasses' get_parser output as parent parses for the created parser. Then all of the handle
+        arguments methods will be called, and the final namespace will be returned. This does not allow unknown
+        arguments.
+
+        Args:
+            parser_classes: a list of ParserBase subclasses that will be used to
+            description: description passed ot the argument parser
+            arguments: arguments to process, None to use command line input
+        Returns: namespace with all parsed arguments from all provided ParserBase subclasses
+        """
+        return cls._parse_args(parser_classes, description, arguments, **kwargs)
+
+
+    @staticmethod
+    def _parse_args(
+        parser_classes,
+        description="No tool description provided",
+        arguments=None,
+        use_parse_known=False,
+        **kwargs,
+    ):
+        """Parse and post-process arguments helper
+
         Create a parser for the given application using the description provided. This will then add all specified
         ParserBase subclasses' get_parser output as parent parses for the created parser. Then all of the handle
         arguments methods will be called, and the final namespace will be returned.
 
+        This takes a function that will take in a parser and return the parsing function to call on arguments.
+
         Args:
+            parse_function_processor: takes a parser, returns the parse function to call
             parser_classes: a list of ParserBase subclasses that will be used to
             description: description passed ot the argument parser
             arguments: arguments to process, None to use command line input
+            use_parse_known: use parse_known_arguments from argparse
+
         Returns: namespace with all parsed arguments from all provided ParserBase subclasses
         """
         composition = CompositeParser(parser_classes, description)
         parser = composition.get_parser()
         try:
-            args_ns = parser.parse_args(arguments)
+            if use_parse_known:
+                args_ns, *unknowns = parser.parse_known_args(arguments)
+            else:
+                args_ns = parser.parse_args(arguments)
+                unknowns = []
             args_ns = composition.handle_arguments(args_ns, **kwargs)
         except ValueError as ver:
             print(f"[ERROR] Failed to parse arguments: {ver}", file=sys.stderr)
@@ -216,7 +276,7 @@ class ParserBase(ABC):
         except Exception as exc:
             print(f"[ERROR] {exc}", file=sys.stderr)
             sys.exit(-1)
-        return args_ns, parser
+        return args_ns, parser, *unknowns
 
     @staticmethod
     def find_in(token, deploy, is_file=True):
@@ -236,6 +296,106 @@ class ParserBase(ABC):
         return None
 
 
+class ConfigDrivenParser(ParserBase):
+    """ Parser that allows options from configuration and command line
+
+    This parser reads a configuration file (if supplied) and uses the values to drive the inputs to arguments. Command
+    line arguments will still take precedence over the configured values.
+    """
+    DEFAULT_CONFIGURATION_PATH = Path("fprime-gds.yml")
+
+    @classmethod
+    def set_default_configuration(cls, path: Path):
+        """ Set path for (global) default configuration file
+
+        Set the path for default configuration file. If unset, will use 'fprime-gds.yml'. Set to None to disable default
+        configuration.
+        """
+        cls.DEFAULT_CONFIGURATION_PATH = path
+
+    @classmethod
+    def parse_args(
+        cls,
+        parser_classes,
+        description="No tool description provided",
+        arguments=None,
+        **kwargs,
+    ):
+        """ Parse and post-process arguments using inputs and config
+
+        Parse the arguments in two stages: first parse the configuration data, ignoring unknown inputs, then parse the
+        full argument set with the supplied configuration to fill in additional options.
+
+        Args:
+            parser_classes: a list of ParserBase subclasses that will be used to
+            description: description passed ot the argument parser
+            arguments: arguments to process, None to use command line input
+        Returns: namespace with all parsed arguments from all provided ParserBase subclasses
+        """
+        arguments = sys.argv[1:] if arguments is None else arguments
+
+        # Help should spill all the arguments, so delegate to the normal parsing flow including
+        # this and supplied parsers
+        if "-h" in arguments or "--help" in arguments:
+            parsers = [ConfigDrivenParser] + parser_classes
+            ParserBase.parse_args(parsers, description, arguments, **kwargs)
+            sys.exit(0)
+
+        # Custom flow involving parsing the arguments of this parser first, then passing the configured values
+        # as part of the argument source
+        ns_config, _, remaining = ParserBase.parse_known_args([ConfigDrivenParser], description, arguments, **kwargs)
+        config_options = ns_config.config_values.get("command-line-options", {})
+        config_args = cls.flatten_options(config_options)
+        # Argparse allows repeated (overridden) arguments, thus the CLI override is accomplished by providing
+        # remaining arguments after the configured ones
+        ns_full, parser = ParserBase.parse_args(parser_classes, description, config_args + remaining, **kwargs)
+        ns_final =  argparse.Namespace(**vars(ns_config), **vars(ns_full))
+        return ns_final, parser
+
+    @staticmethod
+    def flatten_options(configured_options):
+        """ Flatten options down to arguments """
+        flattened = []
+        for option, value in configured_options.items():
+            flattened.append(f"--{option}")
+            if value is not None:
+                flattened.extend(value if isinstance(value, (list, tuple)) else [f"{value}"])
+        return flattened
+
+    def get_arguments(self) -> Dict[Tuple[str, ...], Dict[str, Any]]:
+        """Arguments needed for config processing"""
+        return {
+            ("-c", "--config"): {
+                "dest": "config",
+                "required": False,
+                "default": self.DEFAULT_CONFIGURATION_PATH,
+                "type": Path,
+                "help": f"Argument configuration file path.",
+            }
+        }
+
+    def handle_arguments(self, args, **kwargs):
+        """ Handle the arguments
+
+        Loads the configuration file specified and fills in the `config_values` attribute of the namespace with the
+        loaded configuration dictionary.
+        """
+        args.config_values = {}
+        # Specified but non-existent config file is a hard error
+        if ("-c" in sys.argv[1:] or "--config" in sys.argv[1:]) and not args.config.exists():
+            raise ValueError(f"Specified configuration file '{args.config}' does not exist")
+        # Read configuration if the file was set and exists
+        if args.config is not None  and args.config.exists():
+            print(f"[INFO] Reading command-line configuration from: {args.config}")
+            with open(args.config, "r") as file_handle:
+                try:
+                    loaded = yaml.safe_load(file_handle)
+                    args.config_values = loaded if loaded is not None else {}
+                except Exception as exc:
+                    raise ValueError(f"Malformed configuration {args.config}: {exc}", exc)
+        return args
+
+
 class DetectionParser(ParserBase):
     """Parser that detects items from a root/directory or deployment"""
 
@@ -398,6 +558,7 @@ class IndividualPluginParser(BareArgumentParser):
                 for key, value in self.extract_arguments(arguments).items()
                 if key != self.disable_flag_destination
             }
+
             plugin_zero_argument_class = functools.partial(
                 self.plugin_class.get_implementor(), **plugin_arguments
             )

fprime_gds/executables/run_deployment.py

@@ -9,6 +9,7 @@ import webbrowser
 
 from fprime_gds.executables.cli import (
     BinaryDeployment,
+    ConfigDrivenParser,
     CommParser,
     GdsParser,
     ParserBase,
@@ -37,7 +38,7 @@ def parse_args():
         PluginArgumentParser,
     ]
     # Parse the arguments, and refine through all handlers
-    args, parser = ParserBase.parse_args(arg_handlers, "Run F prime deployment and GDS")
+    args, parser = ConfigDrivenParser.parse_args(arg_handlers, "Run F prime deployment and GDS")
     return args
 
 

fprime_gds/plugin/system.py

@@ -218,6 +218,7 @@ class Plugins(object):
                 FramerDeframer,
                 FpFramerDeframer,
             )
+            from fprime_gds.common.communication.ccsds.chain import SpacePacketSpaceDataLinkFramerDeframer
             from fprime_gds.common.communication.adapters.base import (
                 BaseAdapter,
                 NoneAdapter,
@@ -233,7 +234,7 @@ class Plugins(object):
                 "framing": {
                     "class": FramerDeframer,
                     "type": PluginType.SELECTION,
-                    "built-in": [FpFramerDeframer],
+                    "built-in": [FpFramerDeframer, SpacePacketSpaceDataLinkFramerDeframer],
                 },
                 "communication": {
                     "class": BaseAdapter,

{fprime_gds-4.0.0a1.dist-info → fprime_gds-4.0.0a3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fprime-gds
-Version: 4.0.0a1
+Version: 4.0.0a3
 Summary: F Prime Flight Software Ground Data System layer
 Author-email: Michael Starch <Michael.D.Starch@jpl.nasa.gov>, Thomas Boyer-Chammard <Thomas.Boyer.Chammard@jpl.nasa.gov>
 License: 
@@ -216,15 +216,15 @@ Classifier: Operating System :: Unix
 Classifier: Operating System :: POSIX
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: License :: OSI Approved :: Apache Software License
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 License-File: NOTICE.txt
@@ -240,6 +240,9 @@ Requires-Dist: Jinja2>=2.11.3
 Requires-Dist: openpyxl>=3.0.10
 Requires-Dist: pyserial>=3.5
 Requires-Dist: pydantic>=2.6
+Requires-Dist: PyYAML>=6.0.2
+Requires-Dist: spacepackets>=0.28.0
+Requires-Dist: crc>=7.0.0
 Dynamic: license-file
 
 # F´ GDS

{fprime_gds-4.0.0a1.dist-info → fprime_gds-4.0.0a3.dist-info}/RECORD

@@ -7,13 +7,18 @@ fprime_gds/common/transport.py,sha256=uYXWkM8TYEYz1vfY4AEn0PF8Gu4tkYmJ5t4w1YY1yW
 fprime_gds/common/zmq_transport.py,sha256=E_iBZ5sA4JKB99MWSOM6XnPrO-mbFyRvD9eQp9te6-Y,12397
 fprime_gds/common/communication/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/common/communication/checksum.py,sha256=f6W0Tr68U-XGnFmysMqsFzoGYZVE8clKf-VIJja_1YM,741
-fprime_gds/common/communication/framing.py,sha256=TPpVn5JfGJxdc9BuKJzm5LXo6OQKtkSqX695UdN-Ezk,12915
+fprime_gds/common/communication/framing.py,sha256=GnEUgHiTc0dEJ3coaVmcA03NXk8ehHfPaywB7hNnoO8,12658
 fprime_gds/common/communication/ground.py,sha256=9SD3AoyHA43yNE8UYkWnu5nEJt1PgyB3sU3QLDc4eDY,3619
 fprime_gds/common/communication/updown.py,sha256=UhfCIIA2eM5g2FsIhOGJJH6HzHurUPgcKIJ5fsLb2lE,9888
 fprime_gds/common/communication/adapters/__init__.py,sha256=ivGtzUTqhBYuve5mhN9VOHITwgZjNMVv7sxuac2Ll3c,470
 fprime_gds/common/communication/adapters/base.py,sha256=i3mf4HC-4tuf4mNkhdXCKlngRhODyTriia2pw6XBoSQ,3393
 fprime_gds/common/communication/adapters/ip.py,sha256=vCDclpsb3rVRXSxKqdt9UfkM2M6oCxnsKdzbzhMc0kM,17074
-fprime_gds/common/communication/adapters/uart.py,sha256=6SrN42ShVjwNubFg-1YrO09o1uJtu1rFqeMpLDNWlW4,6647
+fprime_gds/common/communication/adapters/uart.py,sha256=5WkA8xpQ8E7nv2DbN168fibz1l-GddJUKnf6Hcd4hvU,7194
+fprime_gds/common/communication/ccsds/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fprime_gds/common/communication/ccsds/apid.py,sha256=Y5K_xHLo1bmpxOlkt-TSLulCXbKIQrbYfa3GXhadqEE,686
+fprime_gds/common/communication/ccsds/chain.py,sha256=Rkhls55BUwFU0cMlRMY183hlFpfqidQJ9ZUE1kdfi38,4637
+fprime_gds/common/communication/ccsds/space_data_link.py,sha256=pDi1JpmYBuKGsDgTX80Wp8PU_CDtDPtkzdnX1FXN5eM,7385
+fprime_gds/common/communication/ccsds/space_packet.py,sha256=JAPpefcNya_XHGOze9WtYnYCL0NjweSLSfdX1eZEVjg,5221
 fprime_gds/common/controllers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/common/data_types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/common/data_types/ch_data.py,sha256=RP9zSyzNcH0nJ3MYyW_IATnmnHYZ6d0KmoJUJantdBI,6111
@@ -107,16 +112,16 @@ fprime_gds/common/tools/params.py,sha256=htnMLlUW9HmBo4Qc7kYhnWr1sO6bK2mckdskLt5
 fprime_gds/common/tools/seqgen.py,sha256=O57igktjWku5OJhBqezhCjPYUmh4GZM-9qKCChqEW7g,6034
 fprime_gds/common/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/common/utils/config_manager.py,sha256=EurtNdApA9zpIjAXmGSTgFUen0UaVDryH5g9LwMhu1E,5539
-fprime_gds/common/utils/data_desc_type.py,sha256=9GV8hV5q1dDxdfF-1-Wty5MBrFd94EbZ8hpHHkBJKuo,715
+fprime_gds/common/utils/data_desc_type.py,sha256=0AkEMfEa5refd_moovf1hkgKiNakADRzv4soghvf9a4,883
 fprime_gds/common/utils/event_severity.py,sha256=7qPXHrDaM_REJ7sKBUEJTZIE0D4qVnVajsPDUuHg7sI,300
 fprime_gds/common/utils/string_util.py,sha256=u_2iahRG3ROu3lAAt_KVcK226gEByElXqrA8mH8eDpI,3584
 fprime_gds/executables/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/executables/apps.py,sha256=iyHloLaHJOkcZF6O3oXZX6YpoS2SBBZVPilf25l0Q98,13138
-fprime_gds/executables/cli.py,sha256=kdwQ3Wqi7zg0v3QkOyy3YEh3w3T520yGmIMJEk4mAzs,43180
+fprime_gds/executables/cli.py,sha256=aNO8saIKuTDQMwWNFlrpIL5HuwIWWei94Wxf3G0lY3k,50382
 fprime_gds/executables/comm.py,sha256=08rO0o0MJgTRngB7Ygu2IL_gEAWKF7WFvFyro1CqReE,5214
 fprime_gds/executables/data_product_writer.py,sha256=aXnQ75hQ8bapz-sr21mrPCrXIfqQblfBuB49GGZrFLg,34965
 fprime_gds/executables/fprime_cli.py,sha256=CMoT7zWNwM8h2mSZW03AR96wl_XnZXoLNiOZN_sDi38,12431
-fprime_gds/executables/run_deployment.py,sha256=sOtvVcNOSUZMvELc4cDVAXhBNAFIWM3OjxLq_sXf0tc,7177
+fprime_gds/executables/run_deployment.py,sha256=x6auxjsDyCj4216JbO0bSskv2H9r7n3vuu5Z3O5cGwY,7209
 fprime_gds/executables/tcpserver.py,sha256=KspVpu5YIuiWKOk5E6UDMKvqXYrRB1j9aX8CkMxysfw,17555
 fprime_gds/executables/utils.py,sha256=SbzXRe1p41qMPdifvPap5_4v0T42gZZ_Rs_OYfITd80,7626
 fprime_gds/flask/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -232,11 +237,11 @@ fprime_gds/flask/static/third-party/webfonts/fa-solid-900.woff,sha256=P200iM9lN0
 fprime_gds/flask/static/third-party/webfonts/fa-solid-900.woff2,sha256=mDS4KtJuKjdYPSJnahLdLrD-fIA1aiEU0NsaqLOJlTc,78268
 fprime_gds/plugin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/plugin/definitions.py,sha256=QlxW1gNvoiqGMslSJjh3dTFZuv0igFHawN__3XJ0Wns,5355
-fprime_gds/plugin/system.py,sha256=UiNrUqfi-KJOgRIOR8uyFMKdquSPZh_txpNq8eH35-Y,13285
-fprime_gds-4.0.0a1.dist-info/licenses/LICENSE.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-fprime_gds-4.0.0a1.dist-info/licenses/NOTICE.txt,sha256=vXjA_xRcQhd83Vfk5D_vXg5kOjnnXvLuMi5vFKDEVmg,1612
-fprime_gds-4.0.0a1.dist-info/METADATA,sha256=BLViE79kzUK1-kjXnrjPrsQ1Syaugyyo4eWgL9EiqVM,24457
-fprime_gds-4.0.0a1.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-fprime_gds-4.0.0a1.dist-info/entry_points.txt,sha256=qFBHIR7CZ5CEeSEdZ-ZVQN9ZfUOZfm0PvvDZAAheuLk,445
-fprime_gds-4.0.0a1.dist-info/top_level.txt,sha256=6vzFLIX6ANfavKaXFHDMSLFtS94a6FaAsIWhjgYuSNE,27
-fprime_gds-4.0.0a1.dist-info/RECORD,,
+fprime_gds/plugin/system.py,sha256=M9xb-8jBhCUUx3X1z2uAP8Wx_v6NkL8JeaFgGcMnQqY,13432
+fprime_gds-4.0.0a3.dist-info/licenses/LICENSE.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+fprime_gds-4.0.0a3.dist-info/licenses/NOTICE.txt,sha256=vXjA_xRcQhd83Vfk5D_vXg5kOjnnXvLuMi5vFKDEVmg,1612
+fprime_gds-4.0.0a3.dist-info/METADATA,sha256=Qs6683dylX3zRC8sL3vzh6yLDwtok_LhG6xPVocO1q4,24549
+fprime_gds-4.0.0a3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fprime_gds-4.0.0a3.dist-info/entry_points.txt,sha256=qFBHIR7CZ5CEeSEdZ-ZVQN9ZfUOZfm0PvvDZAAheuLk,445
+fprime_gds-4.0.0a3.dist-info/top_level.txt,sha256=6vzFLIX6ANfavKaXFHDMSLFtS94a6FaAsIWhjgYuSNE,27
+fprime_gds-4.0.0a3.dist-info/RECORD,,

{fprime_gds-4.0.0a1.dist-info → fprime_gds-4.0.0a3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.7.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any