fprime-gds 3.4.2__tar.gz → 3.4.4a1__tar.gz

{fprime-gds-3.4.2 → fprime-gds-3.4.4a1}/.github/actions/spelling/excludes.txt

@@ -45,3 +45,4 @@ ignore$
 \.ico$
 pyproject.toml
 setup.py
+dictionary.xml

{fprime-gds-3.4.2 → fprime-gds-3.4.4a1}/.github/actions/spelling/expect.txt

@@ -277,6 +277,8 @@ hidecallergraph
 hidecallgraph
 hideinitializer
 hlp
+Hookimpl
+hookspec
 hostname
 hpaulson
 hpp
@@ -313,6 +315,7 @@ ints
 ip
 ipc
 ipp
+isabstract
 isalnum
 isclass
 isdir

{fprime-gds-3.4.2 → fprime-gds-3.4.4a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fprime-gds
-Version: 3.4.2
+Version: 3.4.4a1
 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: 
@@ -234,7 +234,7 @@ Requires-Dist: pyzmq>=24.0.1
 Requires-Dist: pexpect>=4.8.0
 Requires-Dist: pytest>=6.2.4
 Requires-Dist: flask_restful>=0.3.8
-Requires-Dist: fprime-tools>=3.1.2a1
+Requires-Dist: fprime-tools>=3.4.3
 Requires-Dist: argcomplete>=1.12.3
 Requires-Dist: Jinja2>=2.11.3
 Requires-Dist: openpyxl>=3.0.10

{fprime-gds-3.4.2 → fprime-gds-3.4.4a1}/pyproject.toml

@@ -37,7 +37,7 @@ dependencies = [
     "pexpect>=4.8.0",
     "pytest>=6.2.4",
     "flask_restful>=0.3.8",
-    "fprime-tools>=3.1.2a1",
+    "fprime-tools>=3.4.3",
     "argcomplete>=1.12.3",
     "Jinja2>=2.11.3",
     "openpyxl>=3.0.10",
@@ -85,3 +85,7 @@ fprime_test_api = "fprime_gds.common.testing_fw.pytest_integration"
 # - https://setuptools.pypa.io/en/latest/userguide/pyproject_config.html
 # - https://setuptools.pypa.io/en/latest/userguide/package_discovery.html#src-layout
 ####
+[tool.pytest.ini_options]
+markers =[
+  "gds_cli"
+]

fprime-gds-3.4.4a1/src/fprime_gds/common/communication/adapters/base.py

@@ -0,0 +1,89 @@
+"""
+base.py:
+
+This file specifies the base-adapter for the F prime comm-layer. This class defines the basic methods needed to interact
+with various wire formats as they are supported by the F prime comm-layer. This file defines a single abstract base
+class representing the core features of the adapter class that must be implemented by every implementation of the
+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):
+    """
+    Base adapter for adapting the communications layer. This essentially breaks down to providing the ability to read
+    data from, and write to the necessary wire-format. The children of this class must at least implement the 'read' and
+    'write' functions to ensure that data can be read and written. 'open' and 'close' are also provided as a helper to
+    the subclass implementer to place resource initialization and release code, however; these implementations are
+    defaulted not overridden.
+    """
+
+    def open(self):
+        """Null default implementation"""
+
+    def close(self):
+        """Null default implementation"""
+
+    @abc.abstractmethod
+    def read(self, timeout=0.500):
+        """
+        Read from the interface. Must be overridden by the child adapter. Throw no fatal errors, reconnect instead. This
+        call is expected to block waiting on incoming data.
+
+        :param size: maximum size of data to read before breaking
+        :param timeout: timeout for the block, default: 0.500 (500ms) as blocking w/o timeout may be uninterruptible
+        :return: byte array of data, or b'' if no data was read
+        """
+
+    @abc.abstractmethod
+    def write(self, frame):
+        """
+        Write to the interface. Must be overridden by the child adapter. Throw no fatal errors, reconnect instead.
+
+        :param frame: framed data to uplink
+        :return: True if data sent through adapter, False otherwise
+        """
+
+    @classmethod
+    @gds_plugin_specification
+    def register_communication_plugin(cls) -> Type["BaseAdapter"]:
+        """Register a communications adapter
+
+        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.
+
+        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:
+            BaseAdapter subclass
+        """
+        raise NotImplementedError()
+
+
+class NoneAdapter(BaseAdapter):
+    """ None adapter used to turn off the comm script """
+
+    @classmethod
+    def get_name(cls):
+        """ Get name of the non-adapter """
+        return "none"
+
+    def read(self, timeout=0.500):
+        """ Raise exception if this is called"""
+        raise NotImplementedError()
+
+    def write(self, frame):
+        """ Raise exception if this is called"""
+        raise NotImplementedError()
+
+    @classmethod
+    @gds_plugin_implementation
+    def register_communication_plugin(cls):
+        """ Register this as a plugin """
+        return cls

{fprime-gds-3.4.2 → fprime-gds-3.4.4a1}/src/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-3.4.2 → fprime-gds-3.4.4a1}/src/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-3.4.2 → fprime-gds-3.4.4a1}/src/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-3.4.2 → fprime-gds-3.4.4a1}/src/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-3.4.2 → fprime-gds-3.4.4a1}/src/fprime_gds/common/loaders/xml_loader.py

@@ -49,6 +49,7 @@ class XmlLoader(dict_loader.DictLoader):
 
     ENUM_SECT = "enums"
     ENUM_TYPE_TAG = "type"
+    ENUM_SERIALIZE_TYPE_TAG = "serialize_type"
     ENUM_ELEM_NAME_TAG = "name"
     ENUM_ELEM_VAL_TAG = "value"
     ENUM_ELEM_DESC_TAG = "description"
@@ -202,6 +203,9 @@ class XmlLoader(dict_loader.DictLoader):
         for enum in enum_section:
             # Check enum name
             if enum.get(self.ENUM_TYPE_TAG) == enum_name:
+                # Get serialize/representation type, if present
+                serialize_type = enum.get(self.ENUM_SERIALIZE_TYPE_TAG, "I32")
+
                 # Go through all possible values of the enum
                 members = {}
                 for item in enum:
@@ -209,7 +213,7 @@ class XmlLoader(dict_loader.DictLoader):
                     item_val = int(item.get(self.ENUM_ELEM_VAL_TAG))
                     members[item_name] = item_val
 
-                enum_obj = EnumType.construct_type(enum_name, members)
+                enum_obj = EnumType.construct_type(enum_name, members, serialize_type)
 
                 self.enums[enum_name] = enum_obj
                 return enum_obj

{fprime-gds-3.4.2 → fprime-gds-3.4.4a1}/src/fprime_gds/common/zmq_transport.py

@@ -9,6 +9,7 @@ replace the ThreadedTcpServer for several reasons as described below.
 
 @author lestarch
 """
+
 import logging
 import struct
 from typing import Tuple
@@ -24,6 +25,7 @@ from fprime_gds.common.transport import (
 
 LOGGER = logging.getLogger("transport")
 
+
 class ZmqWrapper(object):
     """Handler for ZMQ functions for use in other objects"""
 
@@ -50,7 +52,9 @@ class ZmqWrapper(object):
             sub_topic: subscription topic used to filter incoming messages
             pub_topic: publication topic supplied for remote subscription filters
         """
-        assert len(transport_url) == 2, f"Must supply a pair of URLs for ZeroMQ not '{transport_url}'"
+        assert (
+            len(transport_url) == 2
+        ), f"Must supply a pair of URLs for ZeroMQ not '{transport_url}'"
         self.pub_topic = pub_topic
         self.sub_topic = sub_topic
         self.transport_url = transport_url
@@ -78,8 +82,12 @@ class ZmqWrapper(object):
         The connection is made using self.transport_url, and as such, this must be configured before running. This is
         intended to be called on the sending thread.
         """
-        assert self.transport_url is not None and len(self.transport_url) == 2, "Must configure before connecting"
-        assert self.zmq_socket_outgoing is None, "Cannot connect outgoing multiple times"
+        assert (
+            self.transport_url is not None and len(self.transport_url) == 2
+        ), "Must configure before connecting"
+        assert (
+            self.zmq_socket_outgoing is None
+        ), "Cannot connect outgoing multiple times"
         assert self.pub_topic is not None, "Must configure sockets before connecting"
         self.zmq_socket_outgoing = self.context.socket(zmq.PUB)
         self.zmq_socket_outgoing.setsockopt(zmq.SNDHWM, 0)
@@ -93,7 +101,7 @@ class ZmqWrapper(object):
             self.zmq_socket_outgoing.connect(self.transport_url[0])
 
     def connect_incoming(self):
-        """ Sets up a ZeroMQ connection for incoming data
+        """Sets up a ZeroMQ connection for incoming data
 
         ZeroMQ allows multiple connections to a single endpoint. This only affects incoming connections as sockets must
         be created on their owning threads. This will connect the ZeroMQ topology and if self.server is set, will bind
@@ -102,8 +110,12 @@ class ZmqWrapper(object):
         The connection is made using self.transport_url, and as such, this must be configured before running. This is
         intended to be called on the receiving thread.
         """
-        assert self.transport_url is not None and len(self.transport_url) == 2, "Must configure before connecting"
-        assert self.zmq_socket_incoming is None, "Cannot connect incoming multiple times"
+        assert (
+            self.transport_url is not None and len(self.transport_url) == 2
+        ), "Must configure before connecting"
+        assert (
+            self.zmq_socket_incoming is None
+        ), "Cannot connect incoming multiple times"
         assert self.sub_topic is not None, "Must configure sockets before connecting"
         self.zmq_socket_incoming = self.context.socket(zmq.SUB)
         self.zmq_socket_incoming.setsockopt(zmq.RCVHWM, 0)
@@ -125,7 +137,7 @@ class ZmqWrapper(object):
         self.zmq_socket_incoming.close()
 
     def terminate(self):
-        """ Terminate the ZeroMQ context"""
+        """Terminate the ZeroMQ context"""
         self.context.term()
 
     def recv(self, timeout=None):
@@ -162,11 +174,14 @@ class ZmqClient(ThreadedTransportClient):
         self.zmq = ZmqWrapper()
 
     def connect(
-        self, transport_url: Tuple[str], sub_routing: RoutingTag, pub_routing: RoutingTag
+        self,
+        transport_url: Tuple[str],
+        sub_routing: RoutingTag,
+        pub_routing: RoutingTag,
     ):
         """Connects to the ZeroMQ network"""
         self.zmq.configure(transport_url, sub_routing.value, pub_routing.value)
-        self.zmq.connect_outgoing() # Outgoing socket, for clients, exists on the current thread
+        self.zmq.connect_outgoing()  # Outgoing socket, for clients, exists on the current thread
         super().connect(transport_url, sub_routing, pub_routing)
 
     def disconnect(self):
@@ -176,16 +191,18 @@ class ZmqClient(ThreadedTransportClient):
 
     def send(self, data):
         """Send data via ZeroMQ"""
-        if data[:4] == b'ZZZZ':
+        if data[:4] == b"ZZZZ":
             data = data[4:]
-        self.zmq.send(data)  # Must strip out ZZZZ as that is a ThreadedTcpServer only property
+        self.zmq.send(
+            data
+        )  # Must strip out ZZZZ as that is a ThreadedTcpServer only property
 
     def recv(self, timeout=None):
         """Receives data from ZeroMQ"""
         return self.zmq.recv(timeout)
 
     def recv_thread(self):
-        """ Overrides the recv_thread method
+        """Overrides the recv_thread method
 
         Overrides the recv_thread method of the superclass such that the ZeroMQ socket may be created/destroyed
         before/after the main recv loop.
@@ -203,11 +220,11 @@ class ZmqGround(GroundHandler):
     to the display and processing layer(s). This effectively acts as the "FSW" side of that interface as it
     frames/deframes packets heading to that layer.
 
-    Since there is likely only one communications client to the FSW users should call make_server() after construction
+    Since there is likely only one communications client to the FSW users should instantiate with server=True
     to ensure that it binds to resources for the network. This is not forced in case of multiple FSW connections.
     """
 
-    def __init__(self, transport_url):
+    def __init__(self, transport_url, server=True):
         """Initialize this interface with the transport_url needed to connect
 
         Args:
@@ -217,6 +234,8 @@ class ZmqGround(GroundHandler):
         self.zmq = ZmqWrapper()
         self.transport_url = transport_url
         self.timeout = 10
+        if server:
+            self.zmq.make_server()
 
     def open(self):
         """Open this ground interface. Delegates to the connect method
@@ -242,10 +261,6 @@ class ZmqGround(GroundHandler):
         self.zmq.disconnect_outgoing()
         self.zmq.terminate()
 
-    def make_server(self):
-        """Makes it into a server"""
-        self.zmq.make_server()
-
     def receive_all(self):
         """Receive all available packets