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

fprime_gds/common/loaders/event_json_loader.py

@@ -0,0 +1,108 @@
+"""
+event_json_loader.py:
+
+Loads flight dictionary (JSON) and returns id and mnemonic based Python dictionaries of events
+
+@author thomas-bc
+"""
+
+from fprime_gds.common.templates.event_template import EventTemplate
+from fprime_gds.common.utils.event_severity import EventSeverity
+from fprime_gds.common.loaders.json_loader import JsonLoader
+from fprime_gds.common.data_types.exceptions import GdsDictionaryParsingException
+
+
+class EventJsonLoader(JsonLoader):
+    """Class to load json based event dictionaries"""
+
+    EVENTS_FIELD = "events"
+
+    NAME = "name"
+    ID = "id"
+    SEVERITY = "severity"
+    FMT_STR = "format"
+    DESC = "annotation"
+    PARAMETERS = "formalParams"
+
+    def construct_dicts(self, _):
+        """
+        Constructs and returns python dictionaries keyed on id and name
+
+        This function should not be called directly, instead, use
+        get_id_dict(path) and get_name_dict(path)
+
+        Args:
+            _: Unused argument (inherited)
+
+        Returns:
+            A tuple with two event dictionaries (python type dict):
+            (id_dict, name_dict). The keys are the events' id and name fields
+            respectively and the values are ChTemplate objects
+        """
+        id_dict = {}
+        name_dict = {}
+
+        if self.EVENTS_FIELD not in self.json_dict:
+            raise GdsDictionaryParsingException(
+                f"Ground Dictionary missing '{self.EVENTS_FIELD}' field: {str(self.json_file)}"
+            )
+
+        for event_dict in self.json_dict[self.EVENTS_FIELD]:
+            event_temp = self.construct_template_from_dict(event_dict)
+
+            id_dict[event_temp.get_id()] = event_temp
+            name_dict[event_temp.get_full_name()] = event_temp
+
+        return (
+            dict(sorted(id_dict.items())),
+            dict(sorted(name_dict.items())),
+            self.get_versions(),
+        )
+
+    def construct_template_from_dict(self, event_dict: dict):
+        try:
+            event_comp, event_name = event_dict[self.NAME].split(".")
+            event_id = event_dict[self.ID]
+            event_severity = EventSeverity[event_dict[self.SEVERITY]]
+        except ValueError as e:
+            raise GdsDictionaryParsingException(
+                f"Event dictionary entry malformed, expected name of the form '<COMP_NAME>.<EVENT_NAME>' in : {str(event_dict)}"
+            )
+        except KeyError as e:
+            raise GdsDictionaryParsingException(
+                f"{str(e)} key missing from Event dictionary entry: {str(event_dict)}"
+            )
+
+        event_fmt_str = JsonLoader.preprocess_format_str(
+            event_dict.get(self.FMT_STR, "")
+        )
+
+        event_desc = event_dict.get(self.DESC)
+
+        # Parse arguments
+        event_args = []
+        for arg in event_dict.get(self.PARAMETERS, []):
+            try:
+                arg_name = arg["name"]
+                arg_type = self.parse_type(arg["type"])
+            except KeyError as e:
+                raise GdsDictionaryParsingException(
+                    f"{str(e)} key missing from Event parameter or its associated type in the dictionary: {str(arg)}"
+                )
+            event_args.append(
+                (
+                    arg_name,
+                    arg.get("annotation"),
+                    arg_type,
+                )
+            )
+
+        return EventTemplate(
+            event_id,
+            event_name,
+            event_comp,
+            event_args,
+            event_severity,
+            event_fmt_str,
+            event_desc,
+        )

fprime_gds/common/loaders/event_xml_loader.py

@@ -43,15 +43,15 @@ class EventXmlLoader(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 events section
         event_section = self.get_xml_section(self.EVENT_SECT, xml_tree)
         if event_section is None:
             msg = f"Xml dict did not have a {self.EVENT_SECT} section"
-            raise exceptions.GseControllerParsingException(
-                msg
-            )
+            raise exceptions.GseControllerParsingException(msg)
 
         id_dict = {}
         name_dict = {}
@@ -63,14 +63,18 @@ class EventXmlLoader(XmlLoader):
             event_name = event_dict[self.NAME_TAG]
             event_id = int(event_dict[self.ID_TAG], base=16)
             event_severity = EventSeverity[event_dict[self.SEVERITY_TAG]]
-            event_fmt_str = event_dict[self.FMT_STR_TAG]
+            event_fmt_str = XmlLoader.preprocess_format_str(
+                event_dict[self.FMT_STR_TAG]
+            )
 
             event_desc = None
             if self.DESC_TAG in event_dict:
                 event_desc = event_dict[self.DESC_TAG]
 
             # Parse arguments
-            args = self.get_args_list(event, xml_tree, f"{ event_comp }::{ event_name }")
+            args = self.get_args_list(
+                event, xml_tree, f"{ event_comp }::{ event_name }"
+            )
 
             event_temp = EventTemplate(
                 event_id,

fprime_gds/common/loaders/json_loader.py

@@ -0,0 +1,222 @@
+"""
+json_loader.py:
+
+Base class for all loaders that load dictionaries from json dictionaries
+
+@author thomas-bc
+"""
+
+import json
+from typing import Optional
+
+from fprime.common.models.serialize.array_type import ArrayType
+from fprime.common.models.serialize.bool_type import BoolType
+from fprime.common.models.serialize.enum_type import EnumType
+import fprime.common.models.serialize.numerical_types as numerical_types
+from fprime.common.models.serialize.serializable_type import SerializableType
+from fprime.common.models.serialize.string_type import StringType
+from fprime.common.models.serialize.type_base import BaseType
+
+from fprime_gds.common.utils.string_util import preprocess_fpp_format_str
+from fprime_gds.common.loaders import dict_loader
+from fprime_gds.common.data_types.exceptions import GdsDictionaryParsingException
+
+
+PRIMITIVE_TYPE_MAP = {
+    "I8": numerical_types.I8Type,
+    "I16": numerical_types.I16Type,
+    "I32": numerical_types.I32Type,
+    "I64": numerical_types.I64Type,
+    "U8": numerical_types.U8Type,
+    "U16": numerical_types.U16Type,
+    "U32": numerical_types.U32Type,
+    "U64": numerical_types.U64Type,
+    "F32": numerical_types.F32Type,
+    "F64": numerical_types.F64Type,
+    "bool": BoolType,
+}
+
+
+class JsonLoader(dict_loader.DictLoader):
+    """Class to help load JSON dictionaries"""
+
+    # Cache parsed type objects at the class level so they can be reused across subclasses
+    parsed_types: dict = {}
+
+    def __init__(self, json_file: str):
+        """
+        Constructor
+
+        Returns:
+            An initialized loader object
+        """
+        super().__init__()
+        self.json_file = json_file
+        with open(json_file, "r") as f:
+            self.json_dict = json.load(f)
+
+    def get_versions(self):
+        """
+        Get the framework and project versions of the dictionary
+
+        Returns:
+            A tuple of the framework and project versions
+        """
+        if "metadata" not in self.json_dict:
+            raise GdsDictionaryParsingException(
+                f"Dictionary has no metadata field: {self.json_file}"
+            )
+        return (
+            self.json_dict["metadata"].get("frameworkVersion", "unknown"),
+            self.json_dict["metadata"].get("projectVersion", "unknown"),
+        )
+
+    def parse_type(self, type_dict: dict) -> BaseType:
+        type_name: str = type_dict.get("name", None)
+
+        if type_name is None:
+            raise GdsDictionaryParsingException(
+                f"Dictionary entry has no `name` field: {str(type_dict)}"
+            )
+
+        if type_name in PRIMITIVE_TYPE_MAP:
+            return PRIMITIVE_TYPE_MAP[type_name]
+
+        if type_name == "string":
+            return StringType.construct_type(
+                f'String_{type_dict["size"]}', type_dict["size"]
+            )
+
+        # Check if type has already been parsed
+        if type_name in self.parsed_types:
+            return self.parsed_types[type_name]
+
+        # Parse new enum/array/serializable types
+        qualified_type = None
+        for type_def in self.json_dict.get("typeDefinitions", []):
+            if type_name == type_def.get("qualifiedName"):
+                qualified_type = type_def
+                break
+        else:
+            raise GdsDictionaryParsingException(
+                f"Dictionary type name has no corresponding type definition: {type_name}"
+            )
+
+        if qualified_type.get("kind") == "array":
+            return self.construct_array_type(type_name, qualified_type)
+
+        if qualified_type.get("kind") == "enum":
+            return self.construct_enum_type(type_name, qualified_type)
+
+        if qualified_type.get("kind") == "struct":
+            return self.construct_serializable_type(type_name, qualified_type)
+
+        raise GdsDictionaryParsingException(
+            f"Dictionary entry has unknown type {str(type_dict)}"
+        )
+
+    def construct_enum_type(self, type_name: str, qualified_type: dict) -> EnumType:
+        """
+        Constructs an EnumType object of the given type name and qualified type dictionary.
+        Caches the constructed EnumType object in the parsed_types dictionary.
+
+        Args:
+            type_name (str): The name of the enum type.
+            qualified_type (dict): A dictionary containing the qualified type information.
+
+        Returns:
+            EnumType: The constructed EnumType object.
+
+        """
+        enum_dict = {}
+        for member in qualified_type.get("enumeratedConstants"):
+            enum_dict[member["name"]] = member.get("value")
+        enum_type = EnumType.construct_type(
+            type_name,
+            enum_dict,
+            qualified_type["representationType"].get("name"),
+        )
+        self.parsed_types[type_name] = enum_type
+        return enum_type
+
+    def construct_array_type(self, type_name: str, qualified_type: dict) -> ArrayType:
+        """
+        Constructs an ArrayType object based on the given type name and qualified type dictionary.
+        Caches the constructed ArrayType object in the parsed_types dictionary.
+
+        Args:
+            type_name (str): The name of the array type.
+            qualified_type (dict): The qualified type dictionary containing information about the array type.
+
+        Returns:
+            ArrayType: The constructed ArrayType object.
+
+        """
+        array_type = ArrayType.construct_type(
+            type_name,
+            self.parse_type(qualified_type.get("elementType")),
+            qualified_type.get("size"),
+            JsonLoader.preprocess_format_str(
+                qualified_type["elementType"].get("format", "{}")
+            ),
+        )
+        self.parsed_types[type_name] = array_type
+        return array_type
+
+    def construct_serializable_type(
+        self, type_name: str, qualified_type: dict
+    ) -> SerializableType:
+        """
+        Constructs a SerializableType based on the given type name and qualified type dictionary.
+        Caches the constructed SerializableType object in the parsed_types dictionary.
+
+        Args:
+            type_name (str): The name of the serializable type.
+            qualified_type (dict): The qualified type dictionary containing information about the type.
+
+        Returns:
+            SerializableType: The constructed serializable type.
+
+        """
+        struct_members = []
+        for name, member_dict in qualified_type.get("members").items():
+            member_type_dict = member_dict["type"]
+            member_type_obj = self.parse_type(member_type_dict)
+
+            # For member arrays (declared inline, so we create a type on the fly)
+            if member_dict.get("size") is not None:
+                member_type_obj = ArrayType.construct_type(
+                    f"Array_{member_type_obj.__name__}_{member_dict['size']}",
+                    member_type_obj,
+                    member_dict["size"],
+                    JsonLoader.preprocess_format_str(
+                        member_dict["type"].get("format", "{}")
+                    ),
+                )
+            fmt_str = JsonLoader.preprocess_format_str(
+                member_type_obj.FORMAT if hasattr(member_type_obj, "FORMAT") else "{}"
+            )
+            description = member_type_dict.get("annotation", "")
+            struct_members.append((name, member_type_obj, fmt_str, description))
+
+        ser_type = SerializableType.construct_type(
+            type_name,
+            struct_members,
+        )
+        self.parsed_types[type_name] = ser_type
+        return ser_type
+
+    @staticmethod
+    def preprocess_format_str(format_str: Optional[str]) -> Optional[str]:
+        """Preprocess format strings before using them in Python format function
+        Internally, this converts FPP-style format strings to Python-style format strings
+
+        Args:
+            format_str (str): FPP-style format string
+
+        Returns:
+            str: Python-style format string
+        """
+        if format_str is None:
+            return None
+        return preprocess_fpp_format_str(format_str)

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",