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

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 '.'
+            qualified_component_name, channel_name = channel_dict[self.NAME].rsplit('.', 1)
+            if not qualified_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 '<QUAL_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,
+            qualified_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:
+            qualified_component_name, cmd_mnemonic = cmd_dict[self.NAME].rsplit('.', 1)
+            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 '<QUAL_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, qualified_component_name, 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):

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:
+            qualified_component_name, event_name = event_dict[self.NAME].rsplit('.', 1)
+            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 '<QUAL_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,
+            qualified_component_name,
+            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)