fprime-gds 4.0.1__tar.gz → 4.0.2a2__tar.gz

{fprime_gds-4.0.1 → fprime_gds-4.0.2a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fprime-gds
-Version: 4.0.1
+Version: 4.0.2a2
 Summary: F Prime Flight Software Ground Data System layer
 Author-email: Michael Starch <Michael.D.Starch@jpl.nasa.gov>, Thomas Boyer-Chammard <Thomas.Boyer.Chammard@jpl.nasa.gov>
 License: 

{fprime_gds-4.0.1 → fprime_gds-4.0.2a2}/pyproject.toml

@@ -67,6 +67,7 @@ fprime-dp-write = "fprime_gds.executables.data_product_writer:main"
 fprime-gds = "fprime_gds.executables.run_deployment:main"
 fprime-prm-write = "fprime_gds.common.tools.params:main"
 fprime-fpyc = "fprime_gds.common.fpy.main:main"
+fprime-merge-dictionary = "fprime_gds.executables.dictionary_merge:main"
 
 # For Pytest fixtures
 [project.entry-points."pytest11"]

{fprime_gds-4.0.1 → fprime_gds-4.0.2a2}/src/fprime_gds/common/decoders/ch_decoder.py

@@ -41,7 +41,7 @@ class ChDecoder(Decoder):
 
         if config is None:
             # Retrieve singleton for the configs
-            config = config_manager.ConfigManager().get_instance()
+            config = config_manager.ConfigManager.get_instance()
 
         self.__dict = ch_dict
         self.id_obj = config.get_type("FwChanIdType")

{fprime_gds-4.0.1 → fprime_gds-4.0.2a2}/src/fprime_gds/common/decoders/event_decoder.py

@@ -43,7 +43,7 @@ class EventDecoder(decoder.Decoder):
 
         if config is None:
             # Retrieve defaults for the configs
-            config = config_manager.ConfigManager().get_instance()
+            config = config_manager.ConfigManager.get_instance()
 
         self.__dict = event_dict
         self.id_obj = config.get_type("FwEventIdType")

{fprime_gds-4.0.1 → fprime_gds-4.0.2a2}/src/fprime_gds/common/decoders/pkt_decoder.py

@@ -41,7 +41,7 @@ class PktDecoder(ChDecoder):
             An initialized PktDecoder object
         """
         if config is None:
-            config = config_manager.ConfigManager().get_instance()
+            config = config_manager.ConfigManager.get_instance()
         super().__init__(ch_dict, config)
 
         self.__dict = pkt_name_dict

{fprime_gds-4.0.1 → fprime_gds-4.0.2a2}/src/fprime_gds/common/distributor/distributor.py

@@ -45,7 +45,7 @@ class Distributor(DataHandler):
         """
         if config is None:
             # Retrieve singleton for the configs, or defaults if singleton unused
-            config = config_manager.ConfigManager().get_instance()
+            config = config_manager.ConfigManager.get_instance()
 
         self.__decoders = {key.name: [] for key in list(data_desc_type.DataDescType)}
 

{fprime_gds-4.0.1 → fprime_gds-4.0.2a2}/src/fprime_gds/common/encoders/cmd_encoder.py

@@ -68,7 +68,7 @@ class CmdEncoder(encoder.Encoder):
         """
 
         if config is None:
-            config = config_manager.ConfigManager().get_instance()
+            config = config_manager.ConfigManager.get_instance()
         super().__init__(config)
 
         self.len_obj = self.config.get_type("msg_len")

{fprime_gds-4.0.1 → fprime_gds-4.0.2a2}/src/fprime_gds/common/encoders/encoder.py

@@ -49,7 +49,7 @@ class Encoder(
         super().__init__()
         if config is None:
             # Retrieve defaults for the configs
-            config = ConfigManager()
+            config = ConfigManager.get_instance()
         self.config = config
 
     def data_callback(self, data, sender=None):

{fprime_gds-4.0.1 → fprime_gds-4.0.2a2}/src/fprime_gds/common/encoders/seq_writer.py

@@ -24,7 +24,7 @@ class SeqBinaryWriter:
         Constructor
         """
         if config is None:
-            config = config_manager.ConfigManager().get_instance()
+            config = config_manager.ConfigManager.get_instance()
 
         self.__fd = None
         self.__timebase = timebase

{fprime_gds-4.0.1 → fprime_gds-4.0.2a2}/src/fprime_gds/common/gds_cli/base_commands.py

@@ -10,7 +10,7 @@ from typing import Iterable
 
 import fprime_gds.common.gds_cli.filtering_utils as filtering_utils
 import fprime_gds.common.gds_cli.test_api_utils as test_api_utils
-from fprime_gds.common.pipeline.dictionaries import Dictionaries
+from fprime_gds.common.models.dictionaries import Dictionaries
 from fprime_gds.common.testing_fw import predicates
 from fprime_gds.common.testing_fw.api import IntegrationTestAPI
 from fprime_gds.executables.cli import StandardPipelineParser

{fprime_gds-4.0.1 → fprime_gds-4.0.2a2}/src/fprime_gds/common/gds_cli/channels.py

@@ -7,7 +7,7 @@ from typing import Iterable
 import fprime_gds.common.gds_cli.test_api_utils as test_api_utils
 from fprime_gds.common.data_types.ch_data import ChData
 from fprime_gds.common.gds_cli.base_commands import QueryHistoryCommand
-from fprime_gds.common.pipeline.dictionaries import Dictionaries
+from fprime_gds.common.models.dictionaries import Dictionaries
 from fprime_gds.common.testing_fw import predicates
 from fprime_gds.common.testing_fw.api import IntegrationTestAPI
 

{fprime_gds-4.0.1 → fprime_gds-4.0.2a2}/src/fprime_gds/common/gds_cli/command_send.py

@@ -9,7 +9,7 @@ from fprime.common.models.serialize.type_exceptions import NotInitializedExcepti
 
 import fprime_gds.common.gds_cli.test_api_utils as test_api_utils
 from fprime_gds.common.gds_cli.base_commands import BaseCommand
-from fprime_gds.common.pipeline.dictionaries import Dictionaries
+from fprime_gds.common.models.dictionaries import Dictionaries
 from fprime_gds.common.templates.cmd_template import CmdTemplate
 from fprime_gds.common.testing_fw import predicates
 from fprime_gds.common.testing_fw.api import IntegrationTestAPI

{fprime_gds-4.0.1 → fprime_gds-4.0.2a2}/src/fprime_gds/common/gds_cli/events.py

@@ -7,7 +7,7 @@ from typing import Iterable
 import fprime_gds.common.gds_cli.test_api_utils as test_api_utils
 from fprime_gds.common.data_types.event_data import EventData
 from fprime_gds.common.gds_cli.base_commands import QueryHistoryCommand
-from fprime_gds.common.pipeline.dictionaries import Dictionaries
+from fprime_gds.common.models.dictionaries import Dictionaries
 from fprime_gds.common.testing_fw import predicates
 from fprime_gds.common.testing_fw.api import IntegrationTestAPI
 

{fprime_gds-4.0.1 → fprime_gds-4.0.2a2}/src/fprime_gds/common/handlers.py

@@ -37,6 +37,13 @@ class DataHandlerPlugin(DataHandler, abc.ABC):
     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.
     """
+    def __init__(self, **kwargs):
+        """ Initialize """
+        self.publisher = None
+
+    def set_publisher(self, publisher):
+        """ Set publishing pipeline """
+        self.publisher = publisher
 
     @abc.abstractmethod
     def get_handled_descriptors() -> List[str]:
@@ -113,3 +120,52 @@ class HandlerRegistrar(abc.ABC):
         """
         for registrant in self._registrants:
             registrant.data_callback(data, sender)
+
+
+class MappedRegistrar(abc.ABC):
+    """ Class to register a mapping """
+
+    def __init__(self):
+        """ Initialize an empty registrant list  """
+        super().__init__()
+        self._registrants = {}
+
+    def register(self, id, registrant):
+        """
+        Register a registrant with this registrar associated with the ID. Will be stored and called back when asked to
+        send data to all the handlers registered at the id
+
+        :param id: id to register to
+        :param registrant: handler to register
+        """
+        self._registrants[id] = self._registrants.get(id, HandlerRegistrar())
+        self._registrants[id].register(registrant)
+
+    def deregister(self, id, registrant):
+        """
+        Remove a registrant from the registrar such that it will not be called back later. Note: ignores invalid
+        removals by trapping the error, as the desired effect is already satisfied.
+
+        :param id: id to register to
+        :param registrant: registrant to remove
+        :return: True if found, False if not. May safely be ignored.
+        """
+        try:
+            self._registrants[id].deregister(registrant)
+            return True
+        except (ValueError, KeyError):
+            return False
+
+    def send_to_all(self, id, data, sender=None):
+        """
+        Sends the given data to all registrants at id.
+
+        :param id: id to send to 
+        :param data: data to send back to registrants
+        :param sender: (optional) sender to pass to data_callback
+        """
+        try:
+            self._registrants[id].send_to_all(data, sender)
+        except KeyError:
+            print("KeyERROR")
+            pass

{fprime_gds-4.0.1/src/fprime_gds/common/pipeline → fprime_gds-4.0.2a2/src/fprime_gds/common/models}/dictionaries.py

@@ -57,6 +57,7 @@ class Dictionaries:
 
         :param dictionary: dictionary path used for loading 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
         """
         if Path(dictionary).is_file() and ".json" in Path(dictionary).suffixes:
             # Events

fprime_gds-4.0.2a2/src/fprime_gds/common/pipeline/publishing.py

@@ -0,0 +1,111 @@
+"""
+publishing.py:
+
+This file contains a basic publishing pipeline. It reads and writes data bound for the GDS.
+
+:author: lestarch
+"""
+
+
+from typing import Type
+
+from fprime_gds.common.data_types.ch_data import ChData
+from fprime_gds.common.data_types.event_data import EventData
+from fprime_gds.common.encoders.ch_encoder import ChEncoder
+from fprime_gds.common.encoders.event_encoder import EventEncoder
+from fprime_gds.common.transport import RoutingTag, ThreadedTCPSocketClient
+from fprime_gds.common.utils.config_manager import ConfigManager
+
+from fprime_gds.common.handlers import DataHandler, MappedRegistrar
+from ..models import dictionaries
+
+
+class PublishingPipeline(DataHandler, MappedRegistrar):
+    """ Pipeline for publishing
+
+    This pipeline sets up the following process:
+
+    Data -> Encoder -> Client -> <wire>
+    """
+    DEFAULT_ENCODERS = {
+        "FW_PACKET_LOG": EventEncoder,
+        "FW_PACKET_TELEM": ChEncoder
+    }
+
+    def __init__(self):
+        """
+        Set core variables to None or their composition handlers.
+        """
+        super().__init__()
+        self.client_socket = None
+
+        self._dictionaries = dictionaries.Dictionaries()
+        self._transport_type = ThreadedTCPSocketClient
+
+    def setup(self, dictionaries):
+        """ Set up the publishing pipeline """
+        self._dictionaries = dictionaries
+        self.client_socket = self.__transport_type()
+        config = ConfigManager.get_instance()
+    
+        for id, encoder_class in self.DEFAULT_ENCODERS.items():
+            encoder_instance = encoder_class(config=config)
+            encoder_instance.register(self.client_socket)
+            self.register(id, encoder_instance)
+
+    def data_callback(self, data, sender=None):
+        """ Publish data """
+        if isinstance(data, ChData):
+            self.send_to_all("FW_PACKET_TELEM", data)
+        elif isinstance(data, EventData):
+            self.send_to_all("FW_PACKET_LOG", data)
+        return super().data_callback(data, sender)
+    
+    def publish_channel(self, name, value, time):
+        """ Publish channel value using name, time, and value
+
+        Looks up the channel template in the dictionary and constructs a new channel object given the time and value.
+        This ChData object is then sent into the outgoing "publish" pipeline.
+
+        """
+        template = self._dictionaries.channel_name[name]
+        copied_value_object = template.get_type_obj()(value)
+        copied_value_object.val = value
+        object = ChData(copied_value_object, time, template)
+        return self.data_callback(object, self)
+
+    @property
+    def transport_implementation(self):
+        """Get implementation type for transport"""
+        return self.__transport_type
+
+    @transport_implementation.setter
+    def transport_implementation(self, transport_type: Type[None]):
+        """Set the implementation type for transport"""
+        assert (
+            self.client_socket is None
+        ), "Cannot setup transport implementation type after setup"
+        self.__transport_type = transport_type
+
+
+    def connect(
+        self, connection_uri, incoming_tag=RoutingTag.GUI, outgoing_tag=RoutingTag.GUI
+    ):
+        """Connects to the middleware layer
+
+        Connect to the middleware layer. This connection needs to identify if the object is a a FSW or GUI client. The
+        default connection acts as a GUI client sending back to the GUI.
+
+        Args:
+            connection_uri: URI of the connection to make
+            incoming_tag: this pipeline will act as supplied tag (GUI, FSW). Default: GUI
+            outgoing_tag: this pipeline will produce data for supplied tag (FSW, GUI). Default: FSW
+        """
+        self.client_socket.connect(connection_uri, incoming_tag, outgoing_tag)
+
+    def disconnect(self):
+        """ Disconnect from the client socket """
+        if self.client_socket is not None:
+            self.client_socket.disconnect()
+
+    

{fprime_gds-4.0.1 → fprime_gds-4.0.2a2}/src/fprime_gds/common/pipeline/standard.py

@@ -23,7 +23,7 @@ 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
+from . import encoding, files, histories
 
 
 class StandardPipeline:
@@ -49,7 +49,7 @@ class StandardPipeline:
         self.up_store = None
         self.down_store = None
 
-        self.__dictionaries = dictionaries.Dictionaries()
+        self.__dictionaries = None
         self.__coders = encoding.EncodingDecoding()
         self.__histories = histories.Histories()
         self.__filing = files.Filing()
@@ -58,25 +58,23 @@ class StandardPipeline:
     def setup(
         self,
         config: ConfigManager,
-        dictionary,
+        dictionaries,
         file_store,
         logging_prefix=None,
-        packet_spec=None,
-        packet_set_name=None,
+        data_logging_enabled=True
     ):
         """
         Setup the standard pipeline for moving data from the middleware layer through the GDS layers using the standard
         patterns. This allows just registering the consumers, and invoking 'setup' all other of the GDS support layer.
 
         :param config: config object used when constructing the pipeline.
-        :param dictionary: dictionary path. Used to setup loading of dictionaries.
+        :param dictionaries: dictionary path. Used to setup loading of dictionaries.
         :param file_store: uplink/downlink storage directory
         :param logging_prefix: logging prefix. Defaults to not logging at all.
         :param packet_spec: location of packetized telemetry XML specification.
         """
-        assert (
-            dictionary is not None and Path(dictionary).is_file()
-        ), f"Dictionary {dictionary} does not exist"
+        self.distributor = fprime_gds.common.distributor.distributor.Distributor(config)
+        self.client_socket = self.__transport_type()
         # File storage configuration for uplink and downlink
         self.up_store = Path(file_store) / "fprime-uplink"
         self.down_store = Path(file_store) / "fprime-downlink"
@@ -87,18 +85,7 @@ class StandardPipeline:
             raise PermissionError(
                 f"{file_store} is not writable. Fix permissions or change storage directory with --file-storage-directory."
             )
-        self.dictionary_path = Path(dictionary)
-        # Loads the distributor and client socket
-        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, 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.__dictionaries = dictionaries
         self.coders.setup_coders(
             self.dictionaries, self.distributor, self.client_socket, config
         )
@@ -113,7 +100,7 @@ class StandardPipeline:
         # Register distributor to client socket
         self.client_socket.register(self.distributor)
         # Final setup step is to make a logging directory, and register in the logger
-        if logging_prefix:
+        if logging_prefix and data_logging_enabled:
             self.setup_logging(logging_prefix)
 
     @property

{fprime_gds-4.0.1 → fprime_gds-4.0.2a2}/src/fprime_gds/common/testing_fw/api.py

@@ -7,6 +7,7 @@ telemetry and dictionaries.
 
 :author: koran
 """
+
 import signal
 import time
 from pathlib import Path
@@ -71,11 +72,12 @@ 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]
-            for subdir in ['bin', 'dict']:
+            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)
+                    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()
@@ -84,7 +86,7 @@ class IntegrationTestAPI(DataHandler):
         self.last_evr = None
 
     def setup(self):
-        """ Set up the API, assumes pipeline is now setup """
+        """Set up the API, assumes pipeline is now setup"""
         self.pipeline.coders.register_event_consumer(self)
 
     def teardown(self):
@@ -162,10 +164,10 @@ class IntegrationTestAPI(DataHandler):
             fail_color = TestLogger.ORANGE
 
         if value:
-            ast_msg = f'{ast_msg} succeeded: {msg}'
+            ast_msg = f"{ast_msg} succeeded: {msg}"
             self.__log(ast_msg, TestLogger.GREEN)
         else:
-            ast_msg = f'{ast_msg} failed: {msg}'
+            ast_msg = f"{ast_msg} failed: {msg}"
             self.__log(ast_msg, fail_color)
 
         if not expect:
@@ -209,7 +211,7 @@ class IntegrationTestAPI(DataHandler):
             self.event_history.clear()
             self.telemetry_history.clear()
             msg = "Clearing Test Histories"
-            
+
         self.__log(msg, TestLogger.WHITE)
         self.command_history.clear()
 
@@ -239,9 +241,9 @@ class IntegrationTestAPI(DataHandler):
         dictionary = str(self.pipeline.dictionary_path)
 
         try:
-            with open(dictionary, 'r') as file:
+            with open(dictionary, "r") as file:
                 data = json.load(file)
-            return data['metadata'].get("deploymentName")
+            return data["metadata"].get("deploymentName")
         except FileNotFoundError:
             msg = f"Error: File not found at path: {dictionary}"
             self.__log(msg, TestLogger.YELLOW)
@@ -273,7 +275,7 @@ class IntegrationTestAPI(DataHandler):
             count, channels=channels, history=history, start=start, timeout=timeout
         )
         if not result:
-            msg = f'Failed to detect any data flow for {timeout} s.'
+            msg = f"Failed to detect any data flow for {timeout} s."
             self.__log(msg, TestLogger.RED)
             assert False, msg
         self.remove_telemetry_subhistory(history)
@@ -300,7 +302,7 @@ class IntegrationTestAPI(DataHandler):
         config_file = self.get_config_file_path()
 
         try:
-            with open(config_file, 'r') as file:
+            with open(config_file, "r") as file:
                 result = json.load(file)
             return result
         except FileNotFoundError:
@@ -351,7 +353,7 @@ class IntegrationTestAPI(DataHandler):
         if data:
             try:
                 filepath = data["Svc.PrmDb.filename"]
-                if filepath.startswith('/'):
+                if filepath.startswith("/"):
                     return filepath
                 else:
                     msg = f"Error: {filepath} did not start with a forward slash"
@@ -549,7 +551,15 @@ class IntegrationTestAPI(DataHandler):
             return self.await_event_sequence(events, start=start, timeout=timeout)
         return self.await_event(events, start=start, timeout=timeout)
 
-    def send_and_assert_command(self, command, args=[], max_delay=None, timeout=5, events=None, commander="cmdDisp"):
+    def send_and_assert_command(
+        self,
+        command,
+        args=[],
+        max_delay=None,
+        timeout=5,
+        events=None,
+        commander="cmdDisp",
+    ):
         """
         This helper will send a command and verify that the command was dispatched and completed
         within the F' deployment. This helper can retroactively check that the delay between
@@ -566,7 +576,9 @@ class IntegrationTestAPI(DataHandler):
             returns a list of the EventData objects found by the search
         """
         cmd_id = self.translate_command_name(command)
-        dispatch = [self.get_event_pred(f"{commander}.OpCodeDispatched", [cmd_id, None])]
+        dispatch = [
+            self.get_event_pred(f"{commander}.OpCodeDispatched", [cmd_id, None])
+        ]
         complete = [self.get_event_pred(f"{commander}.OpCodeCompleted", [cmd_id])]
         events = dispatch + (events if events else []) + complete
         results = self.send_and_assert_event(command, args, events, timeout=timeout)
@@ -576,7 +588,6 @@ class IntegrationTestAPI(DataHandler):
             assert delay < max_delay, msg
         return results
 
-
     ######################################################################################
     #   Command Asserts
     ######################################################################################
@@ -652,14 +663,18 @@ class IntegrationTestAPI(DataHandler):
         """
         if isinstance(channel, str):
             ch_dict = self.pipeline.dictionaries.channel_name
-            matching = [ch_dict[name].get_id() for name in ch_dict.keys() if name.endswith(f".{channel}")] 
+            matching = [
+                ch_dict[name].get_id()
+                for name in ch_dict.keys()
+                if name.endswith(f".{channel}")
+            ]
             if channel in ch_dict:
                 return ch_dict[channel].get_id()
             if force_component or not matching:
                 msg = f"The telemetry mnemonic, {channel}, wasn't in the dictionary"
                 raise KeyError(msg)
             return matching
-        
+
         ch_dict = self.pipeline.dictionaries.channel_id
         if channel in ch_dict:
             return channel
@@ -689,7 +704,11 @@ class IntegrationTestAPI(DataHandler):
 
         if not predicates.is_predicate(channel) and channel is not None:
             channel = self.translate_telemetry_name(channel, force_component=False)
-            channel = predicates.is_a_member_of(channel) if isinstance(channel, list) else predicates.equal_to(channel)
+            channel = (
+                predicates.is_a_member_of(channel)
+                if isinstance(channel, list)
+                else predicates.equal_to(channel)
+            )
 
         if not predicates.is_predicate(value) and value is not None:
             value = predicates.equal_to(value)
@@ -873,7 +892,11 @@ class IntegrationTestAPI(DataHandler):
         """
         if isinstance(event, str):
             event_dict = self.pipeline.dictionaries.event_name
-            matching = [event_dict[name].get_id() for name in event_dict.keys() if name.endswith(f".{event}")] 
+            matching = [
+                event_dict[name].get_id()
+                for name in event_dict.keys()
+                if name.endswith(f".{event}")
+            ]
             if event in event_dict:
                 return event_dict[event].get_id()
             if force_component or not matching:
@@ -910,7 +933,11 @@ class IntegrationTestAPI(DataHandler):
 
         if not predicates.is_predicate(event) and event is not None:
             event = self.translate_event_name(event, force_component=False)
-            event = predicates.is_a_member_of(event) if isinstance(event, list) else predicates.equal_to(event)
+            event = (
+                predicates.is_a_member_of(event)
+                if isinstance(event, list)
+                else predicates.equal_to(event)
+            )
 
         if not predicates.is_predicate(args) and args is not None:
             args = predicates.args_predicate(args)
@@ -1097,6 +1124,38 @@ class IntegrationTestAPI(DataHandler):
         self.__assert_pred("Event count", count_pred, len(results), msg)
         return results
 
+    ######################################################################################
+    #   File Uplink functions
+    ######################################################################################
+
+    def uplink_file_and_await_completion(self, file_path, destination=None, timeout=10):
+        """
+        This function will upload a file and wait for its completion, awaiting for the
+        FileReceived event.
+
+        Args:
+            file_path: the path to the file to upload
+            destination: the destination path for the uploaded file
+            timeout: the maximum time to wait for the event
+        """
+        self.uplink_file(file_path, destination)
+        self.await_event("FileReceived", timeout=timeout)
+
+    def uplink_file(self, file_path, destination=None):
+        """
+        This function will upload a file to the specified location.
+
+        Note: this will simply put the file on the outgoing queue. No guarantee
+        is made on when the file will be delivered. To wait for the completion of
+        the file uplink, use uplink_file_and_await_completion()
+
+        Args:
+            file_path: the path to the file to upload
+        """
+        uplink_file = Path(self.pipeline.up_store) / Path(file_path).name
+        shutil.copy2(file_path, uplink_file)
+        self.pipeline.files.uplinker.enqueue(str(uplink_file), destination)
+
     ######################################################################################
     #   History Searches
     ######################################################################################
@@ -1207,11 +1266,13 @@ class IntegrationTestAPI(DataHandler):
                             return searcher.get_return_value()
                     time.sleep(0.1)
             except self.TimeoutException:
-                self.__log(f'{name} timed out and ended unsuccessfully.', TestLogger.YELLOW)
+                self.__log(
+                    f"{name} timed out and ended unsuccessfully.", TestLogger.YELLOW
+                )
             finally:
                 signal.alarm(0)
         else:
-            self.__log(f'{name} ended unsuccessfully.', TestLogger.YELLOW)
+            self.__log(f"{name} ended unsuccessfully.", TestLogger.YELLOW)
         return searcher.get_return_value()
 
     def find_history_item(self, search_pred, history, start=None, timeout=0):
@@ -1365,7 +1426,9 @@ class IntegrationTestAPI(DataHandler):
                     self.log(f"Count search counted another item: {item}")
                     self.ret_val.append(item)
                     if self.count_pred(len(self.ret_val)):
-                        msg = f"Count search found a correct amount: {len(self.ret_val)}"
+                        msg = (
+                            f"Count search found a correct amount: {len(self.ret_val)}"
+                        )
                         self.log(msg, TestLogger.YELLOW)
                         return True
                 return False

{fprime_gds-4.0.1 → fprime_gds-4.0.2a2}/src/fprime_gds/common/utils/config_manager.py

@@ -40,7 +40,7 @@ class ConfigBadTypeException(Exception):
             config_name (string): Name of the config containing the bad type
             type_str (string): Bad type string that caused the error
         """
-        print(f"Invalid type string {type_str} read in configuration {config_name}")
+        super().__init__(f"Invalid type string {type_str} read in configuration {config_name}")
 
 
 class ConfigManager(configparser.ConfigParser):