fprime-gds 3.6.2a1__py3-none-any.whl → 4.0.0a1__py3-none-any.whl

fprime_gds/common/decoders/ch_decoder.py

@@ -44,7 +44,7 @@ class ChDecoder(Decoder):
             config = config_manager.ConfigManager().get_instance()
 
         self.__dict = ch_dict
-        self.id_obj = config.get_type("ch_id")
+        self.id_obj = config.get_type("FwChanIdType")
 
     def decode_api(self, data):
         """

fprime_gds/common/decoders/event_decoder.py

@@ -19,6 +19,7 @@ from fprime.common.models.serialize.type_exceptions import TypeException
 
 from fprime_gds.common.data_types import event_data
 from fprime_gds.common.decoders import decoder
+from fprime_gds.common.decoders.decoder import DecodingException
 from fprime_gds.common.utils import config_manager
 
 
@@ -43,7 +44,7 @@ class EventDecoder(decoder.Decoder):
             config = config_manager.ConfigManager().get_instance()
 
         self.__dict = event_dict
-        self.id_obj = config.get_type("event_id")
+        self.id_obj = config.get_type("FwEventIdType")
 
     def decode_api(self, data):
         """

fprime_gds/common/decoders/pkt_decoder.py

@@ -45,7 +45,7 @@ class PktDecoder(ChDecoder):
         super().__init__(ch_dict, config)
 
         self.__dict = pkt_name_dict
-        self.id_obj = config.get_type("pkt_id")
+        self.id_obj = config.get_type("FwTlmPacketizeIdType")
 
     def decode_api(self, data):
         """

fprime_gds/common/distributor/distributor.py

@@ -57,7 +57,7 @@ class Distributor(DataHandler):
             self.key_frame = int(config.get("framing", "key_val"), 16)
         self.key_obj = config.get_type("key_val")
         self.len_obj = config.get_type("msg_len")
-        self.desc_obj = config.get_type("msg_desc")
+        self.desc_obj = config.get_type("FwPacketDescriptorType")
 
     # NOTE we could use either the type of the object or an enum as the type argument.
     # It should indicate what the decoder decodes.
@@ -204,4 +204,4 @@ class Distributor(DataHandler):
                 try:
                     d.data_callback(msg)
                 except DecodingException as dexc:
-                    LOGGER.warning("Decoding error occurred: %s. Skipping.", dexc)
+                    LOGGER.warning("Decoding error occurred: %s. Skipping.", dexc)

fprime_gds/common/encoders/ch_encoder.py

@@ -57,8 +57,8 @@ class ChEncoder(Encoder):
         super().__init__(config)
 
         self.len_obj = self.config.get_type("msg_len")
-        self.desc_obj = self.config.get_type("msg_desc")
-        self.id_obj = self.config.get_type("ch_id")
+        self.desc_obj = self.config.get_type("FwPacketDescriptorType")
+        self.id_obj = self.config.get_type("FwChanIdType")
 
     def encode_api(self, data):
         """

fprime_gds/common/encoders/cmd_encoder.py

@@ -72,8 +72,8 @@ class CmdEncoder(encoder.Encoder):
         super().__init__(config)
 
         self.len_obj = self.config.get_type("msg_len")
-        self.desc_obj = self.config.get_type("msg_desc")
-        self.opcode_obj = self.config.get_type("op_code")
+        self.desc_obj = self.config.get_type("FwPacketDescriptorType")
+        self.opcode_obj = self.config.get_type("FwOpcodeType")
 
     def encode_api(self, data):
         """

fprime_gds/common/encoders/event_encoder.py

@@ -61,8 +61,8 @@ class EventEncoder(Encoder):
         super().__init__(config)
 
         self.len_obj = self.config.get_type("msg_len")
-        self.desc_obj = self.config.get_type("msg_desc")
-        self.id_obj = self.config.get_type("event_id")
+        self.desc_obj = self.config.get_type("FwPacketDescriptorType")
+        self.id_obj = self.config.get_type("FwEventIdType")
 
     def encode_api(self, data):
         """

fprime_gds/common/encoders/pkt_encoder.py

@@ -61,8 +61,8 @@ class PktEncoder(Encoder):
         super().__init__(config)
 
         self.len_obj = self.config.get_type("msg_len")
-        self.desc_obj = self.config.get_type("msg_desc")
-        self.id_obj = self.config.get_type("pkt_id")
+        self.desc_obj = self.config.get_type("FwPacketDescriptorType")
+        self.id_obj = self.config.get_type("FwTlmPacketizeIdType")
 
     def encode_api(self, data):
         """

fprime_gds/common/encoders/seq_writer.py

@@ -28,8 +28,8 @@ class SeqBinaryWriter:
 
         self.__fd = None
         self.__timebase = timebase
-        self.desc_obj = config.get_type("msg_desc")
-        self.opcode_obj = config.get_type("op_code")
+        self.desc_obj = config.get_type("FwPacketDescriptorType")
+        self.opcode_obj = config.get_type("FwOpcodeType")
         self.len_obj = config.get_type("msg_len")
 
     def open(self, filename):

fprime_gds/common/fpy/serialize_bytecode.py

@@ -0,0 +1,229 @@
+from __future__ import annotations
+from dataclasses import astuple
+import inspect
+import json
+from pathlib import Path
+from argparse import ArgumentParser
+import struct
+import zlib
+from fprime_gds.common.fpy.types import (
+    StatementTemplate,
+    StatementData,
+    Header,
+    Footer,
+    HEADER_FORMAT,
+    FOOTER_FORMAT,
+    StatementType,
+    FPY_DIRECTIVES,
+    BytecodeParseContext,
+    get_type_obj_for,
+)
+from fprime_gds.common.loaders.ch_json_loader import ChJsonLoader
+from fprime_gds.common.loaders.cmd_json_loader import CmdJsonLoader
+from fprime.common.models.serialize.numerical_types import (
+    U8Type,
+)
+
+from fprime_gds.common.loaders.prm_json_loader import PrmJsonLoader
+
+
+def serialize_statement(stmt: StatementData) -> bytes:
+    """converts a StatementData object into bytes that the FpySequencer can read"""
+    # see https://github.com/nasa/fprime/issues/3023#issuecomment-2693051677
+    # TODO replace this with actual documentation
+
+    # type: U8 (0 if directive, 1 if cmd)
+    # opcode: FwOpcodeType (default U32)
+    # argBufSize: FwSizeStoreType (default U16)
+    # argBuf: X bytes
+
+    output = bytes()
+    output += U8Type(stmt.template.statement_type.value).serialize()
+    output += get_type_obj_for("FwOpcodeType")(stmt.template.opcode).serialize()
+
+    arg_bytes = bytes()
+    for arg in stmt.arg_values:
+        arg_bytes += arg.serialize()
+
+    output += get_type_obj_for("FwSizeStoreType")(len(arg_bytes)).serialize()
+    output += arg_bytes
+
+    return output
+
+
+def parse_str_as_statement(
+    stmt: str, templates: list[StatementTemplate], context: BytecodeParseContext
+) -> StatementData:
+    """Converts a human-readable line of bytecode into a StatementData instance, given a list of
+    possible statement templates"""
+    name = stmt.split()[0]
+    args = stmt[len(name) :]
+
+    args = json.loads("[" + args + "]")
+
+    matching_template = [t for t in templates if t.name == name]
+    if len(matching_template) != 1:
+        # no unique match
+        if len(matching_template) == 0:
+            raise RuntimeError("Could not find command or directive " + str(name))
+        raise RuntimeError(
+            "Found multiple commands or directives with name " + str(name)
+        )
+    matching_template = matching_template[0]
+
+    arg_values = []
+    if len(args) < len(matching_template.args):
+        raise RuntimeError(
+            "Missing arguments for statement "
+            + str(matching_template.name)
+            + ": "
+            + str(matching_template.args[len(args) :])
+        )
+    if len(args) > len(matching_template.args):
+        raise RuntimeError(
+            "Extra arguments for"
+            + str(matching_template.name)
+            + ": "
+            + str(args[len(matching_template.args) :])
+        )
+    for index, arg_json in enumerate(args):
+        arg_type = matching_template.args[index]
+        if inspect.isclass(arg_type):
+            # it's a type. instantiate it with the json
+            arg_value = arg_type(arg_json)
+        else:
+            # it's a function. give it the json and the ctx
+            arg_value = arg_type(arg_json, context)
+        arg_values.append(arg_value)
+
+    return StatementData(matching_template, arg_values)
+
+
+def main():
+    arg_parser = ArgumentParser()
+    arg_parser.add_argument(
+        "input", type=Path, help="The path to the input .fpybc file"
+    )
+
+    arg_parser.add_argument(
+        "-d",
+        "--dictionary",
+        type=Path,
+        help="The JSON topology dictionary to compile against",
+        required=True,
+    )
+
+    arg_parser.add_argument(
+        "-o",
+        "--output",
+        type=Path,
+        help="The output .bin file path. Defaults to the input file path with a .bin extension",
+        default=None,
+    )
+
+    args = arg_parser.parse_args()
+
+    if not args.input.exists():
+        print("Input file", args.input, "does not exist")
+        exit(1)
+
+    if not args.dictionary.exists():
+        print("Dictionary file", args.dictionary, "does not exist")
+        exit(1)
+
+    serialize_bytecode(args.input, args.dictionary, args.output)
+
+
+def serialize_bytecode(input: Path, dictionary: Path, output: Path = None):
+    """Given an input .fpybc file, and a dictionary .json file, converts the
+    bytecode file into binary and writes it to the output file. If the output file
+    is None, writes it to the input file with a .bin extension"""
+    cmd_json_dict_loader = CmdJsonLoader(str(dictionary))
+    (_, cmd_name_dict, _) = cmd_json_dict_loader.construct_dicts(
+        str(dictionary)
+    )
+
+    stmt_templates = []
+    stmt_templates.extend(FPY_DIRECTIVES)
+    for cmd_template in cmd_name_dict.values():
+        stmt_template = StatementTemplate(
+            StatementType.CMD,
+            cmd_template.opcode,
+            cmd_template.get_full_name(),
+            [arg[2] for arg in cmd_template.arguments],
+        )
+        stmt_templates.append(stmt_template)
+
+    tlm_json_loader = ChJsonLoader(str(dictionary))
+    (_, tlm_name_dict, _) = tlm_json_loader.construct_dicts(
+        str(dictionary)
+    )
+
+    prm_json_loader = PrmJsonLoader(str(dictionary))
+    (_, prm_name_dict, _) = prm_json_loader.construct_dicts(
+        str(dictionary)
+    )
+
+    context = BytecodeParseContext()
+    context.types = cmd_json_dict_loader.parsed_types
+    context.channels = tlm_name_dict
+    context.params = prm_name_dict
+
+    input_lines = input.read_text().splitlines()
+    input_lines = [line.strip() for line in input_lines]
+    # remove comments and empty lines
+    input_lines = [
+        line for line in input_lines if not line.startswith(";") and len(line) > 0
+    ]
+
+    goto_tags = {}
+    stmt_idx = 0
+    statement_strs: list[str] = []
+    for stmt in input_lines:
+        if stmt.endswith(":"):
+            # it's a goto tag
+            goto_tags[stmt[:-1]] = stmt_idx
+        else:
+            statement_strs.append(stmt)
+            stmt_idx += 1
+
+    context.goto_tags = goto_tags
+
+    statements: list[StatementData] = []
+    for stmt_idx, stmt in enumerate(statement_strs):
+        try:
+            stmt_data = parse_str_as_statement(stmt, stmt_templates, context)
+            statements.append(stmt_data)
+        except BaseException as e:
+            raise RuntimeError(
+                "Exception while parsing statement index " + str(stmt_idx) + ": " + stmt
+            ) from e
+
+    # perform some checks for things we know will fail
+    for stmt in statements:
+        if stmt.template.name == "GOTO":
+            if stmt.arg_values[0].val > len(statements):
+                raise RuntimeError(
+                    f"GOTO index is outside the valid range for this sequence (was {stmt.arg_values[0].val}, should be <{len(statements)})"
+                )
+
+    output_bytes = bytes()
+
+    for stmt in statements:
+        output_bytes += serialize_statement(stmt)
+
+    header = Header(0, 0, 0, 1, 0, len(statements), len(output_bytes))
+    output_bytes = struct.pack(HEADER_FORMAT, *astuple(header)) + output_bytes
+
+    crc = zlib.crc32(output_bytes) % (1 << 32)
+    footer = Footer(crc)
+    output_bytes += struct.pack(FOOTER_FORMAT, *astuple(footer))
+
+    if output is None:
+        output = input.with_suffix(".bin")
+
+    output.write_bytes(output_bytes)
+
+
+if __name__ == "__main__":
+    main()

fprime_gds/common/fpy/types.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from enum import Enum
+import struct
+from typing import Any, Callable
+from fprime.common.models.serialize.type_base import BaseType, ValueType
+from fprime.common.models.serialize.time_type import TimeType
+from fprime.common.models.serialize.numerical_types import U32Type, U16Type, U8Type
+from fprime.common.models.serialize.string_type import StringType
+
+from fprime_gds.common.loaders.json_loader import PRIMITIVE_TYPE_MAP
+from fprime_gds.common.templates.ch_template import ChTemplate
+from fprime_gds.common.templates.prm_template import PrmTemplate
+
+
+def get_type_obj_for(type: str) -> type[ValueType]:
+    if type == "FwOpcodeType":
+        return U32Type
+    elif type == "FwSizeStoreType":
+        return U16Type
+    elif type == "FwChanIdType":
+        return U32Type
+    elif type == "FwPrmIdType":
+        return U32Type
+
+    raise RuntimeError("Unknown FPrime type alias " + str(type))
+
+
+class StatementType(Enum):
+    DIRECTIVE = 0
+    CMD = 1
+
+
+@dataclass
+class StatementTemplate:
+    """a statement with unspecified argument values"""
+
+    statement_type: StatementType
+    opcode: int
+    name: str
+    """fully qualified statement name"""
+    args: list[type[BaseType] | Callable[[Any, BytecodeParseContext], BaseType]]
+    """list of argument types of this statement, or functions that return an arg type"""
+
+
+@dataclass
+class StatementData:
+    template: StatementTemplate
+    arg_values: list[BaseType]
+
+
+HEADER_FORMAT = "!BBBBBHI"
+HEADER_SIZE = struct.calcsize(HEADER_FORMAT)
+
+
+@dataclass
+class Header:
+    majorVersion: int
+    minorVersion: int
+    patchVersion: int
+    schemaVersion: int
+    argumentCount: int
+    statementCount: int
+    bodySize: int
+
+
+FOOTER_FORMAT = "!I"
+FOOTER_SIZE = struct.calcsize(FOOTER_FORMAT)
+
+
+@dataclass
+class Footer:
+    crc: int
+
+
+class DirectiveOpcode(Enum):
+    INVALID = 0x00000000
+    WAIT_REL = 0x00000001
+    WAIT_ABS = 0x00000002
+    SET_LVAR = 0x00000003
+    GOTO = 0x00000004
+    IF = 0x00000005
+    NO_OP = 0x00000006
+    GET_TLM = 0x00000007
+    GET_PRM = 0x00000008
+
+
+@dataclass
+class BytecodeParseContext:
+    goto_tags: map[str, int] = field(default_factory=dict)
+    """a map of tag name with tag statement index"""
+    types: map[str, type[BaseType]] = field(default_factory=dict)
+    """a map of name to all parsed types available in the dictionary"""
+    channels: map[str, ChTemplate] = field(default_factory=dict)
+    """a map of name to ChTemplate object for all tlm channels"""
+    params: map[str, PrmTemplate] = field(default_factory=dict)
+    """a map of name to PrmTemplate object for all prms"""
+
+
+def time_type_from_json(js, ctx: BytecodeParseContext):
+    return TimeType(js["time_base"], js["time_context"], js["seconds"], js["useconds"])
+
+
+def arbitrary_type_from_json(js, ctx: BytecodeParseContext):
+    type_name = js["type"]
+
+    if type_name == "string":
+        # by default no max size restrictions in the bytecode
+        return StringType.construct_type(f"String", None)(js["value"])
+
+    # try first checking parsed_types, then check primitive types
+    type_class = ctx.types.get(type_name, PRIMITIVE_TYPE_MAP.get(type_name, None))
+    if type_class is None:
+        raise RuntimeError("Unknown type " + str(type_name))
+
+    return type_class(js["value"])
+
+
+def goto_tag_or_idx_from_json(js, ctx: BytecodeParseContext):
+    if isinstance(js, str):
+        # it's a tag
+        if js not in ctx.goto_tags:
+            raise RuntimeError("Unknown goto tag " + str(js))
+        return U32Type(ctx.goto_tags[js])
+
+    # otherwise it is a statement index
+    return U32Type(js)
+
+
+def tlm_chan_id_from_json(js, ctx: BytecodeParseContext):
+    if isinstance(js, str):
+        if js not in ctx.channels:
+            raise RuntimeError("Unknown telemetry channel " + str(js))
+        return get_type_obj_for("FwChanIdType")(ctx.channels[js].id)
+    elif isinstance(js, int):
+        matching = [tmp for tmp in ctx.channels.keys() if tmp.id == js]
+        if len(matching) != 1:
+            if len(matching) == 0:
+                raise RuntimeError("Unknown telemetry channel id " + str(js))
+            raise RuntimeError("Multiple matches for telemetry channel id " + str(js))
+        matching = matching[0]
+        return get_type_obj_for("FwChanIdType")(matching.id)
+
+
+def prm_id_from_json(js, ctx: BytecodeParseContext):
+    if isinstance(js, str):
+        if js not in ctx.params:
+            raise RuntimeError("Unknown parameter " + str(js))
+        return get_type_obj_for("FwPrmIdType")(ctx.params[js].prm_id)
+    elif isinstance(js, int):
+        matching = [tmp for tmp in ctx.params.keys() if tmp.prm_id == js]
+        if len(matching) != 1:
+            if len(matching) == 0:
+                raise RuntimeError("Unknown param id " + str(js))
+            raise RuntimeError("Multiple matches for param id " + str(js))
+        matching = matching[0]
+        return get_type_obj_for("FwPrmIdType")(matching.prm_id)
+
+
+FPY_DIRECTIVES: list[StatementTemplate] = [
+    StatementTemplate(
+        StatementType.DIRECTIVE,
+        DirectiveOpcode.WAIT_REL.value,
+        "WAIT_REL",
+        [U32Type, U32Type],
+    ),
+    StatementTemplate(
+        StatementType.DIRECTIVE,
+        DirectiveOpcode.WAIT_ABS.value,
+        "WAIT_ABS",
+        [time_type_from_json],
+    ),
+    StatementTemplate(
+        StatementType.DIRECTIVE,
+        DirectiveOpcode.SET_LVAR.value,
+        "SET_LVAR",
+        [U8Type, arbitrary_type_from_json],
+    ),
+    StatementTemplate(
+        StatementType.DIRECTIVE,
+        DirectiveOpcode.GOTO.value,
+        "GOTO",
+        [goto_tag_or_idx_from_json],
+    ),
+    StatementTemplate(
+        StatementType.DIRECTIVE,
+        DirectiveOpcode.IF.value,
+        "IF",
+        [U8Type, goto_tag_or_idx_from_json],
+    ),
+    StatementTemplate(
+        StatementType.DIRECTIVE,
+        DirectiveOpcode.GET_TLM.value,
+        "GET_TLM",
+        [U8Type, U8Type, tlm_chan_id_from_json],
+    ),
+    StatementTemplate(
+        StatementType.DIRECTIVE,
+        DirectiveOpcode.GET_PRM.value,
+        "GET_PRM",
+        [U8Type, prm_id_from_json],
+    ),
+]

fprime_gds/common/gds_cli/base_commands.py

@@ -130,7 +130,7 @@ class BaseCommand(abc.ABC):
             passes the given filter
         """
         project_dictionary = Dictionaries()
-        project_dictionary.load_dictionaries(dictionary_path, packet_spec=None)
+        project_dictionary.load_dictionaries(dictionary_path, packet_spec=None, packet_set_name=None)
         items = cls._get_item_list(project_dictionary, search_filter)
         return cls._get_item_list_string(items, json)
 

fprime_gds/common/handlers.py

@@ -6,7 +6,10 @@ defines the "DataHandler" base class for handling data.
 
 @author mstarch
 """
+
 import abc
+from typing import List, Type
+from fprime_gds.plugin.definitions import gds_plugin_specification
 
 
 class DataHandler(abc.ABC):
@@ -27,6 +30,42 @@ class DataHandler(abc.ABC):
         """
 
 
+class DataHandlerPlugin(DataHandler, abc.ABC):
+    """PLugin class allowing for custom data handlers
+
+    This class acts as a DataHandler class with the addition that it can be used as a plugin and thus self reports the
+    data types it handles (whereas DataHandler leaves that up to the registration call). Users shall concretely subclass
+    this class with their own data handling functionality.
+    """
+
+    @abc.abstractmethod
+    def get_handled_descriptors() -> List[str]:
+        """Return a list of data descriptor names this plugin handles"""
+        raise NotImplementedError()
+
+    @classmethod
+    @gds_plugin_specification
+    def register_data_handler_plugin(cls) -> Type["DataHandlerPlugin"]:
+        """Register a plugin to provide post-decoding data handling capabilities
+
+        Plugin hook for registering a plugin that supplies a DataHandler implementation. Implementors of this hook must
+        return a non-abstract subclass of DataHandlerPlugin. This class will be provided as a data handling
+        that is automatically enabled. Users may disable this via the command line. This data handler will be supplied
+        all data types returned by the `get_data_types()` method.
+
+        This DataHandler will run within the standard GDS (UI) process. Users wanting a separate process shall use a
+        GdsApp plugin instead.
+
+        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:
+            DataHandlerPlugin subclass (not instance)
+        """
+        raise NotImplementedError()
+
+
 class HandlerRegistrar(abc.ABC):
     """
     Defines a class that will take in registrants and remember them for calling back later. These objects should be of

fprime_gds/common/loaders/fw_type_json_loader.py

@@ -0,0 +1,54 @@
+"""
+fw_type_json_loader.py:
+
+Loads flight dictionary (JSON) and returns name based Python dictionaries of Fw types
+
+@author jawest
+"""
+
+from fprime_gds.common.loaders.json_loader import JsonLoader
+from fprime_gds.common.data_types.exceptions import GdsDictionaryParsingException
+
+class FwTypeJsonLoader(JsonLoader):
+    """Class to load python based Fw type dictionaries"""
+
+    TYPE_DEFINITIONS_FIELD = "typeDefinitions"
+
+    def construct_dicts(self, _):
+        """
+        Constructs and returns python dictionaries keyed on id and name
+
+        Args:
+            _: Unused argument (inherited)
+        Returns:
+            A tuple with two Fw type dictionaries (python type dict):
+            (id_dict, name_dict). The keys should be the type id and
+            name fields respectively and the values should be type name
+            strings. Note: An empty id dictionary is returned since there 
+            are no id fields in the Fw type alias JSON dictionary entries.
+        """
+        id_dict = {}
+        name_dict = {}
+
+        if self.TYPE_DEFINITIONS_FIELD not in self.json_dict:
+            raise GdsDictionaryParsingException(
+                f"Ground Dictionary missing '{self.TYPE_DEFINITIONS_FIELD}' field: {str(self.json_file)}"
+            )
+
+        for type_def in self.json_dict[self.TYPE_DEFINITIONS_FIELD]:
+            try:
+                if type_def["kind"] == "alias":
+                    name = str(type_def["qualifiedName"])
+                    # Only consider names with the pattern Fw*Type
+                    if name.startswith("Fw") and name.endswith("Type"):
+                        name_dict[type_def["qualifiedName"]] = type_def["underlyingType"]["name"]
+            except KeyError as e:
+                raise GdsDictionaryParsingException(
+                    f"{str(e)} key missing from Type Definition dictionary entry: {str(type_def)}"
+                )
+
+        return (
+            dict(sorted(id_dict.items())),
+            dict(sorted(name_dict.items())),
+            self.get_versions(),
+        )