fprime-gds 4.0.2a2__py3-none-any.whl → 4.0.2a4__py3-none-any.whl

fprime_gds/common/fpy/types.py

@@ -0,0 +1,563 @@
+from __future__ import annotations
+from abc import ABC
+import inspect
+from dataclasses import dataclass, field, fields
+import struct
+import traceback
+import typing
+from typing import Union, get_args, get_origin
+
+# In Python 3.10+, the `|` operator creates a `types.UnionType`.
+# We need to handle this for forward compatibility, but it won't exist in 3.9.
+try:
+    from types import UnionType
+
+    UNION_TYPES = (Union, UnionType)
+except ImportError:
+    UNION_TYPES = (Union,)
+
+from fprime_gds.common.fpy.bytecode.directives import (
+    StackOpDirective,
+    FloatLogDirective,
+    Directive,
+    ExitDirective,
+    WaitAbsDirective,
+    WaitRelDirective,
+)
+from fprime_gds.common.templates.ch_template import ChTemplate
+from fprime_gds.common.templates.cmd_template import CmdTemplate
+from fprime_gds.common.templates.prm_template import PrmTemplate
+from fprime.common.models.serialize.time_type import TimeType
+from fprime.common.models.serialize.serializable_type import SerializableType
+from fprime.common.models.serialize.array_type import ArrayType
+from fprime.common.models.serialize.numerical_types import (
+    U32Type,
+    U16Type,
+    U64Type,
+    U8Type,
+    I16Type,
+    I32Type,
+    I64Type,
+    I8Type,
+    F32Type,
+    F64Type,
+    FloatType,
+    IntegerType,
+)
+from fprime.common.models.serialize.string_type import StringType
+from fprime.common.models.serialize.bool_type import BoolType
+from fprime_gds.common.fpy.parser import (
+    AstExpr,
+    AstOp,
+    AstReference,
+    Ast,
+    AstAssign,
+)
+from fprime.common.models.serialize.type_base import BaseType as FppType
+
+MAX_DIRECTIVES_COUNT = 1024
+MAX_DIRECTIVE_SIZE = 2048
+MAX_STACK_SIZE = 65535
+
+COMPILER_MAX_STRING_SIZE = 128
+
+
+# this is the "internal" integer type that integer literals have by
+# default. it is arbitrary precision
+class InternalIntType(IntegerType):
+    @classmethod
+    def range(cls):
+        raise NotImplementedError()
+
+    @staticmethod
+    def get_serialize_format():
+        raise NotImplementedError()
+
+    @classmethod
+    def get_bits(cls):
+        raise NotImplementedError()
+
+    @classmethod
+    def validate(cls, val):
+        if not isinstance(val, int):
+            raise RuntimeError()
+
+
+InternalStringType = StringType.construct_type("InternalStringType", None)
+
+
+SPECIFIC_NUMERIC_TYPES = (
+    U32Type,
+    U16Type,
+    U64Type,
+    U8Type,
+    I16Type,
+    I32Type,
+    I64Type,
+    I8Type,
+    F32Type,
+    F64Type,
+)
+SPECIFIC_INTEGER_TYPES = (
+    U32Type,
+    U16Type,
+    U64Type,
+    U8Type,
+    I16Type,
+    I32Type,
+    I64Type,
+    I8Type,
+)
+SIGNED_INTEGER_TYPES = (
+    I16Type,
+    I32Type,
+    I64Type,
+    I8Type,
+)
+UNSIGNED_INTEGER_TYPES = (
+    U32Type,
+    U16Type,
+    U64Type,
+    U8Type,
+)
+SPECIFIC_FLOAT_TYPES = (
+    F32Type,
+    F64Type,
+)
+
+
+def is_instance_compat(obj, cls):
+    """
+    A wrapper for isinstance() that correctly handles Union types in Python 3.9+.
+
+    Args:
+        obj: The object to check.
+        cls: The class, tuple of classes, or Union type to check against.
+
+    Returns:
+        True if the object is an instance of the class or any type in the Union.
+    """
+    origin = get_origin(cls)
+    if origin in UNION_TYPES:
+        # It's a Union type, so get its arguments.
+        # e.g., get_args(Union[int, str]) returns (int, str)
+        return isinstance(obj, get_args(cls))
+
+    # It's not a Union, so it's a regular type (like int) or a
+    # tuple of types ((int, str)), which isinstance handles natively.
+    return isinstance(obj, cls)
+
+
+# a value of type FppTypeClass is a Python `type` object representing
+# the type of an Fprime value
+FppTypeClass = type[FppType]
+
+
+class NothingType(ABC):
+    """a type which has no valid values in fprime. used to denote
+    a function which doesn't return a value"""
+
+    @classmethod
+    def __subclasscheck__(cls, subclass):
+        return False
+
+
+# the `type` object representing the NothingType class
+NothingTypeClass = type[NothingType]
+
+
+class CompileException(BaseException):
+    def __init__(self, msg, node: Ast):
+        self.msg = msg
+        self.node = node
+        self.stack_trace = "\n".join(traceback.format_stack(limit=8)[:-1])
+
+    def __str__(self):
+        if self.node is not None:
+            return f'{self.stack_trace}\nAt line {self.node.meta.line} "{self.node.node_text}": {self.msg}'
+        return f"{self.stack_trace}\n{self.msg}"
+
+
+@dataclass
+class FpyCallable:
+    return_type: FppTypeClass | NothingTypeClass
+    args: list[tuple[str, FppTypeClass]]
+
+
+@dataclass
+class FpyCmd(FpyCallable):
+    cmd: CmdTemplate
+
+
+@dataclass
+class FpyMacro(FpyCallable):
+    dir: type[Directive]
+    """a function which instantiates the macro given the argument exprs"""
+
+
+MACROS: dict[str, FpyMacro] = {
+    "sleep": FpyMacro(
+        NothingType,
+        [
+            (
+                "seconds",
+                U32Type,
+            ),
+            ("microseconds", U32Type),
+        ],
+        WaitRelDirective,
+    ),
+    "sleep_until": FpyMacro(NothingType, [("wakeup_time", TimeType)], WaitAbsDirective),
+    "exit": FpyMacro(NothingType, [("success", BoolType)], ExitDirective),
+    "log": FpyMacro(F64Type, [("operand", F64Type)], FloatLogDirective),
+}
+
+
+@dataclass
+class FpyTypeCtor(FpyCallable):
+    type: FppTypeClass
+
+
+@dataclass
+class FieldReference:
+    """a reference to a field/index of an fprime type"""
+
+    parent: "FpyReference"
+    """the qualifier"""
+    type: FppTypeClass
+    """the fprime type of this reference"""
+    offset: int
+    """the constant offset in the parent type at which to find this field"""
+    name: str = None
+    """the name of the field, if applicable"""
+    idx: int = None
+    """the index of the field, if applicable"""
+
+    def get_from(self, parent_val: FppType) -> FppType:
+        """gets the field value from the parent value"""
+        assert isinstance(parent_val, self.type)
+        assert self.name is not None or self.idx is not None
+        value = None
+        if self.name is not None:
+            if isinstance(parent_val, SerializableType):
+                value = parent_val.val[self.name]
+            elif isinstance(parent_val, TimeType):
+                if self.name == "seconds":
+                    value = parent_val.__secs
+                elif self.name == "useconds":
+                    value = parent_val.__usecs
+                elif self.name == "time_base":
+                    value = parent_val.__timeBase
+                elif self.name == "time_context":
+                    value = parent_val.__timeContext
+                else:
+                    assert False, self.name
+            else:
+                assert False, parent_val
+
+        else:
+
+            assert isinstance(parent_val, ArrayType), parent_val
+
+            value = parent_val._val[self.idx]
+
+        assert isinstance(value, self.type), (value, self.type)
+        return value
+
+
+# named variables can be tlm chans, prms, callables, or directly referenced consts (usually enums)
+@dataclass
+class FpyVariable:
+    """a mutable, typed value referenced by an unqualified name"""
+
+    type_ref: AstExpr
+    """the expression denoting the var's type"""
+    declaration: AstAssign
+    """the node where this var is declared"""
+    type: FppTypeClass | None = None
+    """the resolved type of the variable. None if type unsure at the moment"""
+    lvar_offset: int | None = None
+    """the offset in the lvar array where this var is stored"""
+
+
+# a scope
+FpyScope = dict[str, "FpyReference"]
+
+
+def create_scope(
+    references: dict[str, "FpyReference"],
+) -> FpyScope:
+    """from a flat dict of strs to references, creates a hierarchical, scoped
+    dict. no two leaf nodes may have the same name"""
+
+    base = {}
+
+    for fqn, ref in references.items():
+        names_strs = fqn.split(".")
+
+        ns = base
+        while len(names_strs) > 1:
+            existing_child = ns.get(names_strs[0], None)
+            if existing_child is None:
+                # this scope is not defined atm
+                existing_child = {}
+                ns[names_strs[0]] = existing_child
+
+            if not isinstance(existing_child, dict):
+                # something else already has this name
+                print(
+                    f"WARNING: {fqn} is already defined as {existing_child}, tried to redefine it as {ref}"
+                )
+                break
+
+            ns = existing_child
+            names_strs = names_strs[1:]
+
+        if len(names_strs) != 1:
+            # broke early. skip this loop
+            continue
+
+        # okay, now ns is the complete scope of the attribute
+        # i.e. everything up until the last '.'
+        name = names_strs[0]
+
+        existing_child = ns.get(name, None)
+
+        if existing_child is not None:
+            # uh oh, something already had this name with a diff value
+            print(
+                f"WARNING: {fqn} is already defined as {existing_child}, tried to redefine it as {ref}"
+            )
+            continue
+
+        ns[name] = ref
+
+    return base
+
+
+def union_scope(lhs: FpyScope, rhs: FpyScope) -> FpyScope:
+    """returns the two scopes, joined into one. if there is a conflict, chooses lhs over rhs"""
+    lhs_keys = set(lhs.keys())
+    rhs_keys = set(rhs.keys())
+    common_keys = lhs_keys.intersection(rhs_keys)
+
+    only_lhs_keys = lhs_keys.difference(common_keys)
+    only_rhs_keys = rhs_keys.difference(common_keys)
+
+    new = FpyScope()
+
+    for key in common_keys:
+        if not isinstance(lhs[key], dict) or not isinstance(rhs[key], dict):
+            # cannot be merged cleanly. one of the two is not a scope
+            print(f"WARNING: {key} is defined as {lhs[key]}, ignoring {rhs[key]}")
+            new[key] = lhs[key]
+            continue
+
+        new[key] = union_scope(lhs[key], rhs[key])
+
+    for key in only_lhs_keys:
+        new[key] = lhs[key]
+    for key in only_rhs_keys:
+        new[key] = rhs[key]
+
+    return new
+
+
+FpyReference = typing.Union[
+    ChTemplate,
+    PrmTemplate,
+    FppType,
+    FpyCallable,
+    FppTypeClass,
+    FpyVariable,
+    FieldReference,
+    dict,  # dict of FpyReference
+]
+"""some named concept in fpy"""
+
+
+def get_ref_fpp_type_class(ref: FpyReference) -> FppTypeClass:
+    """returns the fprime type of the ref, if it were to be evaluated as an expression"""
+    if isinstance(ref, ChTemplate):
+        result_type = ref.ch_type_obj
+    elif isinstance(ref, PrmTemplate):
+        result_type = ref.prm_type_obj
+    elif isinstance(ref, FppType):
+        # constant value
+        result_type = type(ref)
+    elif isinstance(ref, FpyCallable):
+        # a reference to a callable isn't a type in and of itself
+        # it has a return type but you have to call it (with an AstFuncCall)
+        # consider making a separate "reference" type
+        result_type = NothingType
+    elif isinstance(ref, FpyVariable):
+        result_type = ref.type
+    elif isinstance(ref, type):
+        # a reference to a type doesn't have a value, and so doesn't have a type,
+        # in and of itself. if this were a function call to the type's ctor then
+        # it would have a value and thus a type
+        result_type = NothingType
+    elif isinstance(ref, FieldReference):
+        result_type = ref.type
+    elif isinstance(ref, dict):
+        # reference to a scope. scopes don't have values
+        result_type = NothingType
+    else:
+        assert False, ref
+
+    return result_type
+
+
+@dataclass
+class CompileState:
+    """a collection of input, internal and output state variables and maps"""
+
+    types: FpyScope
+    """a scope whose leaf nodes are subclasses of BaseType"""
+    callables: FpyScope
+    """a scope whose leaf nodes are FpyCallable instances"""
+    tlms: FpyScope
+    """a scope whose leaf nodes are ChTemplates"""
+    prms: FpyScope
+    """a scope whose leaf nodes are PrmTemplates"""
+    consts: FpyScope
+    """a scope whose leaf nodes are instances of subclasses of BaseType"""
+    variables: FpyScope = field(default_factory=dict)
+    """a scope whose leaf nodes are FpyVariables"""
+    runtime_values: FpyScope = None
+    """a scope whose leaf nodes are tlms/prms/consts/variables, all of which
+    have some value at runtime."""
+
+    def __post_init__(self):
+        self.runtime_values = union_scope(
+            self.tlms,
+            union_scope(self.prms, union_scope(self.consts, self.variables)),
+        )
+
+    resolved_references: dict[AstReference, FpyReference] = field(
+        default_factory=dict, repr=False
+    )
+    """reference to its singular resolution"""
+
+    expr_types: dict[AstExpr, FppTypeClass | NothingTypeClass] = field(
+        default_factory=dict
+    )
+    """expr to its fprime type, or nothing type if none"""
+
+    stack_op_directives: dict[AstOp, type[StackOpDirective]] = field(
+        default_factory=dict
+    )
+    """some stack operation to which directive will be emitted for it"""
+
+    type_coercions: dict[AstExpr, FppTypeClass] = field(default_factory=dict)
+    """expr to fprime type it must be converted into at runtime"""
+
+    expr_values: dict[AstExpr, FppType | NothingType | None] = field(
+        default_factory=dict
+    )
+    """expr to its fprime value, or nothing if no value, or None if unsure at compile time"""
+
+    directives: dict[Ast, list[Directive] | None] = field(default_factory=dict)
+    """a list of code generated by each node, or None/empty list if no directives"""
+
+    node_dir_counts: dict[Ast, int] = field(default_factory=dict)
+    """node to the number of directives generated by it"""
+
+    lvar_array_size_bytes: int = 0
+    """the size in bytes of the lvar array"""
+
+    start_line_idx: dict[Ast, int] = field(default_factory=dict)
+    """the line index at which each node's directives will be included in the output"""
+
+    errors: list[CompileException] = field(default_factory=list)
+    """a list of all compile exceptions generated by passes"""
+
+    def err(self, msg, n):
+        """adds a compile exception to internal state"""
+        self.errors.append(CompileException(msg, n))
+
+
+class Visitor:
+    """visits each class, calling a custom visit function, if one is defined, for each
+    node type"""
+
+    def _find_custom_visit_func(self, node: Ast):
+        for name, func in inspect.getmembers(type(self), inspect.isfunction):
+            if not name.startswith("visit") or name == "visit_default":
+                # not a visitor, or the default visit func
+                continue
+            signature = inspect.signature(func)
+            params = list(signature.parameters.values())
+            assert len(params) == 3
+            assert params[1].annotation is not None
+            annotations = typing.get_type_hints(func)
+            param_type = annotations[params[1].name]
+            if is_instance_compat(node, param_type):
+                return func
+        else:
+            # call the default
+            return type(self).visit_default
+
+    def _visit(self, node: Ast, state: CompileState):
+        visit_func = self._find_custom_visit_func(node)
+        visit_func(self, node, state)
+
+    def visit_default(self, node: Ast, state: CompileState):
+        pass
+
+    def run(self, start: Ast, state: CompileState):
+        """runs the visitor, starting at the given node, descending depth-first"""
+
+        def _descend(node: Ast):
+            if not isinstance(node, Ast):
+                return
+            children = []
+            for field in fields(node):
+                field_val = getattr(node, field.name)
+                if isinstance(field_val, list):
+                    children.extend(field_val)
+                else:
+                    children.append(field_val)
+
+            for child in children:
+                if not isinstance(child, Ast):
+                    continue
+                _descend(child)
+                if len(state.errors) != 0:
+                    break
+                self._visit(child, state)
+                if len(state.errors) != 0:
+                    break
+
+        _descend(start)
+        self._visit(start, state)
+
+
+class TopDownVisitor(Visitor):
+
+    def run(self, start: Ast, state: CompileState):
+        """runs the visitor, starting at the given node, descending breadth-first"""
+
+        def _descend(node: Ast):
+            if not isinstance(node, Ast):
+                return
+            children = []
+            for field in fields(node):
+                field_val = getattr(node, field.name)
+                if isinstance(field_val, list):
+                    children.extend(field_val)
+                else:
+                    children.append(field_val)
+
+            for child in children:
+                if not isinstance(child, Ast):
+                    continue
+                self._visit(child, state)
+                if len(state.errors) != 0:
+                    break
+                _descend(child)
+                if len(state.errors) != 0:
+                    break
+
+        self._visit(start, state)
+        _descend(start)

fprime_gds/common/models/dictionaries.py

@@ -49,6 +49,9 @@ class Dictionaries:
         self._fw_type_name_dict = None
         self._versions = None
         self._metadata = None
+        self._dictionary_path = None
+        self._packet_spec_path = None
+        self._packet_set_name = None
 
     def load_dictionaries(self, dictionary, packet_spec, packet_set_name):
         """
@@ -59,6 +62,11 @@ class Dictionaries:
         :param packet_spec: specification for packets, or None, for packetized telemetry
         :param packet_set_name: name of packet set in case multiple are available
         """
+        # Update the "from" values
+        self._dictionary_path = dictionary
+        self._packet_spec_path = packet_spec
+        self._packet_set_name = packet_set_name
+
         if Path(dictionary).is_file() and ".json" in Path(dictionary).suffixes:
             # Events
             json_event_loader = (
@@ -204,6 +212,21 @@ class Dictionaries:
         for legacy reasons. New code should use the metadata property."""
         return self._metadata
 
+    @property
+    def dictionary_path(self):
+        """ Dictionary Path """
+        return self._dictionary_path
+
+    @property
+    def packet_spec_path(self):
+        """ Dictionary Path """
+        return self._packet_spec_path
+    
+    @property
+    def packet_set_name(self):
+        """ Dictionary Path """
+        return self._packet_set_name
+
     @property
     def packet(self):
         """Packet dictionary"""

fprime_gds/common/pipeline/standard.py

@@ -239,3 +239,8 @@ class StandardPipeline:
         :return: filing compositions
         """
         return self.__filing
+
+    @property
+    def dictionaries(self):
+        """ Dictionaries member """
+        return self.__dictionaries

fprime_gds/common/testing_fw/api.py

@@ -71,7 +71,7 @@ class IntegrationTestAPI(DataHandler):
 
         # Copy dictionaries and binary file to output directory
         if logpath is not None:
-            base_dir = Path(self.pipeline.dictionary_path).parents[1]
+            base_dir = Path(self.dictionaries.dictionary_path).parents[1]
             for subdir in ["bin", "dict"]:
                 dir_path = base_dir / subdir
                 if dir_path.is_dir():
@@ -85,6 +85,13 @@ class IntegrationTestAPI(DataHandler):
         # Used by the data_callback method to detect if events have been received out of order.
         self.last_evr = None
 
+    @property
+    def dictionaries(self):
+        """ Return the dictionaries """
+        # Pipeline should not be exposed to the user, but it stores the dictionary
+        # thus delegate to it.
+        return self.pipeline.dictionaries
+
     def setup(self):
         """Set up the API, assumes pipeline is now setup"""
         self.pipeline.coders.register_event_consumer(self)

fprime_gds/executables/cli.py

@@ -318,6 +318,7 @@ class ConfigDrivenParser(ParserBase):
 
     DEFAULT_CONFIGURATION_PATH = Path("fprime-gds.yml")
 
+
     @classmethod
     def set_default_configuration(cls, path: Path):
         """Set path for (global) default configuration file
@@ -413,6 +414,14 @@ class ConfigDrivenParser(ParserBase):
             print(f"[INFO] Reading command-line configuration from: {args.config}")
             with open(args.config, "r") as file_handle:
                 try:
+                    relative_base = args.config.parent.absolute()
+
+                    def path_constructor(loader, node):
+                        """ Processes !PATH annotations as relative to current file """
+                        calculated_path = relative_base / loader.construct_scalar(node)
+                        return calculated_path
+
+                    yaml.SafeLoader.add_constructor("!PATH", path_constructor)
                     loaded = yaml.safe_load(file_handle)
                     args.config_values = loaded if loaded is not None else {}
                 except Exception as exc:

fprime_gds/executables/run_deployment.py

@@ -11,6 +11,7 @@ import webbrowser
 from fprime_gds.executables.cli import (
     BinaryDeployment,
     ConfigDrivenParser,
+    CompositeParser,
     CommParser,
     GdsParser,
     ParserBase,
@@ -104,6 +105,7 @@ def launch_html(parsed_args):
     Return:
         launched process
     """
+    composite_parser = CompositeParser([StandardPipelineParser, ConfigDrivenParser])
     reproduced_arguments = StandardPipelineParser().reproduce_cli_args(parsed_args)
     if "--log-directly" not in reproduced_arguments:
         reproduced_arguments += ["--log-directly"]