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

fprime_gds/common/loaders/xml_loader.py

@@ -13,6 +13,7 @@ helper functions
 
 @bug No known bugs
 """
+
 import os
 
 from fprime.common.models.serialize.array_type import ArrayType
@@ -34,6 +35,7 @@ from fprime.common.models.serialize.serializable_type import SerializableType
 from fprime.common.models.serialize.string_type import StringType
 from lxml import etree
 
+from fprime_gds.common.utils.string_util import preprocess_c_style_format_str
 from fprime_gds.common.data_types import exceptions
 from fprime_gds.version import (
     MAXIMUM_SUPPORTED_FRAMEWORK_VERSION,
@@ -258,18 +260,21 @@ class XmlLoader(dict_loader.DictLoader):
                 members = []
                 for memb in memb_section:
                     name = memb.get(self.SER_MEMB_NAME_TAG)
-                    fmt_str = memb.get(self.SER_MEMB_FMT_STR_TAG)
+                    fmt_str = XmlLoader.preprocess_format_str(
+                        memb.get(self.SER_MEMB_FMT_STR_TAG)
+                    )
                     desc = memb.get(self.SER_MEMB_DESC_TAG)
                     memb_type_name = memb.get(self.SER_MEMB_TYPE_TAG)
                     memb_size = memb.get(self.SER_MEMB_SIZE_TAG)
                     type_obj = self.parse_type(memb_type_name, memb, xml_obj)
                     # memb_size is not None for member array
-                    if(memb_size is not None):
+                    if memb_size is not None:
                         type_obj = ArrayType.construct_type(
                             f"Array_{type_obj.__name__}_{memb_size}",
                             type_obj,
                             int(memb_size),
-                            fmt_str)
+                            fmt_str,
+                        )
 
                     members.append((name, type_obj, fmt_str, desc))
 
@@ -319,10 +324,14 @@ class XmlLoader(dict_loader.DictLoader):
                 # Make config
                 arr_type = arr_memb.get(self.ARR_TYPE_TAG)
                 type_obj = self.parse_type(arr_type, arr_memb, xml_obj)
-                arr_format = arr_memb.get(self.ARR_FORMAT_TAG)
+                arr_format = XmlLoader.preprocess_format_str(
+                    arr_memb.get(self.ARR_FORMAT_TAG)
+                )
                 arr_size = arr_memb.get(self.ARR_SIZE_TAG)
 
-                arr_obj = ArrayType.construct_type(type_name, type_obj, int(arr_size), arr_format)
+                arr_obj = ArrayType.construct_type(
+                    type_name, type_obj, int(arr_size), arr_format
+                )
 
                 self.array_types[type_name] = arr_obj
                 return arr_obj
@@ -372,7 +381,9 @@ class XmlLoader(dict_loader.DictLoader):
             return BoolType
         if type_name == "string":
             if self.STR_LEN_TAG not in xml_item.attrib:
-                print(f"Trying to parse string type, but found {self.STR_LEN_TAG} field")
+                print(
+                    f"Trying to parse string type, but found {self.STR_LEN_TAG} field"
+                )
                 return None
             max_length = int(xml_item.get(self.STR_LEN_TAG, 0))
             name = f"{context or ''}::{xml_item.get(self.ARG_NAME_TAG)}String"
@@ -394,6 +405,17 @@ class XmlLoader(dict_loader.DictLoader):
 
         # Abandon all hope
         msg = f"Could not find type {type_name}"
-        raise exceptions.GseControllerParsingException(
-            msg
-        )
+        raise exceptions.GseControllerParsingException(msg)
+
+    @staticmethod
+    def preprocess_format_str(format_str):
+        """Converts C-style format strings to Python-style format strings
+        For example "%x" -> "{:x}" or "%.2f" -> "{:.2f}"
+
+        Args:
+            format_str (str): C-style format string
+
+        Returns:
+            str: Python-style format string
+        """
+        return preprocess_c_style_format_str(format_str)

fprime_gds/common/pipeline/dictionaries.py

@@ -6,7 +6,9 @@ class called "Dictionaries".
 
 @author mstarch
 """
+
 import os
+from pathlib import Path
 
 import fprime_gds.common.loaders.ch_py_loader
 import fprime_gds.common.loaders.ch_xml_loader
@@ -19,6 +21,9 @@ import fprime_gds.common.loaders.cmd_xml_loader
 import fprime_gds.common.loaders.event_py_loader
 import fprime_gds.common.loaders.event_xml_loader
 import fprime_gds.common.loaders.pkt_xml_loader
+import fprime_gds.common.loaders.ch_json_loader
+import fprime_gds.common.loaders.cmd_json_loader
+import fprime_gds.common.loaders.event_json_loader
 
 
 class Dictionaries:
@@ -80,8 +85,34 @@ class Dictionaries:
             self._channel_name_dict = channel_loader.get_name_dict(
                 os.path.join(dictionary, "channels")
             )
+        elif Path(dictionary).is_file() and ".json" in Path(dictionary).suffixes:
+            # Events
+            json_event_loader = (
+                fprime_gds.common.loaders.event_json_loader.EventJsonLoader(dictionary)
+            )
+            self._event_name_dict = json_event_loader.get_name_dict(None)
+            self._event_id_dict = json_event_loader.get_id_dict(None)
+            self._versions = json_event_loader.get_versions()
+            # Commands
+            json_command_loader = (
+                fprime_gds.common.loaders.cmd_json_loader.CmdJsonLoader(dictionary)
+            )
+            self._command_name_dict = json_command_loader.get_name_dict(None)
+            self._command_id_dict = json_command_loader.get_id_dict(None)
+            assert (
+                self._versions == json_command_loader.get_versions()
+            ), "Version mismatch while loading"
+            # Channels
+            json_channel_loader = fprime_gds.common.loaders.ch_json_loader.ChJsonLoader(
+                dictionary
+            )
+            self._channel_name_dict = json_channel_loader.get_name_dict(None)
+            self._channel_id_dict = json_channel_loader.get_id_dict(None)
+            assert (
+                self._versions == json_channel_loader.get_versions()
+            ), "Version mismatch while loading"
         # XML dictionaries
-        elif os.path.isfile(dictionary):
+        elif Path(dictionary).is_file():
             # Events
             event_loader = fprime_gds.common.loaders.event_xml_loader.EventXmlLoader()
             self._event_id_dict = event_loader.get_id_dict(dictionary)
@@ -91,12 +122,16 @@ class Dictionaries:
             command_loader = fprime_gds.common.loaders.cmd_xml_loader.CmdXmlLoader()
             self._command_id_dict = command_loader.get_id_dict(dictionary)
             self._command_name_dict = command_loader.get_name_dict(dictionary)
-            assert self._versions == command_loader.get_versions(), "Version mismatch while loading"
+            assert (
+                self._versions == command_loader.get_versions()
+            ), "Version mismatch while loading"
             # Channels
             channel_loader = fprime_gds.common.loaders.ch_xml_loader.ChXmlLoader()
             self._channel_id_dict = channel_loader.get_id_dict(dictionary)
             self._channel_name_dict = channel_loader.get_name_dict(dictionary)
-            assert self._versions == channel_loader.get_versions(), "Version mismatch while loading"
+            assert (
+                self._versions == channel_loader.get_versions()
+            ), "Version mismatch while loading"
         else:
             msg = f"[ERROR] Dictionary '{dictionary}' does not exist."
             raise Exception(msg)

fprime_gds/common/tools/seqgen.py

@@ -22,7 +22,7 @@ from fprime.common.models.serialize.time_type import TimeBase, TimeType
 from fprime_gds.common.data_types import exceptions as gseExceptions
 from fprime_gds.common.data_types.cmd_data import CmdData, CommandArgumentsException
 from fprime_gds.common.encoders.seq_writer import SeqBinaryWriter
-from fprime_gds.common.loaders.cmd_xml_loader import CmdXmlLoader
+from fprime_gds.common.loaders.cmd_json_loader import CmdJsonLoader
 from fprime_gds.common.parsers.seq_file_parser import SeqFileParser
 
 __author__ = "Tim Canham"
@@ -56,9 +56,9 @@ def generateSequence(inputFile, outputFile, dictionary, timebase, cont=False):
         raise SeqGenException(msg)
 
     # Check the user environment:
-    cmd_xml_dict = CmdXmlLoader()
+    cmd_json_dict = CmdJsonLoader(dictionary)
     try:
-        (cmd_id_dict, cmd_name_dict, versions) = cmd_xml_dict.construct_dicts(
+        (cmd_id_dict, cmd_name_dict, versions) = cmd_json_dict.construct_dicts(
             dictionary
         )
     except gseExceptions.GseControllerUndefinedFileException:
@@ -153,7 +153,7 @@ def main():
         action="store",
         type=str,
         required=True,
-        help="Dictionary file name",
+        help="JSON Dictionary file name",
     )
     parser.add_argument(
         "-t",

fprime_gds/common/utils/string_util.py

@@ -9,12 +9,51 @@ Note: This function has an identical copy in fprime-gds
 
 import logging
 import re
+from typing import Any, Union
 
 LOGGER = logging.getLogger("string_util_logger")
 
 
-def format_string_template(format_str, given_values):
-    r"""
+def format_string_template(template: str, value: Union[tuple, list, Any]) -> str:
+    """
+    Function to format a string template with values. This function is a simple wrapper around the
+    format function. It accepts a tuple, list, or single value and passes it to the format function
+
+    Args:
+        template (str): String template to be formatted
+        value (Union[tuple, list, Any]): Value(s) to be inserted into the template
+
+    Returns:
+        str: Formatted string
+    """
+    if not isinstance(value, (tuple, list)):
+        value = (value,)
+    try:
+        return template.format(*value)
+    except (IndexError, ValueError) as e:
+        LOGGER.error(
+            f"Error formatting string template: {template} with value: {str(value)}"
+        )
+        raise e
+
+
+def preprocess_fpp_format_str(format_str: str) -> str:
+    """Preprocess a FPP-style format string and convert it to Python format string
+    FPP format strings are documented https://nasa.github.io/fpp/fpp-spec.html#Format-Strings
+    For example "{x}" -> "{:x}" or "{.2f}" -> "{:.2f}"
+
+    Args:
+        format_str (str): FPP-style format string
+
+    Returns:
+        str: Python-style format string
+    """
+    pattern = r"{(\d*\.?\d*[cdxoefgCDXOEFG])}"
+    return re.sub(pattern, r"{:\1}", format_str)
+
+
+def preprocess_c_style_format_str(format_str: str) -> str:
+    """
     Function to convert C-string style to python format
     without using python interpolation
     Considered the following format for C-string:
@@ -31,20 +70,26 @@ def format_string_template(format_str, given_values):
     This function will keep the flags, width, and .precision of C-string
     template.
 
-    It will keep f, d, x, o, and e flags and remove all other types.
-    Other types will be duck-typed by python
-    interpreter.
+    It will keep f, x, o, and e flags and remove all other types.
+    Other types will be duck-typed by python interpreter.
 
     lengths will also be removed since they are not meaningful to Python interpreter.
     `See: https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting`
-
     `Regex Source: https://www.regexlib.com/REDetails.aspx?regexp_id=3363`
+
+    For example "%x" -> "{:x}" or "%.2f" -> "{:.2f}"
+
+    Args:
+        format_str (str): C-style format string
+
+    Returns:
+        str: Python-style format string
     """
 
-    def convert(match_obj, ignore_int):
+    def convert(match_obj: re.Match):
         if match_obj.group() is None:
             return match_obj
-        flags, width, precision, length, conversion_type = match_obj.groups()
+        flags, width, precision, _, conversion_type = match_obj.groups()
         format_template = ""
         if flags:
             format_template += f"{flags}"
@@ -53,66 +98,13 @@ def format_string_template(format_str, given_values):
         if precision:
             format_template += f"{precision}"
 
-        if conversion_type:
-            if any(
-                [
-                    str(conversion_type).lower() == "f",
-                    str(conversion_type).lower() == "x",
-                    str(conversion_type).lower() == "o",
-                    str(conversion_type).lower() == "e",
-                ]
-            ):
-                format_template += f"{conversion_type}"
-            elif all([not ignore_int, str(conversion_type).lower() == "d"]):
-                format_template += f"{conversion_type}"
+        if conversion_type and str(conversion_type).lower() in {"f", "x", "o", "e"}:
+            format_template += f"{conversion_type}"
 
         return "{}" if format_template == "" else "{:" + format_template + "}"
 
-    def convert_include_all(match_obj):
-        return convert(match_obj, ignore_int=False)
-
-    def convert_ignore_int(match_obj):
-        return convert(match_obj, ignore_int=True)
-
-    # Allowing single, list and tuple inputs
-    if not isinstance(given_values, (list, tuple)):
-        values = (given_values,)
-    elif isinstance(given_values, list):
-        values = tuple(given_values)
-    else:
-        values = given_values
-
-    pattern = r"(?<!%)(?:%%)*%([\-\+0\ \#])?(\d+|\*)?(\.\*|\.\d+)?([hLIw]|l{1,2}|I32|I64)?([cCdiouxXeEfgGaAnpsSZ])"
+    pattern = r"(?<!%)(?:%%)*%([\-\+0\ \#])?(\d+|\*)?(\.\*|\.\d+)?([hLIw]|l{1,2}|I32|I64)?([cCdiouxXeEfgGaAnpsSZ])"  # NOSONAR
 
     match = re.compile(pattern)
 
-    # First try to include all types
-    try:
-        formatted_str = re.sub(match, convert_include_all, format_str)
-        result = formatted_str.format(*values)
-        result = result.replace("%%", "%")
-        return result
-    except Exception:
-        msg = "Value and format string do not match. "
-        msg += " Will ignore integer flags `d` in string template. "
-        msg += f"values: {values}. "
-        msg += f"format_str: {format_str}. "
-        msg += f"given_values: {given_values}"
-        LOGGER.warning(msg)
-
-    # Second try by not including %d.
-    # This will resolve failing ENUMs with %d
-    # but will fail on other types.
-    try:
-        formatted_str = re.sub(match, convert_ignore_int, format_str)
-        result = formatted_str.format(*values)
-        result = result.replace("%%", "%")
-        return result
-    except ValueError as e:
-        msg = "Value and format string do not match. "
-        msg += f"values: {values}. "
-        msg += f"format_str: {format_str}. "
-        msg += f"given_values: {given_values}"
-        msg += f"Err Msg: {str(e)}\n"
-        LOGGER.error(msg)
-        raise ValueError
+    return re.sub(match, convert, format_str).replace("%%", "%")

fprime_gds/common/zmq_transport.py

@@ -130,11 +130,13 @@ class ZmqWrapper(object):
 
     def disconnect_outgoing(self):
         """Disconnect the ZeroMQ sockets"""
-        self.zmq_socket_outgoing.close()
+        if self.zmq_socket_outgoing is not None:
+            self.zmq_socket_outgoing.close()
 
     def disconnect_incoming(self):
         """Disconnect the ZeroMQ sockets"""
-        self.zmq_socket_incoming.close()
+        if self.zmq_socket_incoming is not None:
+            self.zmq_socket_incoming.close()
 
     def terminate(self):
         """Terminate the ZeroMQ context"""

fprime_gds/executables/cli.py

@@ -31,21 +31,8 @@ from fprime_gds.common.utils.config_manager import ConfigManager
 from fprime_gds.executables.utils import find_app, find_dict, get_artifacts_root
 from fprime_gds.plugin.definitions import PluginType
 from fprime_gds.plugin.system import Plugins
+from fprime_gds.common.zmq_transport import ZmqClient
 
-# Optional import: ZeroMQ. Requires package: pyzmq
-try:
-    import zmq
-
-    from fprime_gds.common.zmq_transport import ZmqClient
-except ImportError:
-    zmq = None
-    ZmqClient = None
-
-# Optional import: Serial Adapter. Requires package: SerialAdapter
-try:
-    from fprime_gds.common.communication.adapters.uart import SerialAdapter
-except ImportError:
-    SerialAdapter = None
 
 GUIS = ["none", "html"]
 
@@ -197,7 +184,6 @@ class ParserBase(ABC):
             sys.exit(-1)
         except Exception as exc:
             print(f"[ERROR] {exc}", file=sys.stderr)
-            raise
             sys.exit(-1)
         return args_ns, parser
 
@@ -578,40 +564,37 @@ class MiddleWareParser(ParserBase):
 
     def get_arguments(self) -> Dict[Tuple[str, ...], Dict[str, Any]]:
         """Return arguments necessary to run a and connect to the GDS middleware"""
-        # May use ZMQ transportation layer if zmq package is available
-        zmq_arguments = {}
-        if zmq is not None and ZmqClient is not None:
-            zmq_arguments = {
-                ("--zmq",): {
-                    "dest": "zmq",
-                    "action": "store_true",
-                    "help": "Switch to using the ZMQ transportation layer",
-                    "default": False,
-                },
-                ("--zmq-transport",): {
-                    "dest": "zmq_transport",
-                    "nargs": 2,
-                    "help": "Pair of URls used with --zmq to setup ZeroMQ transportation [default: %(default)s]",
-                    "default": [
-                        "ipc:///tmp/fprime-server-in",
-                        "ipc:///tmp/fprime-server-out",
-                    ],
-                    "metavar": ("serverInUrl", "serverOutUrl"),
-                },
-            }
+        zmq_arguments = {
+            ("--no-zmq",): {
+                "dest": "zmq",
+                "action": "store_false",
+                "help": "Disable ZMQ transportation layer, falling back to TCP socket server.",
+                "default": True,
+            },
+            ("--zmq-transport",): {
+                "dest": "zmq_transport",
+                "nargs": 2,
+                "help": "Pair of URls used with --zmq to setup ZeroMQ transportation [default: %(default)s]",
+                "default": [
+                    "ipc:///tmp/fprime-server-in",
+                    "ipc:///tmp/fprime-server-out",
+                ],
+                "metavar": ("serverInUrl", "serverOutUrl"),
+            },
+        }
         tts_arguments = {
             ("--tts-port",): {
                 "dest": "tts_port",
                 "action": "store",
                 "type": int,
-                "help": "Set the threaded TCP socket server port [default: %(default)s]",
+                "help": "Set the threaded TCP socket server port when ZMQ is not used [default: %(default)s]",
                 "default": 50050,
             },
             ("--tts-addr",): {
                 "dest": "tts_addr",
                 "action": "store",
                 "type": str,
-                "help": "Set the threaded TCP socket server address [default: %(default)s]",
+                "help": "Set the threaded TCP socket server address when ZMQ is not used [default: %(default)s]",
                 "default": "0.0.0.0",
             },
         }
@@ -626,7 +609,6 @@ class MiddleWareParser(ParserBase):
         :return: args namespace
         """
         is_client = kwargs.get("client", False)
-        args.zmq = getattr(args, "zmq", False)
         tts_connection_address = (
             args.tts_addr.replace("0.0.0.0", "127.0.0.1")
             if is_client

fprime_gds/executables/comm.py

@@ -19,20 +19,16 @@ Note: assuming the module containing the ground adapter has been imported, then
 import logging
 import signal
 import sys
-
 from pathlib import Path
 
 # Required adapters built on standard tools
-try:
-    from fprime_gds.common.zmq_transport import ZmqGround
-except ImportError:
-    ZmqGround = None
 import fprime_gds.common.communication.adapters.base
 import fprime_gds.common.communication.adapters.ip
 import fprime_gds.common.communication.ground
 import fprime_gds.common.logger
 import fprime_gds.executables.cli
 from fprime_gds.common.communication.updown import Downlinker, Uplinker
+from fprime_gds.common.zmq_transport import ZmqGround
 
 # Uses non-standard PIP package pyserial, so test the waters before getting a hard-import crash
 try:
@@ -68,11 +64,8 @@ def main():
         sys.exit(-1)
 
     # Create the handling components for either side of this script, adapter for hardware, and ground for the GDS side
-    if args.zmq and ZmqGround is None:
-        print("[ERROR] ZeroMQ is not available. Install pyzmq.", file=sys.stderr)
-        sys.exit(-1)
-    elif args.zmq:
-        ground = fprime_gds.common.zmq_transport.ZmqGround(args.zmq_transport)
+    if args.zmq:
+        ground = ZmqGround(args.zmq_transport)
     else:
         ground = fprime_gds.common.communication.ground.TCPGround(
             args.tts_addr, args.tts_port