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

fprime_gds/common/logger/__init__.py

@@ -13,7 +13,7 @@ import sys
 INITIALIZED = False
 
 
-def configure_py_log(directory=None, filename=sys.argv[0], mirror_to_stdout=False):
+def configure_py_log(directory=None, filename=sys.argv[0], mirror_to_stdout=False, log_level="INFO"):
     """
     Configure the python logging. If logdir is supplied, our logs will go in that directory as a log file. Otherwise,
     logs will go to the CLI.
@@ -40,6 +40,6 @@ def configure_py_log(directory=None, filename=sys.argv[0], mirror_to_stdout=Fals
     for handler in handlers:
         handler.setFormatter(formatter)
         logging.getLogger().addHandler(handler)
-    logging.getLogger().setLevel(logging.INFO)
+    logging.getLogger().setLevel(log_level)
     logging.info("Logging system initialized!")
     INITIALIZED = True

fprime_gds/common/pipeline/dictionaries.py

@@ -14,6 +14,8 @@ from pathlib import Path
 import fprime_gds.common.loaders.ch_xml_loader
 import fprime_gds.common.loaders.cmd_xml_loader
 import fprime_gds.common.loaders.event_xml_loader
+import fprime_gds.common.loaders.fw_type_json_loader
+import fprime_gds.common.loaders.pkt_json_loader
 import fprime_gds.common.loaders.pkt_xml_loader
 
 # JSON Loaders
@@ -21,7 +23,6 @@ import fprime_gds.common.loaders.ch_json_loader
 import fprime_gds.common.loaders.cmd_json_loader
 import fprime_gds.common.loaders.event_json_loader
 
-
 class Dictionaries:
     """
     Dictionaries class to encapsulate the many different dictionaries used in the system. This includes the following
@@ -45,10 +46,11 @@ class Dictionaries:
         self._event_name_dict = None
         self._channel_name_dict = None
         self._packet_dict = None
+        self._fw_type_name_dict = None
         self._versions = None
         self._metadata = None
 
-    def load_dictionaries(self, dictionary, packet_spec):
+    def load_dictionaries(self, dictionary, packet_spec, packet_set_name):
         """
         Loads the dictionaries based on the dictionary path supplied. Optional packet_spec is allowed to specify the
         definitions of packets.
@@ -75,6 +77,11 @@ class Dictionaries:
             )
             self._channel_name_dict = json_channel_loader.get_name_dict(None)
             self._channel_id_dict = json_channel_loader.get_id_dict(None)
+            # Fw Types
+            fw_types_loader = fprime_gds.common.loaders.fw_type_json_loader.FwTypeJsonLoader(
+                dictionary
+            )
+            self._fw_type_name_dict = fw_types_loader.get_name_dict(None)
             # Metadata
             self._versions = json_event_loader.get_versions()
             self._metadata = json_event_loader.get_metadata().copy()
@@ -126,6 +133,20 @@ class Dictionaries:
             self._packet_dict = packet_loader.get_id_dict(
                 packet_spec, self._channel_name_dict
             )
+        # Otherwise use JSON dictionary to attempt automatic packet loading
+        elif self._metadata["dictionary_type"] == "json":
+            packet_loader = fprime_gds.common.loaders.pkt_json_loader.PktJsonLoader(dictionary)
+            if packet_set_name is None:
+                names = packet_loader.get_packet_set_names(None)
+                if len(names) == 0:
+                    self._packet_dict = None
+                    return
+                elif len(names) > 1:
+                    raise Exception("[ERROR] Multiple packet sets, must set --packet-set-name")
+                packet_set_name = names[0]
+            self._packet_dict = packet_loader.get_id_dict(
+                None, packet_set_name, self._channel_name_dict
+            )
         else:
             self._packet_dict = None
 
@@ -158,6 +179,11 @@ class Dictionaries:
     def channel_name(self):
         """Channel dictionary by name"""
         return self._channel_name_dict
+    
+    @property
+    def fw_type_name(self):
+        """Fw type name dictionary by name"""
+        return self._fw_type_name_dict
 
     @property
     def project_version(self):

fprime_gds/common/pipeline/encoding.py

@@ -6,6 +6,7 @@ and decoding into a single component that the be composed into the standard pipe
 
 @mstarch
 """
+
 import fprime_gds.common.decoders.ch_decoder
 import fprime_gds.common.decoders.event_decoder
 import fprime_gds.common.decoders.file_decoder
@@ -130,6 +131,24 @@ class EncodingDecoding:
         """
         return self.channel_decoder.deregister(consumer)
 
+    def register_file_consumer(self, consumer):
+        """
+        Registers a consumer with the file decoder.
+
+        :param consumer: consumer of file packets
+        """
+        self.file_decoder.register(consumer)
+
+    def remove_file_consumer(self, consumer):
+        """
+        Removes a consumer from the file decoder. Will raise an error if the history was not
+        previously registered.
+
+        :param consumer: consumer of channels
+        :return: a boolean indicating if the consumer was removed.
+        """
+        return self.file_decoder.deregister(consumer)
+
     def register_command_consumer(self, consumer):
         """
         Registers a history with the standard pipeline.

fprime_gds/common/pipeline/histories.py

@@ -6,6 +6,7 @@ to compose in this code.
 
 @author mstarch
 """
+
 from typing import Type
 
 from fprime_gds.common.history.history import History
@@ -37,6 +38,9 @@ class Histories:
         :param coders: coders object to register histories with
         """
         self.coders = coders
+        # Allow implementation type to disable histories
+        if self._implementation_type is None:
+            return
         # Create histories, RAM histories for now
         self.commands = self._implementation_type()
         self.events = self._implementation_type()

fprime_gds/common/pipeline/standard.py

@@ -8,6 +8,7 @@ below.
 
 :author: lestarch
 """
+
 import datetime
 import os.path
 from pathlib import Path
@@ -19,6 +20,7 @@ import fprime_gds.common.data_types.cmd_data
 import fprime_gds.common.distributor.distributor
 import fprime_gds.common.logger.data_logger
 from fprime_gds.common.transport import RoutingTag, ThreadedTCPSocketClient
+from fprime_gds.common.utils.config_manager import ConfigManager
 
 # Local imports for the sake of composition
 from . import dictionaries, encoding, files, histories
@@ -54,7 +56,13 @@ class StandardPipeline:
         self.__transport_type = ThreadedTCPSocketClient
 
     def setup(
-        self, config, dictionary, file_store, logging_prefix=None, packet_spec=None
+        self,
+        config: ConfigManager,
+        dictionary,
+        file_store,
+        logging_prefix=None,
+        packet_spec=None,
+        packet_set_name=None,
     ):
         """
         Setup the standard pipeline for moving data from the middleware layer through the GDS layers using the standard
@@ -84,7 +92,13 @@ class StandardPipeline:
         self.distributor = fprime_gds.common.distributor.distributor.Distributor(config)
         self.client_socket = self.__transport_type()
         # Setup dictionaries encoders and decoders
-        self.dictionaries.load_dictionaries(self.dictionary_path, packet_spec)
+        self.dictionaries.load_dictionaries(
+            self.dictionary_path, packet_spec, packet_set_name
+        )        
+        # Update config to use Fw types defined in the JSON dictionary
+        if self.dictionaries.fw_type_name:
+            for fw_type_name, fw_type in self.dictionaries.fw_type_name.items():
+                config.set("types", fw_type_name, fw_type)
         self.coders.setup_coders(
             self.dictionaries, self.distributor, self.client_socket, config
         )

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/common/templates/prm_template.py

@@ -0,0 +1,81 @@
+"""
+@brief Params Template class
+
+Instances of this class describe a parameter of a component instance (not 
+including a specific value)
+
+@date Created January 27, 2025
+@author Zimri Leisher
+
+@bug Hopefully none
+"""
+
+from fprime.common.models.serialize.type_base import BaseType
+from fprime.common.models.serialize.type_exceptions import TypeMismatchException
+
+from . import data_template
+
+
+class PrmTemplate(data_template.DataTemplate):
+    """Class for param templates that describe parameters of component instances"""
+
+    def __init__(
+        self,
+        prm_id: int,
+        prm_name: str,
+        comp_name: str,
+        prm_type_obj: BaseType,
+        prm_default_val,
+    ):
+        """
+        Constructor
+
+        Args:
+            prm_id: the id of the parameter
+            prm_name: the name of the parameter
+            comp_name: the name of the component instance owning this parameter
+            prm_type_obj: the instance of BaseType corresponding to the type of this parameter
+            prm_default_val: the default value of this parameter, in raw JSON form
+        """
+        super().__init__()
+        # Make sure correct types are passed
+        if not isinstance(prm_id, int):
+            raise TypeMismatchException(int, type(prm_id))
+
+        if not isinstance(prm_name, str):
+            raise TypeMismatchException(str, type(prm_name))
+
+        if not isinstance(comp_name, str):
+            raise TypeMismatchException(str, type(comp_name))
+
+        if not issubclass(prm_type_obj, BaseType):
+            raise TypeMismatchException(BaseType, prm_type_obj)
+
+        # prm_default_val is an arbitrary type, likely a primitive or dict
+
+        self.prm_id = prm_id
+        self.prm_name = prm_name
+        self.comp_name = comp_name
+        self.prm_type_obj = prm_type_obj
+        self.prm_default_val = prm_default_val
+
+    def get_full_name(self):
+        """
+        Get the full name of this param
+
+        Returns:
+            The full name (component.param) for this param
+        """
+        return f"{self.comp_name}.{self.prm_name}"
+
+    def get_id(self):
+        return self.prm_id
+
+    def get_name(self):
+        return self.prm_name
+
+    def get_comp_name(self):
+        return self.comp_name
+
+    def get_type_obj(self):
+        return self.prm_type_obj

fprime_gds/common/testing_fw/api.py

@@ -9,6 +9,9 @@ telemetry and dictionaries.
 """
 import signal
 import time
+from pathlib import Path
+import shutil
+import json
 
 from fprime.common.models.serialize.time_type import TimeType
 
@@ -28,15 +31,17 @@ class IntegrationTestAPI(DataHandler):
 
     NOW = "NOW"
 
-    def __init__(self, pipeline, logpath=None, fsw_order=True):
+    def __init__(self, pipeline, deployment_config=None, logpath=None, fsw_order=True):
         """
         Initializes API: constructs and registers test histories.
         Args:
             pipeline: a pipeline object providing access to basic GDS functionality
+            deployment_config: path to deployment configuration file
             logpath: an optional output destination for the api test log
             fsw_order: a flag to determine whether the API histories will maintain FSW time order.
         """
         self.pipeline = pipeline
+        self.deployment_config = deployment_config
 
         # these are owned by the GDS and will not be modified by the test API.
         self.aggregate_command_history = pipeline.histories.commands
@@ -63,6 +68,15 @@ class IntegrationTestAPI(DataHandler):
         # Initialize the logger
         self.logger = TestLogger(logpath) if logpath is not None else None
 
+        # Copy dictionaries and binary file to output directory
+        if logpath is not None:
+            base_dir = Path(self.pipeline.dictionary_path).parents[1]
+            for subdir in ['bin', 'dict']:
+                dir_path = base_dir / subdir
+                if dir_path.is_dir():
+                    shutil.copytree(dir_path, Path(logpath) / subdir,
+                                    dirs_exist_ok=True)
+
         # A predicate used as a filter to choose which events to log automatically
         self.event_log_filter = self.get_event_pred()
 
@@ -215,6 +229,139 @@ class IntegrationTestAPI(DataHandler):
         """
         self.event_log_filter = self.get_event_pred(event, args, severity, time_pred)
 
+    def get_deployment(self):
+        """
+        Get the deployment of the target using the loaded FSW dictionary.
+
+        Returns:
+            The name of the deployment (str) or None if not found
+        """
+        dictionary = str(self.pipeline.dictionary_path)
+
+        try:
+            with open(dictionary, 'r') as file:
+                data = json.load(file)
+            return data['metadata'].get("deploymentName")
+        except FileNotFoundError:
+            msg = f"Error: File not found at path: {dictionary}"
+            self.__log(msg, TestLogger.YELLOW)
+            return None
+        except json.JSONDecodeError as e:
+            msg = f"Error decoding JSON: {e}"
+            self.__log(msg, TestLogger.YELLOW)
+            return None
+        except Exception as e:
+            msg = f"An unexpected error occurred: {e} is an unknown key"
+            self.__log(msg, TestLogger.YELLOW)
+            return None
+
+    def wait_for_dataflow(self, count=1, channels=None, start=None, timeout=120):
+        """
+        Wait for data flow by checking for any telemetry updates within a specified timeout.
+
+        Args:
+            count: either an exact amount (int) or a predicate to specify how many objects to find
+            channels: a channel specifier or list of channel specifiers (mnemonic, ID, or predicate). All will count if None
+            start: an optional index or predicate to specify the earliest item to search
+            timeout: the number of seconds to wait before terminating the search (int)
+        """
+        if start is None:
+            start = self.get_latest_time()
+
+        history = self.get_telemetry_subhistory()
+        result = self.await_telemetry_count(
+            count, channels=channels, history=history, start=start, timeout=timeout
+        )
+        if not result:
+            msg = f'Failed to detect any data flow for {timeout} s.'
+            self.__log(msg, TestLogger.RED)
+            assert False, msg
+        self.remove_telemetry_subhistory(history)
+
+    def get_config_file_path(self):
+        """
+        Accessor for IntegrationTestAPI's deployment configuration file.
+
+        Returns:
+            path to user-specified deployment configuration file (str) or None if not defined
+        """
+        if self.deployment_config:
+            return self.deployment_config
+        else:
+            return None
+
+    def load_config_file(self):
+        """
+        Load user-specified deployment configuration JSON file.
+
+        Returns:
+            JSON object as a dictionary
+        """
+        config_file = self.get_config_file_path()
+
+        try:
+            with open(config_file, 'r') as file:
+                result = json.load(file)
+            return result
+        except FileNotFoundError:
+            msg = f"Error: File not found at path {config_file}"
+            self.__log(msg, TestLogger.RED)
+            assert False, msg
+        except json.JSONDecodeError as e:
+            msg = f"Error decoding JSON: {e}"
+            self.__log(msg, TestLogger.RED)
+            assert False, msg
+        except Exception as e:
+            msg = f"An unexpected error occurred: {e}"
+            self.__log(msg, TestLogger.RED)
+            assert False, msg
+
+    def get_mnemonic(self, comp=None, name=None):
+        """
+        Get deployment mnemonic of specified item from user-specified deployment
+        configuration file.
+
+        Args:
+            comp: qualified name of the component instance (str), i.e. "<component>.<instance>"
+            name: command, channel, or event name (str) [optional]
+        Returns:
+            deployment mnemonic of specified item (str) or native mnemonic (str) if not found
+        """
+        data = self.load_config_file()
+
+        if data:
+            try:
+                mnemonic = data[comp]
+                return f"{mnemonic}.{name}" if name else f"{mnemonic}"
+            except KeyError:
+                self.__log(f"Error: {comp} not found", TestLogger.YELLOW)
+                return f"{comp}.{name}" if name else f"{comp}"
+        else:
+            return f"{comp}.{name}" if name else f"{comp}"
+
+    def get_prm_db_path(self) -> str:
+        """
+        Get file path to parameter db from user-specified deployment configuration file.
+
+        Returns:
+            file path to parameter db (str) or None if not found
+        """
+        data = self.load_config_file()
+
+        if data:
+            try:
+                filepath = data["Svc.PrmDb.filename"]
+                if filepath.startswith('/'):
+                    return filepath
+                else:
+                    msg = f"Error: {filepath} did not start with a forward slash"
+                    self.__log(msg, TestLogger.RED)
+                    assert False, msg
+            except KeyError:
+                return None
+        else:
+            return None
+
     ######################################################################################
     #   History Functions
     ######################################################################################

fprime_gds/common/testing_fw/pytest_integration.py

@@ -15,7 +15,7 @@ Here a test (defined by starting the name with test_) uses the fprime_test_api f
 @author lestarch
 """
 import sys
-
+from pathlib import Path
 import pytest
 
 from fprime_gds.common.testing_fw.api import IntegrationTestAPI
@@ -38,7 +38,36 @@ def pytest_addoption(parser):
         # Reduce flags to only the long option (i.e. --something) form
         flags = [flag for flag in flags if flag.startswith("--")]
         parser.addoption(*flags, **specifiers)
-
+        
+    # Add an option to specify JUnit XML report file
+    parser.addoption(
+        "--junit-xml-file",
+        action="store",
+        default="report.xml",
+        help="File to store JUnit XML report. [default: %(default)s]",
+    )
+    # Add an option to enable JUnit XML report generation to a specified location
+    parser.addoption(
+        "--gen-junitxml",
+        action="store_true",
+        help="Enable JUnitXML report generation to a specified location"
+    )
+    # Add an option to specify a json config file that maps components
+    parser.addoption(
+        "--deployment-config",
+        action="store",
+        help="Path to JSON configuration file for mapping deployment components"
+    )
+
+def pytest_configure(config):
+    """ This is a hook to allow plugins and conftest files to perform initial configuration
+    
+    This hook is called for every initial conftest file after command line options have been parsed. After that, the 
+    hook is called for other conftest files as they are registered.
+    """
+    # Create a JUnit XML report file to capture the test result in a specified location
+    if config.getoption("--gen-junitxml"):
+        config.option.xmlpath = Path(config.getoption("--logs")) / config.getoption("--junit-xml-file")
 
 @pytest.fixture(scope='session')
 def fprime_test_api_session(request):
@@ -62,6 +91,7 @@ def fprime_test_api_session(request):
     pipeline_parser = StandardPipelineParser()
     pipeline = None
     api = None
+    deployment_config = None
     try:
         # Parse the command line arguments into a client connection
         arg_ns = pipeline_parser.handle_arguments(request.config.known_args_namespace, client=True)
@@ -69,8 +99,12 @@ def fprime_test_api_session(request):
         # Build a new pipeline with the parsed and processed arguments
         pipeline = pipeline_parser.pipeline_factory(arg_ns, pipeline)
 
+        # Get deployment configuration from command line arguments
+        if request.config.option.deployment_config:
+            deployment_config = request.config.option.deployment_config
+
         # Build and set up the integration test api
-        api = IntegrationTestAPI(pipeline, arg_ns.logs)
+        api = IntegrationTestAPI(pipeline, deployment_config, arg_ns.logs)
         api.setup()
 
         # Return the API. Note: the second call here-in will begin after the yield and clean-up after the test

fprime_gds/common/tools/README.md

@@ -0,0 +1,34 @@
+# FPrime GDS tools
+## fprime-prm-write
+### JSON file reference
+JSON files for the `fprime-prm-write` tool should take the following form:
+```json
+{
+    "componentInstanceOne": {
+        "parameterNameOne": "parameter value",
+        "parameterNameTwo": ["a", "b", "c"],
+        "parameterNameThree": {
+            "complexValue": [123, 456]
+        }
+    },
+    "componentInstanceTwo": {
+        "parameterNameFour": true
+    }
+}
+```
+The JSON should consist of a key-value map of component instance names to an inner key-value map. The inner key-value map should consist of parameter name-to-value map entries. The parameter values support complex FPrime types, such as nested structs, arrays or enum constants. Structs are instantiated with key-value maps, where the keys are the field names and the values are the field values. Arrays are just JSON arrays, and enum constants are represented as strings.
+
+### How to Initialize a ParamDB .dat File
+
+The `fprime-prm-write` tool can be used to create a `.dat` file compatible with the `PrmDb` component from a json file. To use, create a compatible JSON file as defined in the JSON File Reference above, and pass it in to the tool using the `dat` subcommand, like so:
+```
+fprime-prm-write dat <json file> --dictionary <path to compiled FPrime dict>
+```
+You should then have a `.dat` file which can be passed in to the `PrmDb`. Note, this `.dat` file will only have entries for the parameters specified in the JSON file. If you want it to instead have a value for all parameters which have a default value, you can add the `--defaults` option. Then, the generated `.dat` file will essentially reset all parameters back to default, except for those specified in the JSON file.
+
+### How to Create a .seq File From a Parameter JSON File
+Sometimes, you may want to update parameters while the FPrime application is running. This can be accomplished with a sequence of `_PRM_SET` commands, which the `fprime-prm-write` tool can automatically create for you. To use, create a compatible JSON file as defined in the JSON File Reference above, and pass it in to the tool using the `seq` subcommand, like so:
+```
+fprime-prm-write seq <json file> --dictionary <path to compiled FPrime dict>
+```
+You should then have a `.seq` file which can be compiled and executed by the `CmdSequencer`.