fprime-gds 3.4.3__py3-none-any.whl → 3.4.4a2__py3-none-any.whl

fprime_gds/common/communication/adapters/base.py

@@ -9,6 +9,8 @@ adapter for use with the comm-layer.
 @author lestarch
 """
 import abc
+from typing import Type
+from fprime_gds.plugin.definitions import gds_plugin_implementation, gds_plugin_specification
 
 
 class BaseAdapter(abc.ABC):
@@ -47,71 +49,41 @@ class BaseAdapter(abc.ABC):
         """
 
     @classmethod
-    @abc.abstractmethod
-    def get_arguments(cls):
-        """
-        Returns a set of arguments consumed by this adapter. This will be consumed by the CLI layer in order to provide
-        command line arguments to the user. Note: these should be globally unique args, e.g. --ip-address
+    @gds_plugin_specification
+    def register_communication_plugin(cls) -> Type["BaseAdapter"]:
+        """Register a communications adapter
 
-        :return: dictionary, keys of tuple of arg flags and value of list of other arguments to argparse's add_argument
-        """
+        Plugin hook for registering a plugin that supplies an adapter to the communications interface (radio, uart, i2c,
+        etc). This interface is expected to read and write bytes from a wire and will be provided to the framing system.
 
-    @classmethod
-    @abc.abstractmethod
-    def check_arguments(cls, args):
-        """
-        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.
+        Note: users should return the class, not an instance of the class. Needed arguments for instantiation are
+        determined from class methods, solicited via the command line, and provided at construction time to the chosen
+        instantiation.
 
-        :param args: arguments as dictionary
+        Returns:
+            BaseAdapter subclass
         """
+        raise NotImplementedError()
+
+
+class NoneAdapter(BaseAdapter):
+    """ None adapter used to turn off the comm script """
 
     @classmethod
-    def get_adapters(cls):
-        """
-        Get all known adapters of this base class. These must be imported into the comm-layer to be available to the
-        system, however; they only need to be imported. Once imported this function will find them and make them
-        available to the comm-layer in the standard way.
+    def get_name(cls):
+        """ Get name of the non-adapter """
+        return "none"
 
-        :return: list of all imported comm adapters.
-        """
-        adapter_map = {}
-        for adapter in cls.__subclasses__():
-            # Get two versions of names
-            adapter_name = adapter.__module__
-            adapter_short = adapter_name.split(".")[-1]
-            # Check to use long or short name
-            if adapter_short not in adapter_map:
-                adapter_name = adapter_short
-            adapter_map[adapter_name] = adapter
-        return adapter_map
-
-    @staticmethod
-    def process_arguments(clazz, args):
-        """
-        Process arguments incoming from the command line and construct a dictionary of kwargs to supply to the chosen
-        adapter at creation time. This will allow the user to choose any imported adapters at runtime.
+    def read(self, timeout=0.500):
+        """ Raise exception if this is called"""
+        raise NotImplementedError()
 
-        :param args: arguments to process
-        :return: dictionary of constructor keyword arguments
-        """
-        return {
-            value["dest"]: getattr(args, value["dest"])
-            for value in clazz.get_arguments().values()
-        }
+    def write(self, frame):
+        """ Raise exception if this is called"""
+        raise NotImplementedError()
 
     @classmethod
-    def construct_adapter(cls, adapter_name, args):
-        """
-        Constructs a new adapter, from the given adapter name and the given namespace of argument inputs. This is a
-        wrapper of "get_adapters" and "process_arguments" to help build a new, fully configured, adapter. This is a
-        factory method.
-
-        :param adapter_name: name of the adapter to build
-        :param args: namespace of arg value to help build an adapter
-        :return: newly constructed adapter
-        """
-        if adapter_name == "none":
-            return None
-        adapter = cls.get_adapters()[adapter_name]
-        return adapter(**cls.process_arguments(adapter, args))
+    @gds_plugin_implementation
+    def register_communication_plugin(cls):
+        """ Register this as a plugin """
+        return cls

fprime_gds/common/communication/adapters/ip.py

@@ -18,6 +18,8 @@ import time
 import fprime_gds.common.communication.adapters.base
 import fprime_gds.common.logger
 
+from fprime_gds.plugin.definitions import gds_plugin_implementation
+
 LOGGER = logging.getLogger("ip_adapter")
 
 
@@ -114,7 +116,7 @@ class IpAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
 
     def write(self, frame):
         """
-        Send a given framed bit of data by sending it out the serial interface. It will attempt to reconnect if there is
+        Send a given framed bit of data by sending it out the serial interface. It will attempt to reconnect if there
         was a problem previously. This function will return true on success, or false on error.
 
         :param frame: framed data packet to send out
@@ -151,6 +153,11 @@ class IpAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
             self.write(IpAdapter.KEEPALIVE_DATA)
             time.sleep(interval)
 
+    @classmethod
+    def get_name(cls):
+        """ Get the name of this adapter  """
+        return "ip"
+
     @classmethod
     def get_arguments(cls):
         """
@@ -163,13 +170,13 @@ class IpAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
                 "dest": "address",
                 "type": str,
                 "default": "0.0.0.0",
-                "help": "Address of the IP adapter server. Default: %(default)s",
+                "help": "Address of the IP adapter server.",
             },
             ("--ip-port",): {
                 "dest": "port",
                 "type": int,
                 "default": 50000,
-                "help": "Port of the IP adapter server. Default: %(default)s",
+                "help": "Port of the IP adapter server.",
             },
             ("--ip-client",): {
                 # dest is "server" since it is handled in BaseAdapter.construct_adapter and passed with the same
@@ -182,14 +189,25 @@ class IpAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
         }
 
     @classmethod
-    def check_arguments(cls, args):
+    @gds_plugin_implementation
+    def register_communication_plugin(cls):
+        """ Register this as a communication plugin """
+        return cls
+
+    @classmethod
+    def check_arguments(cls, address, port, server=True):
         """
         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
         """
-        check_port(args["address"], args["port"])
+        try:
+            if server:
+                check_port(address, port)
+        except OSError as os_error:
+            raise ValueError(f"{os_error}")
+
 
 
 class IpHandler(abc.ABC):

fprime_gds/common/communication/adapters/uart.py

@@ -15,6 +15,8 @@ from serial.tools import list_ports
 
 import fprime_gds.common.communication.adapters.base
 
+from fprime_gds.plugin.definitions import gds_plugin_implementation
+
 LOGGER = logging.getLogger("serial_adapter")
 
 
@@ -151,18 +153,29 @@ class SerialAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
                 "dest": "device",
                 "type": str,
                 "default": default,
-                "help": "UART device representing the FSW. Default: %(default)s",
+                "help": "UART device representing the FSW.",
             },
             ("--uart-baud",): {
                 "dest": "baud",
                 "type": int,
                 "default": 9600,
-                "help": "Baud rate of the serial device. Default: %(default)s",
+                "help": "Baud rate of the serial device.",
             },
         }
 
     @classmethod
-    def check_arguments(cls, args):
+    def get_name(cls):
+        """ Get name of the adapter """
+        return "uart"
+
+    @classmethod
+    @gds_plugin_implementation
+    def register_communication_plugin(cls):
+        """ Register this as a communication plugin """
+        return cls
+
+    @classmethod
+    def check_arguments(cls, device, baud):
         """
         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.
@@ -170,16 +183,16 @@ class SerialAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
         :param args: arguments as dictionary
         """
         ports = map(lambda info: info.device, list_ports.comports(include_links=True))
-        if args["device"] not in ports:
-            msg = f"Serial port '{args['device']}' not valid. Available ports: {ports}"
+        if 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
         try:
-            baud = int(args["baud"])
+            baud = int(baud)
         except ValueError:
-            msg = f"Serial baud rate '{args['baud']}' not integer. Use one of: {SerialAdapter.BAUDS}"
+            msg = f"Serial baud rate '{baud}' not integer. Use one of: {SerialAdapter.BAUDS}"
             raise ValueError(
                 msg
             )

fprime_gds/common/communication/checksum.py

@@ -11,7 +11,6 @@ def crc_calculation(data: bytes):
     return zlib.crc32(data) & 0xFFFFFFFF
 
 
-CHECKSUM_SELECTION = "crc32"
 CHECKSUM_MAPPING = {
     "fixed": lambda data: 0xCAFECAFE,
     "crc32": crc_calculation,
@@ -19,8 +18,7 @@ CHECKSUM_MAPPING = {
 }
 
 
-def calculate_checksum(data: bytes):
+def calculate_checksum(data: bytes, selected_checksum: str):
     """Calculates the checksum of bytes"""
-    selected_checksum = CHECKSUM_SELECTION
     hash_fn = CHECKSUM_MAPPING.get(selected_checksum, CHECKSUM_MAPPING.get("default"))
     return hash_fn(data)

fprime_gds/common/communication/framing.py

@@ -15,8 +15,10 @@ import abc
 import copy
 import struct
 import sys
+from typing import Type
 
-from .checksum import calculate_checksum
+from .checksum import calculate_checksum, CHECKSUM_MAPPING
+from fprime_gds.plugin.definitions import gds_plugin_implementation, gds_plugin_specification
 
 
 class FramerDeframer(abc.ABC):
@@ -70,6 +72,24 @@ class FramerDeframer(abc.ABC):
                 return packets, data, discarded_aggregate
             packets.append(packet)
 
+    @classmethod
+    @gds_plugin_specification
+    def register_framing_plugin(cls) -> Type["FramerDeframer"]:
+        """Register a plugin to provide framing capabilities
+
+        Plugin hook for registering a plugin that supplies a FramerDeframer implementation. Implementors of this hook must
+        return a non-abstract subclass of FramerDeframer. This class will be provided as a framing implementation option
+        that users may select via command line arguments.
+
+        Note: users should return the class, not an instance of the class. Needed arguments for instantiation are
+        determined from class methods, solicited via the command line, and provided at construction time to the chosen
+        instantiation.
+
+        Returns:
+            FramerDeframer subclass
+        """
+        raise NotImplementedError()
+
 
 class FpFramerDeframer(FramerDeframer):
     """
@@ -97,10 +117,11 @@ class FpFramerDeframer(FramerDeframer):
     HEADER_FORMAT = None
     START_TOKEN = None
 
-    def __init__(self):
+    def __init__(self, checksum_type):
         """Sets constants on construction."""
         # Setup the constants as soon as possible.
         FpFramerDeframer.set_constants()
+        self.checksum = checksum_type
 
     @classmethod
     def set_constants(cls):
@@ -134,7 +155,7 @@ class FpFramerDeframer(FramerDeframer):
             FpFramerDeframer.HEADER_FORMAT, FpFramerDeframer.START_TOKEN, len(data)
         )
         framed += data
-        framed += struct.pack(">I", calculate_checksum(framed))
+        framed += struct.pack(">I", calculate_checksum(framed, self.checksum))
         return framed
 
     def deframe(self, data, no_copy=False):
@@ -176,7 +197,8 @@ 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]
+                    data[: data_size + FpFramerDeframer.HEADER_SIZE],
+                    self.checksum
                 ):
                     data = data[total_size:]
                     return deframed, data, discarded
@@ -192,6 +214,33 @@ class FpFramerDeframer(FramerDeframer):
             return None, data, discarded
         return None, data, discarded
 
+    @classmethod
+    def get_name(cls):
+        """ 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 """
+        return cls
+
 
 class TcpServerFramerDeframer(FramerDeframer):
     """

fprime_gds/common/data_types/event_data.py

@@ -44,7 +44,12 @@ class EventData(sys_data.SysData):
             self.display_text = event_temp.description
         elif event_temp.format_str == "":
             args_template = self.template.get_args()
-            self.display_text = str([{args_template[index][0]:arg.val} for index, arg in enumerate(event_args)])
+            self.display_text = str(
+                [
+                    {args_template[index][0]: arg.val}
+                    for index, arg in enumerate(event_args)
+                ]
+            )
         else:
             self.display_text = format_string_template(
                 event_temp.format_str, tuple([arg.val for arg in event_args])

fprime_gds/common/data_types/exceptions.py

@@ -2,10 +2,25 @@
 Created on Jan 9, 2015
 @author: reder
 """
+
 # Exception classes for all controllers modules
 
 
-class GseControllerException(Exception):
+class FprimeGdsException(Exception):
+    """
+    Base Exception for exceptions that need to be handled at the system-level
+    by the GDS
+    """
+
+    pass
+
+
+class GdsDictionaryParsingException(FprimeGdsException):
+    pass
+
+
+# Note: Gse is the historical name for what is now called the GDS
+class GseControllerException(FprimeGdsException):
     def __init__(self, val):
         self.except_msg = val
         super().__init__(val)
@@ -27,13 +42,3 @@ class GseControllerUndefinedFileException(GseControllerException):
 class GseControllerParsingException(GseControllerException):
     def __init__(self, val):
         super().__init__(f"Parsing error: {str(val)}")
-
-
-class GseControllerMnemonicMismatchException(GseControllerException):
-    def __init__(self, val1, val2):
-        super().__init__(f"ID mismatch ({str(val1)}, {str(val2)})!")
-
-
-class GseControllerStatusUpdateException(GseControllerException):
-    def __init__(self, val):
-        super().__init__(f"Bad status update mode: {str(val)}!")

fprime_gds/common/loaders/ch_json_loader.py

@@ -0,0 +1,107 @@
+"""
+ch_json_loader.py:
+
+Loads flight dictionary (JSON) and returns id and mnemonic based Python dictionaries of channels
+
+@author thomas-bc
+"""
+
+from fprime_gds.common.templates.ch_template import ChTemplate
+from fprime_gds.common.loaders.json_loader import JsonLoader
+from fprime_gds.common.data_types.exceptions import GdsDictionaryParsingException
+
+
+class ChJsonLoader(JsonLoader):
+    """Class to load python based telemetry channel dictionaries"""
+
+    CHANNELS_FIELD = "telemetryChannels"
+
+    ID = "id"
+    NAME = "name"
+    DESC = "annotation"
+    TYPE = "type"
+    FMT_STR = "format"
+    LIMIT_FIELD = "limit"
+    LIMIT_LOW = "low"
+    LIMIT_HIGH = "high"
+    LIMIT_RED = "red"
+    LIMIT_ORANGE = "orange"
+    LIMIT_YELLOW = "yellow"
+
+    def construct_dicts(self, _):
+        """
+        Constructs and returns python dictionaries keyed on id and name
+
+        Args:
+            _: Unused argument (inherited)
+        Returns:
+            A tuple with two channel dictionaries (python type dict):
+            (id_dict, name_dict). The keys should be the channels' id and
+            name fields respectively and the values should be ChTemplate
+            objects.
+        """
+        id_dict = {}
+        name_dict = {}
+
+        if self.CHANNELS_FIELD not in self.json_dict:
+            raise GdsDictionaryParsingException(
+                f"Ground Dictionary missing '{self.CHANNELS_FIELD}' field: {str(self.json_file)}"
+            )
+
+        for ch_dict in self.json_dict[self.CHANNELS_FIELD]:
+            # Create a channel template object
+            ch_temp = self.construct_template_from_dict(ch_dict)
+
+            id_dict[ch_temp.get_id()] = ch_temp
+            name_dict[ch_temp.get_full_name()] = ch_temp
+
+        return (
+            dict(sorted(id_dict.items())),
+            dict(sorted(name_dict.items())),
+            self.get_versions(),
+        )
+
+    def construct_template_from_dict(self, channel_dict: dict) -> ChTemplate:
+        try:
+            ch_id = channel_dict[self.ID]
+            # The below assignment also raises a ValueError if the name does not contain a '.'
+            component_name, channel_name = channel_dict[self.NAME].split(".")
+            if not component_name or not channel_name:
+                raise ValueError()
+
+            type_obj = self.parse_type(channel_dict[self.TYPE])
+        except ValueError as e:
+            raise GdsDictionaryParsingException(
+                f"Channel dictionary entry malformed, expected name of the form '<COMP_NAME>.<CH_NAME>' in : {str(channel_dict)}"
+            )
+        except KeyError as e:
+            raise GdsDictionaryParsingException(
+                f"{str(e)} key missing from Channel dictionary entry or its associated type in the dictionary: {str(channel_dict)}"
+            )
+
+        format_str = JsonLoader.preprocess_format_str(channel_dict.get(self.FMT_STR))
+
+        limit_field = channel_dict.get(self.LIMIT_FIELD)
+        limit_low = limit_field.get(self.LIMIT_LOW) if limit_field else None
+        limit_high = limit_field.get(self.LIMIT_HIGH) if limit_field else None
+        limit_low_yellow = limit_low.get(self.LIMIT_YELLOW) if limit_low else None
+        limit_low_red = limit_low.get(self.LIMIT_RED) if limit_low else None
+        limit_low_orange = limit_low.get(self.LIMIT_ORANGE) if limit_low else None
+        limit_high_yellow = limit_high.get(self.LIMIT_YELLOW) if limit_high else None
+        limit_high_red = limit_high.get(self.LIMIT_RED) if limit_high else None
+        limit_high_orange = limit_high.get(self.LIMIT_ORANGE) if limit_high else None
+
+        return ChTemplate(
+            ch_id,
+            channel_name,
+            component_name,
+            type_obj,
+            ch_fmt_str=format_str,
+            ch_desc=channel_dict.get(self.DESC),
+            low_red=limit_low_red,
+            low_orange=limit_low_orange,
+            low_yellow=limit_low_yellow,
+            high_yellow=limit_high_yellow,
+            high_orange=limit_high_orange,
+            high_red=limit_high_red,
+        )

fprime_gds/common/loaders/ch_xml_loader.py

@@ -49,15 +49,15 @@ class ChXmlLoader(XmlLoader):
             respectively and the values are ChTemplate objects
         """
         xml_tree = self.get_xml_tree(path)
-        versions = xml_tree.attrib.get("framework_version", "unknown"), xml_tree.attrib.get("project_version", "unknown")
+        versions = xml_tree.attrib.get(
+            "framework_version", "unknown"
+        ), xml_tree.attrib.get("project_version", "unknown")
 
         # Check if xml dict has channels section
         ch_section = self.get_xml_section(self.CH_SECT, xml_tree)
         if ch_section is None:
             msg = f"Xml dict did not have a {self.CH_SECT} section"
-            raise exceptions.GseControllerParsingException(
-                msg
-            )
+            raise exceptions.GseControllerParsingException(msg)
 
         id_dict = {}
         name_dict = {}
@@ -84,7 +84,7 @@ class ChXmlLoader(XmlLoader):
                 ch_desc = ch_dict[self.DESC_TAG]
 
             if self.FMT_STR_TAG in ch_dict:
-                ch_fmt_str = ch_dict[self.FMT_STR_TAG]
+                ch_fmt_str = XmlLoader.preprocess_format_str(ch_dict[self.FMT_STR_TAG])
 
             # TODO we need to convert these into numbers, is this the best
             #  way to do it?

fprime_gds/common/loaders/cmd_json_loader.py

@@ -0,0 +1,85 @@
+"""
+cmd_json_loader.py:
+
+Loads flight dictionary (JSON) and returns id and mnemonic based Python dictionaries of commands
+
+@author thomas-bc
+"""
+
+from fprime_gds.common.templates.cmd_template import CmdTemplate
+from fprime_gds.common.loaders.json_loader import JsonLoader
+from fprime_gds.common.data_types.exceptions import GdsDictionaryParsingException
+
+
+class CmdJsonLoader(JsonLoader):
+    """Class to load json based command dictionaries"""
+
+    COMMANDS_FIELD = "commands"
+
+    NAME = "name"
+    OPCODE = "opcode"
+    DESC = "annotation"
+    PARAMETERS = "formalParams"
+
+    def construct_dicts(self, _):
+        """
+         Constructs and returns python dictionaries keyed on id and name
+
+        Args:
+            _: Unused argument (inherited)
+         Returns:
+            A tuple with two command dictionaries (python type dict):
+            (id_dict, name_dict). The keys are the events' id and name fields
+            respectively and the values are CmdTemplate objects
+        """
+        id_dict = {}
+        name_dict = {}
+
+        if self.COMMANDS_FIELD not in self.json_dict:
+            raise GdsDictionaryParsingException(
+                f"Ground Dictionary missing '{self.COMMANDS_FIELD}' field: {str(self.json_file)}"
+            )
+
+        for cmd_dict in self.json_dict[self.COMMANDS_FIELD]:
+            cmd_temp = self.construct_template_from_dict(cmd_dict)
+
+            id_dict[cmd_temp.get_id()] = cmd_temp
+            name_dict[cmd_temp.get_full_name()] = cmd_temp
+
+        return (
+            dict(sorted(id_dict.items())),
+            dict(sorted(name_dict.items())),
+            self.get_versions(),
+        )
+
+    def construct_template_from_dict(self, cmd_dict: dict) -> CmdTemplate:
+        try:
+            cmd_comp, cmd_mnemonic = cmd_dict[self.NAME].split(".")
+            cmd_opcode = cmd_dict[self.OPCODE]
+            cmd_desc = cmd_dict.get(self.DESC)
+        except ValueError as e:
+            raise GdsDictionaryParsingException(
+                f"Command dictionary entry malformed, expected name of the form '<COMP_NAME>.<CMD_NAME>' in : {str(cmd_dict)}"
+            )
+        except KeyError as e:
+            raise GdsDictionaryParsingException(
+                f"{str(e)} key missing from Command dictionary entry: {str(cmd_dict)}"
+            )
+        # Parse Arguments
+        cmd_args = []
+        for param in cmd_dict.get(self.PARAMETERS, []):
+            try:
+                param_name = param["name"]
+                param_type = self.parse_type(param["type"])
+            except KeyError as e:
+                raise GdsDictionaryParsingException(
+                    f"{str(e)} key missing from Command parameter or its associated type in the dictionary: {str(param)}"
+                )
+            cmd_args.append(
+                (
+                    param_name,
+                    param.get("annotation"),
+                    param_type,
+                )
+            )
+        return CmdTemplate(cmd_opcode, cmd_mnemonic, cmd_comp, cmd_args, cmd_desc)

fprime_gds/common/loaders/dict_loader.py

@@ -93,7 +93,7 @@ class DictLoader:
         return name_dict
 
     def get_versions(self):
-        """ Get version tuple """
+        """Get version tuple"""
         return self.versions
 
     def construct_dicts(self, path):