fprime-gds 4.0.0a8__py3-none-any.whl → 4.0.0a10__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/templates/cmd_template.py

@@ -175,3 +175,11 @@ class CmdTemplate(data_template.DataTemplate):
 
     def getArgs(self):
         return self.get_args()
+
+    def __repr__(self):
+        arg_strs = []
+        for arg in self.arguments:
+            arg_strs.append(arg[0] + ": " + str(arg[2]))
+            
+        args_str = ", ".join(arg_strs)
+        return f"CmdTemplate({self.comp_name}.{self.mnemonic}, args: ({args_str}))"

fprime_gds/executables/cli.py

@@ -209,7 +209,9 @@ class ParserBase(ABC):
             arguments: arguments to process, None to use command line input
         Returns: namespace with all parsed arguments from all provided ParserBase subclasses
         """
-        return cls._parse_args(parser_classes, description, arguments, use_parse_known=True, **kwargs)
+        return cls._parse_args(
+            parser_classes, description, arguments, use_parse_known=True, **kwargs
+        )
 
     @classmethod
     def parse_args(
@@ -234,7 +236,6 @@ class ParserBase(ABC):
         """
         return cls._parse_args(parser_classes, description, arguments, **kwargs)
 
-
     @staticmethod
     def _parse_args(
         parser_classes,
@@ -297,16 +298,17 @@ class ParserBase(ABC):
 
 
 class ConfigDrivenParser(ParserBase):
-    """ Parser that allows options from configuration and command line
+    """Parser that allows options from configuration and command line
 
     This parser reads a configuration file (if supplied) and uses the values to drive the inputs to arguments. Command
     line arguments will still take precedence over the configured values.
     """
+
     DEFAULT_CONFIGURATION_PATH = Path("fprime-gds.yml")
 
     @classmethod
     def set_default_configuration(cls, path: Path):
-        """ Set path for (global) default configuration file
+        """Set path for (global) default configuration file
 
         Set the path for default configuration file. If unset, will use 'fprime-gds.yml'. Set to None to disable default
         configuration.
@@ -321,7 +323,7 @@ class ConfigDrivenParser(ParserBase):
         arguments=None,
         **kwargs,
     ):
-        """ Parse and post-process arguments using inputs and config
+        """Parse and post-process arguments using inputs and config
 
         Parse the arguments in two stages: first parse the configuration data, ignoring unknown inputs, then parse the
         full argument set with the supplied configuration to fill in additional options.
@@ -343,23 +345,29 @@ class ConfigDrivenParser(ParserBase):
 
         # Custom flow involving parsing the arguments of this parser first, then passing the configured values
         # as part of the argument source
-        ns_config, _, remaining = ParserBase.parse_known_args([ConfigDrivenParser], description, arguments, **kwargs)
+        ns_config, _, remaining = ParserBase.parse_known_args(
+            [ConfigDrivenParser], description, arguments, **kwargs
+        )
         config_options = ns_config.config_values.get("command-line-options", {})
         config_args = cls.flatten_options(config_options)
         # Argparse allows repeated (overridden) arguments, thus the CLI override is accomplished by providing
         # remaining arguments after the configured ones
-        ns_full, parser = ParserBase.parse_args(parser_classes, description, config_args + remaining, **kwargs)
-        ns_final =  argparse.Namespace(**vars(ns_config), **vars(ns_full))
+        ns_full, parser = ParserBase.parse_args(
+            parser_classes, description, config_args + remaining, **kwargs
+        )
+        ns_final = argparse.Namespace(**vars(ns_config), **vars(ns_full))
         return ns_final, parser
 
     @staticmethod
     def flatten_options(configured_options):
-        """ Flatten options down to arguments """
+        """Flatten options down to arguments"""
         flattened = []
         for option, value in configured_options.items():
             flattened.append(f"--{option}")
             if value is not None:
-                flattened.extend(value if isinstance(value, (list, tuple)) else [f"{value}"])
+                flattened.extend(
+                    value if isinstance(value, (list, tuple)) else [f"{value}"]
+                )
         return flattened
 
     def get_arguments(self) -> Dict[Tuple[str, ...], Dict[str, Any]]:
@@ -375,24 +383,30 @@ class ConfigDrivenParser(ParserBase):
         }
 
     def handle_arguments(self, args, **kwargs):
-        """ Handle the arguments
+        """Handle the arguments
 
         Loads the configuration file specified and fills in the `config_values` attribute of the namespace with the
         loaded configuration dictionary.
         """
         args.config_values = {}
         # Specified but non-existent config file is a hard error
-        if ("-c" in sys.argv[1:] or "--config" in sys.argv[1:]) and not args.config.exists():
-            raise ValueError(f"Specified configuration file '{args.config}' does not exist")
+        if (
+            "-c" in sys.argv[1:] or "--config" in sys.argv[1:]
+        ) and not args.config.exists():
+            raise ValueError(
+                f"Specified configuration file '{args.config}' does not exist"
+            )
         # Read configuration if the file was set and exists
-        if args.config is not None  and args.config.exists():
+        if args.config is not None and args.config.exists():
             print(f"[INFO] Reading command-line configuration from: {args.config}")
             with open(args.config, "r") as file_handle:
                 try:
                     loaded = yaml.safe_load(file_handle)
                     args.config_values = loaded if loaded is not None else {}
                 except Exception as exc:
-                    raise ValueError(f"Malformed configuration {args.config}: {exc}", exc)
+                    raise ValueError(
+                        f"Malformed configuration {args.config}: {exc}", exc
+                    )
         return args
 
 
@@ -576,8 +590,9 @@ class PluginArgumentParser(ParserBase):
     """Parser for arguments coming from plugins"""
 
     DESCRIPTION = "Plugin options"
+    # Defaults:
     FPRIME_CHOICES = {
-        "framing": "fprime",
+        "framing": "space-packet-space-data-link",
         "communication": "ip",
     }