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

fprime_gds/common/fpy/grammar.lark

@@ -0,0 +1,88 @@
+# Adapted from: https://docs.python.org/3/reference/grammar.html and the Lark Python grammar
+
+input: (_NEWLINE | _stmt)*
+
+_literal: number | string | boolean
+
+_stmt: _small_stmt [_NEWLINE] | _compound_stmt
+_small_stmt: (_expr_stmt | assign | pass_stmt )
+_compound_stmt: if_stmt
+pass_stmt: "pass"
+
+_expr_stmt: _expr
+
+
+# assignment
+
+# can currently only assign constant values to vars
+# for some reason if i use _reference here i don't get a None in the optional spot
+assign: var [":" (get_attr | get_item | var)] "=" _expr
+
+
+
+# branching
+
+if_stmt: "if" _expr ":" body elifs ["else" ":" body]
+elifs: elif_*
+elif_: "elif" _expr ":" body
+body: _NEWLINE _INDENT _stmt+ _DEDENT
+
+_expr: _test
+
+# logical tests
+_test: or_test
+?or_test: and_test ("or" and_test)*
+?and_test: not_test_ ("and" not_test_)*
+?not_test_: "not" not_test_ -> not_test
+          | comparison
+          | atom
+comparison: atom comp_op atom
+comp_op: COMPARISON_OP
+
+arguments: _expr ("," _expr)*
+
+?atom: _reference "(" [arguments] ")" -> func_call
+     | _reference
+     | _literal
+     | "(" _expr ")"
+
+get_item: _reference "[" number "]"
+get_attr: _reference "." name
+var: name
+
+_reference: get_item | get_attr | var
+
+# not used in grammar, but may appear in "node" passed from Parser to Compiler
+encoding_decl: name
+
+number: DEC_NUMBER | FLOAT_NUMBER
+string: STRING
+boolean: CONST_FALSE | CONST_TRUE
+
+# Other terminals
+
+_NEWLINE: ( /\r?\n[\t ]*/ | COMMENT )+
+
+%ignore /[\t \f]+/  // WS
+%ignore /\\[\t \f]*\r?\n/   // LINE_CONT
+%ignore COMMENT
+%declare _INDENT _DEDENT
+
+
+# Python terminals
+
+!name: NAME
+NAME: /[^\W\d]\w*/
+COMMENT: /#[^\n]*/
+CONST_TRUE: "True"
+CONST_FALSE: "False"
+COMPARISON_OP: ">" | "<" | "<=" | ">=" | "==" | "!="
+
+STRING: /("(?!"").*?(?<!\\)(\\\\)*?"|'(?!'').*?(?<!\\)(\\\\)*?')/i
+
+_SPECIAL_DEC: "0".."9"        ("_"?  "0".."9"                       )*
+DEC_NUMBER:   "-"? "1".."9"        ("_"?  "0".."9"                       )*
+          |   "-"? "0"             ("_"?  "0"                            )* /(?![1-9])/
+
+DECIMAL: "." _SPECIAL_DEC | _SPECIAL_DEC "." _SPECIAL_DEC?
+FLOAT_NUMBER.2: "-"? _SPECIAL_DEC DECIMAL ["e" ["-"] _SPECIAL_DEC]

fprime_gds/common/fpy/main.py

@@ -0,0 +1,40 @@
+import argparse
+from pathlib import Path
+
+from fprime_gds.common.fpy.parser import parse
+from fprime_gds.common.fpy.codegen import compile
+from fprime_gds.common.fpy.bytecode.directives import serialize_directives
+
+
+def main():
+    arg_parser = argparse.ArgumentParser()
+    arg_parser.add_argument("input", type=Path, help="The input .fpy file")
+    arg_parser.add_argument(
+        "-o",
+        "--output",
+        type=Path,
+        required=False,
+        default=None,
+        help="The output .bin path",
+    )
+    arg_parser.add_argument(
+        "-d",
+        "--dictionary",
+        type=Path,
+        required=True,
+        help="The FPrime dictionary .json file",
+    )
+
+    args = arg_parser.parse_args()
+
+    if not args.input.exists():
+        print(f"Input file {args.input} does not exist")
+        exit(-1)
+
+    body = parse(args.input.read_text())
+    directives = compile(body, args.dictionary)
+    output = args.output
+    if output is None:
+        output = args.input.with_suffix(".bin")
+    serialize_directives(directives, output)
+    print("Done")

fprime_gds/common/fpy/parser.py

@@ -0,0 +1,239 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Literal as TypingLiteral, Union
+from lark.indenter import PythonIndenter
+from lark import Lark, Transformer, v_args
+from lark.tree import Meta
+
+fpy_grammar_str = (Path(__file__).parent / "grammar.lark").read_text()
+
+input_text = None
+
+
+def parse(text: str):
+    parser = Lark(
+        fpy_grammar_str,
+        start="input",
+        parser="lalr",
+        postlex=PythonIndenter(),
+        propagate_positions=True,
+        maybe_placeholders=True,
+    )
+
+    global input_text
+    input_text = text
+    tree = parser.parse(text, on_error=lambda x: print("Error"))
+    transformed = FpyTransformer().transform(tree)
+    return transformed
+
+
+@dataclass
+class Ast:
+    meta: Meta = field(repr=False)
+    id: int = field(init=False, repr=False, default=None)
+    node_text: str = field(init=False, repr=False, default=None)
+
+    def __post_init__(self):
+        if not hasattr(self.meta, "start_pos"):
+            self.node_text = ""
+            return
+        self.node_text = (
+            input_text[self.meta.start_pos : self.meta.end_pos]
+            .replace("\n", " ")
+            .strip()
+        )
+
+    def __hash__(self):
+        return hash(self.id)
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self.node_text})"
+
+
+@dataclass
+class AstVar(Ast):
+    var: str
+
+
+@dataclass()
+class AstString(Ast):
+    value: str
+
+
+@dataclass
+class AstNumber(Ast):
+    value: int | float
+
+
+@dataclass
+class AstBoolean(Ast):
+    value: TypingLiteral[True] | TypingLiteral[False]
+
+
+AstLiteral = AstString | AstNumber | AstBoolean
+
+
+@dataclass
+class AstGetAttr(Ast):
+    parent: "AstReference"
+    attr: str
+
+
+@dataclass
+class AstGetItem(Ast):
+    parent: "AstReference"
+    item: AstNumber
+
+
+@dataclass
+class AstFuncCall(Ast):
+    func: "AstReference"
+    args: list["AstExpr"] | None
+
+
+@dataclass
+class AstInfixOp(Ast):
+    value: str
+
+
+@dataclass()
+class AstPass(Ast):
+    pass
+
+
+@dataclass
+class AstComparison(Ast):
+    lhs: "AstExpr"
+    op: AstInfixOp
+    rhs: "AstExpr"
+
+
+@dataclass
+class AstNot(Ast):
+    value: "AstExpr"
+
+
+@dataclass
+class AstAnd(Ast):
+    values: list["AstExpr"]
+
+
+@dataclass
+class AstOr(Ast):
+    values: list["AstExpr"]
+
+
+AstTest = AstOr | AstAnd | AstNot | AstComparison
+
+
+AstReference = AstGetAttr | AstGetItem | AstVar
+AstExpr = Union[AstFuncCall, AstTest, AstLiteral, AstReference]
+
+
+@dataclass
+class AstAssign(Ast):
+    variable: AstVar
+    var_type: AstReference | None
+    value: AstExpr
+
+
+@dataclass
+class AstElif(Ast):
+    condition: AstExpr
+    body: "AstBody"
+
+
+@dataclass
+class AstElifs(Ast):
+    cases: list[AstElif]
+
+
+@dataclass()
+class AstIf(Ast):
+    condition: AstExpr
+    body: "AstBody"
+    elifs: AstElifs | None
+    els: Union["AstBody", None]
+
+
+AstStmt = Union[AstExpr, AstAssign, AstPass, AstIf]
+
+
+@dataclass
+class AstBody(Ast):
+    stmts: list[AstStmt]
+
+
+for cls in Ast.__subclasses__():
+    cls.__hash__ = Ast.__hash__
+    # cls.__repr__ = Ast.__repr__
+
+
+@v_args(meta=False, inline=False)
+def as_list(self, tree):
+    return list(tree)
+
+
+def no_inline_or_meta(type):
+    @v_args(meta=False, inline=False)
+    def wrapper(self, tree):
+        return type(tree)
+
+    return wrapper
+
+
+def no_inline(type):
+    @v_args(meta=True, inline=False)
+    def wrapper(self, meta, tree):
+        return type(meta, tree)
+
+    return wrapper
+
+
+def no_meta(type):
+    @v_args(meta=False, inline=True)
+    def wrapper(self, tree):
+        return type(tree)
+
+    return wrapper
+
+def handle_str(meta, s: str):
+    return s.strip("'").strip('"')
+
+
+@v_args(meta=True, inline=True)
+class FpyTransformer(Transformer):
+    input = no_inline(AstBody)
+    pass_stmt = AstPass
+
+    assign = AstAssign
+
+    if_stmt = AstIf
+    elifs = no_inline(AstElifs)
+    elif_ = AstElif
+    body = no_inline(AstBody)
+    or_test = no_inline(AstOr)
+    and_test = no_inline(AstAnd)
+    not_test = AstNot
+    comparison = AstComparison
+    comp_op = AstInfixOp
+
+    func_call = AstFuncCall
+    arguments = no_inline_or_meta(list)
+
+    string = AstString
+    number = AstNumber
+    boolean = AstBoolean
+    name = no_meta(str)
+    get_attr = AstGetAttr
+    get_item = AstGetItem
+    var = AstVar
+
+    NAME = str
+    DEC_NUMBER = int
+    FLOAT_NUMBER = float
+    COMPARISON_OP = str
+    STRING = handle_str
+    CONST_TRUE = lambda a, b: True
+    CONST_FALSE = lambda a, b: False

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(),
+        )

fprime_gds/common/loaders/pkt_json_loader.py

@@ -0,0 +1,125 @@
+"""
+pkt_json_loader.py:
+
+Loads flight dictionary (JSON) and returns Python dictionaries of telemetry packets
+
+@author jawest
+"""
+
+from fprime_gds.common.templates.pkt_template import PktTemplate
+from fprime_gds.common.loaders.json_loader import JsonLoader
+from fprime_gds.common.data_types.exceptions import GdsDictionaryParsingException
+
+
+class PktJsonLoader(JsonLoader):
+    """Class to load python based telemetry packet dictionaries"""
+
+    PACKETS_FIELD = "telemetryPacketSets"
+
+    SET_NAME = "name"
+    MEMBERS = "members"
+
+    def get_packet_set_names(self, path):
+        """ Get the list of packet sets """
+        return [packet_set[self.SET_NAME] for packet_set in self.json_dict[self.PACKETS_FIELD]]
+
+    def get_id_dict(self, path, packet_set_name: str, ch_name_dict: dict):
+        if path in self.saved_dicts and packet_set_name in self.saved_dicts[path]:
+            (id_dict, name_dict) = self.saved_dicts[path][packet_set_name]
+        else:
+            (id_dict, name_dict, self.versions) = self.construct_dicts(packet_set_name, ch_name_dict)
+            if path not in self.saved_dicts:
+                self.saved_dicts[path] = dict()
+            self.saved_dicts[path].update({packet_set_name: (id_dict, name_dict)})
+
+        return id_dict
+    
+    def get_name_dict(self, path, packet_set_name: str, ch_name_dict: dict):
+        if path in self.saved_dicts and packet_set_name in self.saved_dicts[path]:
+            (id_dict, name_dict) = self.saved_dicts[path][packet_set_name]
+        else:
+            (id_dict, name_dict, self.versions) = self.construct_dicts(packet_set_name, ch_name_dict)
+            if path not in self.saved_dicts:
+                self.saved_dicts[path] = dict()
+            self.saved_dicts[path].update({packet_set_name: (id_dict, name_dict)})
+
+        return name_dict
+
+
+    def construct_dicts(self, packet_set_name: str, ch_name_dict: dict):
+        """
+        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:
+            ch_name_dict (dict()): Channel dictionary with names as keys and
+                                   ChTemplate objects as values.
+
+        Returns:
+            A tuple with two packet dictionaries (type==dict()):
+            (id_dict, name_dict) and the dictionary version. The keys of the packet dictionaries should 
+            be the packets' id and name fields respectively and the values should be PktTemplate objects.
+        """
+        id_dict = {}
+        name_dict = {}
+
+        if self.PACKETS_FIELD not in self.json_dict:
+            raise GdsDictionaryParsingException(
+                f"Ground Dictionary missing '{self.PACKETS_FIELD}' field: {str(self.json_file)}"
+            )
+
+        for packet_dict in self.json_dict[self.PACKETS_FIELD]:
+            try:
+                if packet_set_name == packet_dict[self.SET_NAME]:
+                    for packet_group_dict in packet_dict.get(self.MEMBERS, []):
+                        packet_temp = self.construct_template_from_dict(packet_group_dict, ch_name_dict)
+                        id_dict[packet_temp.get_id()] = packet_temp
+                        name_dict[packet_temp.get_name()] = packet_temp
+
+                    return (
+                        dict(sorted(id_dict.items())),
+                        dict(sorted(name_dict.items())),
+                        self.get_versions(),
+                    )
+                
+            except KeyError as e:
+                raise GdsDictionaryParsingException(
+                    f"{str(e)} key missing from telemetry packet dictionary entry: {str(packet_dict)}"
+                )
+            
+        raise GdsDictionaryParsingException(
+            f"Ground Dictionary does not contain packet set '{packet_set_name}'"
+        )
+
+    def construct_template_from_dict(self, packet_group_dict: dict, ch_name_dict: dict):
+        """        
+        Args:
+            packet_group_dict (dict()): Packet group dictionary with group id, name, and members
+            ch_name_dict (dict()): Channel dictionary with names as keys and ChTemplate objects as values.
+        Returns:
+            A a PktTemplate object containing the packet group id, group name, and list of ChTemplate 
+            objects that represent each member in the packet.
+        """
+        try:
+            ch_list = []
+            group_name = packet_group_dict["name"]
+            group_id = packet_group_dict["id"]
+            group_members = packet_group_dict["members"]
+
+            for ch_name in group_members:
+                ch_template = ch_name_dict[ch_name]
+                ch_list.append(ch_template)
+            
+        except KeyError as e:
+            raise GdsDictionaryParsingException(
+                f"{str(e)} key missing from telemetry packet member or member is not a channel in the dictionary: {str(group_name)}"
+            )
+        
+        return PktTemplate(
+            group_id,
+            group_name,
+            ch_list
+        )
+

fprime_gds/common/loaders/prm_json_loader.py

@@ -0,0 +1,85 @@
+"""
+prm_json_loader.py:
+
+Loads flight dictionary (JSON) and returns id and mnemonic based Python dictionaries of params
+
+@author zimri.leisher
+"""
+
+from fprime_gds.common.templates.prm_template import PrmTemplate
+from fprime_gds.common.loaders.json_loader import JsonLoader
+from fprime_gds.common.data_types.exceptions import GdsDictionaryParsingException
+
+
+class PrmJsonLoader(JsonLoader):
+    """Class to load parameters from json dictionaries"""
+
+    PARAMS_FIELD = "parameters"
+
+    ID = "id"
+    NAME = "name"
+    TYPE = "type"
+    DESC = "annotation"
+    DEFAULT = "default"
+    
+
+    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, fqn_name_dict). The keys should be the channels' id and
+            fully qualified name fields respectively and the values should be PrmTemplate
+            objects.
+        """
+        id_dict = {}
+        fqn_name_dict = {}
+
+        if self.PARAMS_FIELD not in self.json_dict:
+            raise GdsDictionaryParsingException(
+                f"Ground Dictionary missing '{self.PARAMS_FIELD}' field: {str(self.json_file)}"
+            )
+
+        for prm_dict in self.json_dict[self.PARAMS_FIELD]:
+            # Create a channel template object
+            prm_temp = self.construct_template_from_dict(prm_dict)
+
+            id_dict[prm_temp.get_id()] = prm_temp
+            fqn_name_dict[prm_temp.get_full_name()] = prm_temp
+
+        return (
+            dict(sorted(id_dict.items())),
+            dict(sorted(fqn_name_dict.items())),
+            self.get_versions(),
+        )
+
+    def construct_template_from_dict(self, prm_dict: dict) -> PrmTemplate:
+        try:
+            prm_id = prm_dict[self.ID]
+            # The below assignment also raises a ValueError if the name does not contain a '.'
+            qualified_component_name, prm_name = prm_dict[self.NAME].rsplit('.', 1)
+            if not qualified_component_name or not prm_name:
+                raise ValueError()
+
+            type_obj = self.parse_type(prm_dict[self.TYPE])
+        except ValueError as e:
+            raise GdsDictionaryParsingException(
+                f"Parameter dictionary entry malformed, expected name of the form '<QUAL_COMP_NAME>.<PRM_NAME>' in : {str(prm_dict)}"
+            )
+        except KeyError as e:
+            raise GdsDictionaryParsingException(
+                f"{str(e)} key missing from parameter dictionary entry or its associated type in the dictionary: {str(prm_dict)}"
+            )
+
+        prm_default_val = prm_dict.get(self.DEFAULT, None)
+
+        return PrmTemplate(
+            prm_id,
+            prm_name,
+            qualified_component_name,
+            type_obj,
+            prm_default_val
+        )