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

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/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/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/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/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/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/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/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/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/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/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/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/common/{pipeline → 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/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/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,11 +58,9 @@ 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
     ):
         """
@@ -70,14 +68,13 @@ class StandardPipeline:
         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"
@@ -88,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
         )

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):

fprime_gds/executables/apps.py

@@ -14,8 +14,8 @@ command line that will be spun into its own process.
 import subprocess
 import sys
 from abc import ABC, abstractmethod
-from argparse import Namespace
-from typing import final, List, Dict, Tuple, Type
+import argparse
+from typing import final, List, Dict, Tuple, Type, Optional
 
 from fprime_gds.plugin.definitions import gds_plugin_specification, gds_plugin
 from fprime_gds.plugin.system import Plugins
@@ -23,10 +23,13 @@ from fprime_gds.executables.cli import (
     CompositeParser,
     ParserBase,
     BareArgumentParser,
+    MiddleWareParser,
+    DictionaryParser,
     StandardPipelineParser,
     PluginArgumentParser,
 )
 from fprime_gds.common.pipeline.standard import StandardPipeline
+from fprime_gds.common.pipeline.publishing import PublishingPipeline
 
 
 class GdsBaseFunction(ABC):
@@ -40,7 +43,7 @@ class GdsBaseFunction(ABC):
     """
 
     @abstractmethod
-    def run(self):
+    def run(self, parsed_args):
         """Run the start-up function
 
         Run the start-up function unconstrained by the limitations of running in a dedicated subprocess.
@@ -110,13 +113,13 @@ class GdsApp(GdsBaseFunction):
         self.process = None
         self.arguments = arguments
 
-    def run(self):
+    def run(self, parsed_args):
         """Run the application as an isolated process
 
         GdsFunction objects require an implementation of the `run` command. This implementation will take the arguments
         provided from `get_process_invocation` function and supplies them as an invocation of the isolated subprocess.
         """
-        invocation_arguments = self.get_process_invocation()
+        invocation_arguments = self.get_process_invocation(parsed_args)
         self.process = subprocess.Popen(invocation_arguments)
 
     def wait(self, timeout=None):
@@ -137,7 +140,9 @@ class GdsApp(GdsBaseFunction):
         return self.process.returncode
 
     @abstractmethod
-    def get_process_invocation(self) -> List[str]:
+    def get_process_invocation(
+        self, namespace: Optional[argparse.Namespace] = None
+    ) -> List[str]:
         """Run the start-up function
 
         Run the start-up function unconstrained by the limitations of running in a dedicated subprocess.
@@ -199,6 +204,18 @@ class GdsStandardApp(GdsApp):
             dictionary of flag tuple to argparse kwargs
         """
         return {}
+    
+    @classmethod
+    def get_additional_cli_parsers(cls) -> List[ParserBase]:
+        """ Supply a list of CLI parser objects
+        
+        Supply a list of CLI parser objects to the CLI system. This allows use of full ParserBase objects instead of
+        the more restrictive dictionary approach seen in get_additional_arguments.
+
+        Returns:
+            list of parser objects as passed to ParserBase
+        """
+        return []
 
     @classmethod
     def init(cls):
@@ -230,7 +247,7 @@ class GdsStandardApp(GdsApp):
         """Start function to contain behavior based in standard pipeline"""
         raise NotImplementedError()
 
-    def get_process_invocation(self):
+    def get_process_invocation(self, namespace=None):
         """Return the process invocation for this class' main
 
         The process invocation of this application is to run cls.main and supply it a reproduced version of the
@@ -247,7 +264,8 @@ class GdsStandardApp(GdsApp):
         composite_parser = CompositeParser(
             [self.get_cli_parser(), StandardPipelineParser]
         )
-        namespace, _, _ = ParserBase.parse_known_args([composite_parser])
+        if namespace is None:
+            namespace, _, _ = ParserBase.parse_known_args([composite_parser], client=True)
         args = composite_parser.reproduce_cli_args(namespace)
         return [sys.executable, "-c", f"import {module}\n{module}.{cls}.main()"] + args
 
@@ -261,32 +279,39 @@ class GdsStandardApp(GdsApp):
                     []
                 )  # Disable plugin system unless specified through init
             # In the case where `init` sets up the plugin system, we want to pass the assertion
-            # triggered by the code above that turns it off in the not-setup case. 
+            # triggered by the code above that turns it off in the not-setup case.
             except AssertionError:
                 pass
             plugin_name = getattr(cls, "get_name", lambda: cls.__name__)()
+            plugin_composite = CompositeParser([cls.get_cli_parser()] + cls.get_additional_cli_parsers())
+
             parsed_arguments, _ = ParserBase.parse_args(
-                [cls.get_cli_parser(), StandardPipelineParser, PluginArgumentParser],
+                [ StandardPipelineParser, PluginArgumentParser, plugin_composite],
                 f"{plugin_name}: a standard app plugin",
+                client=True,
             )
             pipeline = StandardPipeline()
-            # Turn off history and filing
+            # Turn off history, file handling, and logging
             pipeline.histories.implementation = None
             pipeline.filing = None
+            parsed_arguments.disable_data_logging = True 
             pipeline = StandardPipelineParser.pipeline_factory(
                 parsed_arguments, pipeline
             )
             application = cls(
-                **cls.get_cli_parser().extract_arguments(parsed_arguments)
+                **cls.get_cli_parser().extract_arguments(parsed_arguments),
+                namespace=parsed_arguments, 
+
             )
             application.start(pipeline)
             sys.exit(0)
         except Exception as e:
             print(f"[ERROR] Error launching {cls.__name__}: {e}", file=sys.stderr)
-            raise
             sys.exit(148)
 
 
+
+
 @gds_plugin(GdsApp)
 class CustomDataHandlers(GdsStandardApp):
     """Run an app that registers all custom data handlers
@@ -294,10 +319,25 @@ class CustomDataHandlers(GdsStandardApp):
     A GdsApp plugin, built using the GdsStandardApp helper, that uses the provided standard pipeline to register each
     custom DataHandler plugin as a consumer of the appropriate type.
     """
+    PLUGIN_PARSER = CompositeParser([MiddleWareParser, DictionaryParser])
 
-    def __init__(self, **kwargs):
+    def __init__(self, namespace, **kwargs):
         """Required __init__ implementation"""
         super().__init__(**kwargs)
+        self.connection_transport = namespace.connection_transport
+        self.connection_uri = namespace.connection_uri
+        self.dictionaries  = namespace.dictionaries
+
+    @classmethod
+    def get_additional_arguments(cls):
+        """ Supplies additional arguments needed """
+        return {}
+
+    @classmethod
+    def get_additional_cli_parsers(cls):
+        """ Requires MiddleWareParser and Dictionary Parser"""
+        return [cls.PLUGIN_PARSER]
+
 
     @classmethod
     def init(cls):
@@ -312,10 +352,15 @@ class CustomDataHandlers(GdsStandardApp):
             "FW_PACKET_FILE": pipeline.coders.register_file_consumer,
             "FW_PACKET_PACKETIZED_TLM": pipeline.coders.register_packet_consumer,
         }
+        self.publisher = PublishingPipeline()
+        self.publisher.transport_implementation = self.connection_transport
+        self.publisher.setup(self.dictionaries)
+        self.publisher.connect(self.connection_uri)
 
         data_handlers = Plugins.system().get_feature_classes("data_handler")
         for data_handler_class in data_handlers:
             data_handler = data_handler_class()
+            data_handler.set_publisher(self.publisher)
             descriptors = data_handler.get_handled_descriptors()
             for descriptor in descriptors:
                 DESCRIPTOR_TO_FUNCTION.get(descriptor, lambda discard: discard)(

fprime_gds/executables/cli.py

@@ -27,9 +27,9 @@ from pathlib import Path
 from typing import Any, Dict, List, Tuple
 
 # Required to set the checksum as a module variable
-import fprime_gds.common.communication.checksum
 import fprime_gds.common.logger
 from fprime_gds.common.communication.adapters.ip import check_port
+from fprime_gds.common.models.dictionaries import Dictionaries
 from fprime_gds.common.pipeline.standard import StandardPipeline
 from fprime_gds.common.transport import ThreadedTCPSocketClient
 from fprime_gds.common.utils.config_manager import ConfigManager
@@ -176,6 +176,18 @@ class ParserBase(ABC):
         ]
         return list(itertools.chain.from_iterable(cli_pairs))
 
+    def handle_values(self, values: Dict[str, Any]):
+        """Post-process the parser's arguments in dictionary form
+
+        Handle arguments from the given parser in dictionary form. This will convert to/from the namespace and then
+        delegate to handle_arguments.
+
+        Args:
+            args: arguments namespace of processed arguments
+        Returns: dictionary with processed results of arguments.
+        """
+        return vars(self.handle_arguments(args=argparse.Namespace(**values), kwargs={}))
+
     @abstractmethod
     def handle_arguments(self, args, **kwargs):
         """Post-process the parser's arguments
@@ -1007,6 +1019,19 @@ class DictionaryParser(DetectionParser):
         elif args.dictionary is None:
             args = super().handle_arguments(args, **kwargs)
             args.dictionary = find_dict(args.deployment)
+        
+        # Setup dictionaries encoders and decoders
+        dictionaries = Dictionaries()
+
+        dictionaries.load_dictionaries(
+            args.dictionary, args.packet_spec, args.packet_set_name
+        )
+        config = ConfigManager.get_instance()
+        # Update config to use Fw types defined in the JSON dictionary
+        if dictionaries.fw_type_name:
+            for fw_type_name, fw_type in dictionaries.fw_type_name.items():
+                config.set("types", fw_type_name, fw_type)
+        args.dictionaries = dictionaries
         return args
 
 
@@ -1070,11 +1095,9 @@ class StandardPipelineParser(CompositeParser):
     def pipeline_factory(args_ns, pipeline=None) -> StandardPipeline:
         """A factory of the standard pipeline given the handled arguments"""
         pipeline_arguments = {
-            "config": ConfigManager(),
-            "dictionary": args_ns.dictionary,
+            "config": ConfigManager.get_instance(),
+            "dictionaries": args_ns.dictionaries,
             "file_store": args_ns.files_storage_directory,
-            "packet_spec": args_ns.packet_spec,
-            "packet_set_name": args_ns.packet_set_name,
             "logging_prefix": args_ns.logs,
             "data_logging_enabled": not args_ns.disable_data_logging
         }

fprime_gds/executables/fprime_cli.py

@@ -227,7 +227,7 @@ class CommandSubparserInjector(CliSubparserInjectorBase):
             argcomplete.warn("No dictionary found to get command names from")
             return []
 
-        from fprime_gds.common.pipeline.dictionaries import Dictionaries
+        from fprime_gds.common.models.dictionaries import Dictionaries
 
         dictionary = Dictionaries()
         dictionary.load_dictionaries(dict_path, None, None)

fprime_gds/executables/run_deployment.py

@@ -5,6 +5,7 @@
 ####
 import os
 import sys
+import copy
 import webbrowser
 
 from fprime_gds.executables.cli import (
@@ -38,7 +39,9 @@ def parse_args():
         PluginArgumentParser,
     ]
     # Parse the arguments, and refine through all handlers
-    args, parser = ConfigDrivenParser.parse_args(arg_handlers, "Run F prime deployment and GDS")
+    args, parser = ConfigDrivenParser.parse_args(
+        arg_handlers, "Run F prime deployment and GDS"
+    )
     return args
 
 
@@ -175,11 +178,21 @@ def launch_comm(parsed_args):
     )
 
 
-def launch_plugin(plugin_class_instance):
+def launch_plugin(parsed_args, plugin_class_instance):
     """Launch a plugin instance"""
-    plugin_name = getattr(plugin_class_instance, "get_name", lambda: plugin_class_instance.__class__.__name__)()
+    plugin_name = getattr(
+        plugin_class_instance,
+        "get_name",
+        lambda: plugin_class_instance.__class__.__name__,
+    )()
+    plugin_args = copy.deepcopy(parsed_args)
+    # Set logging to use a subdirectory within the root logs directory
+    plugin_logs = os.path.join(plugin_args.logs, plugin_name)
+    os.mkdir(plugin_logs)
+    plugin_args.logs = plugin_logs
+    plugin_args.log_directly = True
     return launch_process(
-        plugin_class_instance.get_process_invocation(),
+        plugin_class_instance.get_process_invocation(plugin_args),
         name=f"{ plugin_name } Plugin App",
         launch_time=1,
     )
@@ -218,11 +231,11 @@ def main():
     try:
         procs = [launcher(parsed_args) for launcher in launchers]
         _ = [
-            launch_plugin(cls())
+            launch_plugin(parsed_args, cls(namespace=parsed_args))
             for cls in Plugins.system().get_feature_classes("gds_app")
         ]
         _ = [
-            instance().run()
+            instance().run(parsed_args)
             for instance in Plugins.system().get_feature_classes("gds_function")
         ]
 

{fprime_gds-4.0.2a1.dist-info → fprime_gds-4.0.2a2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fprime-gds
-Version: 4.0.2a1
+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.2a1.dist-info → fprime_gds-4.0.2a2.dist-info}/RECORD

@@ -2,7 +2,7 @@ fastentrypoints.py,sha256=2HO-tsTTZxpzYNd-BaLK3WDLknzCZKzb_yX2p3Ftqa8,4020
 fprime_gds/__init__.py,sha256=y2ljhCEHnvyfSDvXIEgBGIk8oHjjjjCWFxfddOGeYFk,115
 fprime_gds/version.py,sha256=dlUlfOKTsGaqz_L7TjhCVC-Vanx5cK67kdZlqcHCM8M,395
 fprime_gds/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fprime_gds/common/handlers.py,sha256=YyhuF4yg3d7tFgWmbvXfxLDHYgea6Z1hpFd2A27gVZY,4464
+fprime_gds/common/handlers.py,sha256=vPfW1jJpq-oI7c9OTFqZ1LovlhFjx1DEUrfZTk_iuNY,6344
 fprime_gds/common/transport.py,sha256=uYXWkM8TYEYz1vfY4AEn0PF8Gu4tkYmJ5t4w1YY1yW8,10565
 fprime_gds/common/zmq_transport.py,sha256=E_iBZ5sA4JKB99MWSOM6XnPrO-mbFyRvD9eQp9te6-Y,12397
 fprime_gds/common/communication/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -29,21 +29,21 @@ fprime_gds/common/data_types/file_data.py,sha256=4_G9kf4ThC5NzkxnKa0xNYBdi8UDvZg
 fprime_gds/common/data_types/pkt_data.py,sha256=cxqUnsPte0ijF1E8F1_uglVKIJFAIQbpoBlmwRjMrJY,3405
 fprime_gds/common/data_types/sys_data.py,sha256=Xfk5xryFg7zWS3VcGUDx9lQYBTajjWXvwkgFK5EUCG4,2095
 fprime_gds/common/decoders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fprime_gds/common/decoders/ch_decoder.py,sha256=mx0yfT-DQqQ8TrmRM3dr79eL9_E-c0gsKiKvvsjAu98,3849
+fprime_gds/common/decoders/ch_decoder.py,sha256=-Vo_GJys-4ohs94XV0ZYB88SNqN0gxxY29Ijt1gwyXY,3847
 fprime_gds/common/decoders/decoder.py,sha256=9j7u05_nwXaEjR0etsoB--ATsHuILYCXlhk9m9yajKg,2655
-fprime_gds/common/decoders/event_decoder.py,sha256=ib-O18V5Z7bcnUUSDE9R0fU--bAZsfxLwuHXm964rzE,4505
+fprime_gds/common/decoders/event_decoder.py,sha256=tF_mg98RDjR0PppymGhmXybYXA0mFqklZXwora-cVtw,4503
 fprime_gds/common/decoders/file_decoder.py,sha256=Ky2U8bli3YL6GbT9jSSvI73ySOtf0cdZLK4FXTuWjfA,2542
-fprime_gds/common/decoders/pkt_decoder.py,sha256=kW8k3OSbMy96w6MzsGWp656lAQvwxrIznWkD3Sbi8Ig,3329
+fprime_gds/common/decoders/pkt_decoder.py,sha256=c1CebqBaD7rAZd9t0AXkGVRTCtvXj0YH9OBN2bJKaTk,3327
 fprime_gds/common/distributor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fprime_gds/common/distributor/distributor.py,sha256=jged1utucsYkVBm5tSaFEXHDg8suiJ_Hn-9YLPCaVXA,8036
+fprime_gds/common/distributor/distributor.py,sha256=hP0mUknxxpKrQfYkf57dHbMItwgUTzpzmkrc1AOHVCw,8034
 fprime_gds/common/encoders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/common/encoders/ch_encoder.py,sha256=TBrTJ7TK4WwCh6KAspozh63WcPxrMImloB8tz7qeulw,2878
-fprime_gds/common/encoders/cmd_encoder.py,sha256=5wG5854ozmxctnYou3q9MdQNkTQEmpCiT4oBVgNRZdE,3499
-fprime_gds/common/encoders/encoder.py,sha256=xgFFCi-qKEKG7T5Qfo-qIadSiY0NSnfDgQUBq21fMhw,2984
+fprime_gds/common/encoders/cmd_encoder.py,sha256=iFPi6uMlMPlApC47p9YKRjKJxMvz46p15Yy3NnGTyaE,3497
+fprime_gds/common/encoders/encoder.py,sha256=jaN-uLHRGAzAs33ZdPm2FTdh3mAvsOCtqO6Ov9hspyI,2997
 fprime_gds/common/encoders/event_encoder.py,sha256=aM_3hWWx4OrLKF3-MlhmGSBYnzt-4iktSzMVrcUbfB8,3140
 fprime_gds/common/encoders/file_encoder.py,sha256=G9uUXQP-oD2eW_GJuGNBrN7xPafKFhmgKiNi-zvZz-g,3830
 fprime_gds/common/encoders/pkt_encoder.py,sha256=6hzwrAEg1tjGw9yGycWMuNgbGCoe87Cd-7eP1rvy2d4,3126
-fprime_gds/common/encoders/seq_writer.py,sha256=rH1I8trAHBKjqxQtNg1isTmLWqAjK3xtZbETTCp6RQI,6882
+fprime_gds/common/encoders/seq_writer.py,sha256=g0Rmnlw4qLgJn290ORzJ21jZo0gB2dTvHFWs4pzbmio,6880
 fprime_gds/common/files/File Decoder Documentation.txt,sha256=a-VYHcUMqh7mBGY2fqvMf1nd3gdg3cLdPKwrulNKXjc,5314
 fprime_gds/common/files/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/common/files/downlinker.py,sha256=CZPfhH0J9-LNqW5Cv_ryicLTuoedLSWK8OPQmmQDZZY,7498
@@ -59,10 +59,10 @@ fprime_gds/common/fpy/parser.py,sha256=g-l67oZN_vB1JAdZ5S3u9m8APf6PdJ88GZyz0iX66
 fprime_gds/common/fpy/bytecode/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/common/fpy/bytecode/directives.py,sha256=tBpPQ2ZnQXA7juB85HhacDdil1vEHUKW8m_AsMf1KdQ,13360
 fprime_gds/common/gds_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fprime_gds/common/gds_cli/base_commands.py,sha256=nHnzHRMXs9haRjiUmq-Ciu1DSo1BXtcVscByk1Ypsxo,9432
-fprime_gds/common/gds_cli/channels.py,sha256=S8y0Mo2JbBFPvMzeW22HFVJ8p-UC-tzpYM7rXqIGWi4,2136
-fprime_gds/common/gds_cli/command_send.py,sha256=pMPwCixiuhk3r1mP7IbHLlItxYf_np8ez0hGhH0yTUw,6608
-fprime_gds/common/gds_cli/events.py,sha256=EpaUfDEaXvPwKu7qutkuU1f8zrFoVNsbyCIGUFUloWI,2123
+fprime_gds/common/gds_cli/base_commands.py,sha256=js4SAXPfDYy_ewIL27066XylExxh9S1A-e4NNChWf9s,9430
+fprime_gds/common/gds_cli/channels.py,sha256=BvADGBrsJ2G9zcGpSwJlxLRFiY1bUxtQSTfEOlA3UME,2134
+fprime_gds/common/gds_cli/command_send.py,sha256=SnDBbwKzNluG-yJSsmsQJpNBPmv4O7nMvG6qYbdpI64,6606
+fprime_gds/common/gds_cli/events.py,sha256=9Jpk0C7VI-KldFxo7neaG2MpcKhqH2VE2xaV8G-5pSw,2121
 fprime_gds/common/gds_cli/filtering_utils.py,sha256=2LxT9tzuNvnwm7HVItv87XkO6K29nOBift2bYcYn3zg,7554
 fprime_gds/common/gds_cli/test_api_utils.py,sha256=VphGie_VxTMZQGz6p_5AjdEZWXqKJTohrqslRS8VnNU,5109
 fprime_gds/common/history/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -88,19 +88,18 @@ fprime_gds/common/logger/__init__.py,sha256=TLUbrAnkCtckKGsLzh4hXgEshwQfZsWMDaOO
 fprime_gds/common/logger/data_logger.py,sha256=VjfhTGO1gGw954xNhSc0_zpw8JexCho5f8BlXDEYkL4,2505
 fprime_gds/common/logger/test_logger.py,sha256=wL8Lq49sVmxGRALgv-ei6AnXFh79qlHFehmKJ1A8X28,6475
 fprime_gds/common/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fprime_gds/common/models/dictionaries.py,sha256=8HRnSrg6yVOlep17qFWdJzKJ7gZIoNGA-bCabuITyM8,8091
 fprime_gds/common/models/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fprime_gds/common/models/common/channel_telemetry.py,sha256=UkLIgWLgVNi2AmPnuT3k9pAmUqNuw2zYHj_r6dB3q5o,4305
 fprime_gds/common/models/common/command.py,sha256=ASih9dwR_7F94nR1CV7cIuZEJSuaUAzX7JU2_lCAg4g,5476
-fprime_gds/common/models/common/event.py,sha256=gSFrCJT9ZddGJfkf3fGCCqk0aMIQV-SNeAhCX6hnbrc,3386
 fprime_gds/common/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/common/parsers/seq_file_parser.py,sha256=6DZrA0jmt8IqsutfK7pdLtYn4oVHO593rWgAOH63yRg,9587
 fprime_gds/common/pipeline/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fprime_gds/common/pipeline/dictionaries.py,sha256=x3QCZAg6YB9bEumZ330PGo0ilJqODGyo_K70RgbQ53M,8009
 fprime_gds/common/pipeline/encoding.py,sha256=PttJ8NmXm75mLXyhlmxOJqE8RFt46q1dThaV19PyAr4,7216
 fprime_gds/common/pipeline/files.py,sha256=J2zm0sucvImtmSnv0iUp5uTpvUO8nlmz2lUdMuMC5aM,2244
 fprime_gds/common/pipeline/histories.py,sha256=7KyboNnm9OARQk4meVPSSeYpeqH0G8RWRiy0BLBL1rw,3671
+fprime_gds/common/pipeline/publishing.py,sha256=A0Hb4RpK7RCBDN9BEiJZr9WQMSrmohYXCFOuzl23mPo,3953
 fprime_gds/common/pipeline/router.py,sha256=-P1wI0KXEh_snOzDaq8CjEoWuM_zRm8vUMR1T0oY9qQ,2327
-fprime_gds/common/pipeline/standard.py,sha256=5aivCoPKfZXH_g0pk4fHHwnNt_dEcj-HMWAa4LleCbA,9837
+fprime_gds/common/pipeline/standard.py,sha256=Gj-TPWoCWN-zp6uI2o_TI9jANJ7I7hmXOujgwJ8PlMo,9126
 fprime_gds/common/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/common/templates/ch_template.py,sha256=1MoDZsia0dI_CvnIttwyKLhbQhum35OcJnFc50Xohuo,3893
 fprime_gds/common/templates/cmd_template.py,sha256=n91z4WhFgHwTu6_fQqy7JqpkEObAkllIeEy0AR0DvrQ,5455
@@ -117,18 +116,18 @@ fprime_gds/common/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG
 fprime_gds/common/tools/params.py,sha256=htnMLlUW9HmBo4Qc7kYhnWr1sO6bK2mckdskLt5rDUk,9323
 fprime_gds/common/tools/seqgen.py,sha256=O57igktjWku5OJhBqezhCjPYUmh4GZM-9qKCChqEW7g,6034
 fprime_gds/common/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fprime_gds/common/utils/config_manager.py,sha256=EurtNdApA9zpIjAXmGSTgFUen0UaVDryH5g9LwMhu1E,5539
+fprime_gds/common/utils/config_manager.py,sha256=dMqN204UKLiZzIs7-d--fdYMQ8kBzTX56xexkgFq18s,5550
 fprime_gds/common/utils/data_desc_type.py,sha256=0AkEMfEa5refd_moovf1hkgKiNakADRzv4soghvf9a4,883
 fprime_gds/common/utils/event_severity.py,sha256=7qPXHrDaM_REJ7sKBUEJTZIE0D4qVnVajsPDUuHg7sI,300
 fprime_gds/common/utils/string_util.py,sha256=u_2iahRG3ROu3lAAt_KVcK226gEByElXqrA8mH8eDpI,3584
 fprime_gds/executables/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fprime_gds/executables/apps.py,sha256=u79T_PlgMmNmA4YwWjs7LvPMCJnrjnURr05NMthOYP0,13350
-fprime_gds/executables/cli.py,sha256=Cv8gHPqPrDil87Gv0dNFyWpRrp4XBC82-tmIy5kbz_U,51223
+fprime_gds/executables/apps.py,sha256=_OLWxby1XvYmmDcecsOAKu34XGf952_ya5uRWf_8Y3I,15127
+fprime_gds/executables/cli.py,sha256=OqcBOpvnj8f8wZjntfbr-pNzCEF3P_-eA58kBqK7iDg,52216
 fprime_gds/executables/comm.py,sha256=08rO0o0MJgTRngB7Ygu2IL_gEAWKF7WFvFyro1CqReE,5214
 fprime_gds/executables/data_product_writer.py,sha256=e1Rp2LT_Cpg08f0Ki8GhirC7Wn6LtYiAef7KLAkZHUY,37773
 fprime_gds/executables/dictionary_merge.py,sha256=3Zy8LcbEdBwmNX2GLN_Nr1DfbLyWYHg-y4jdjTVCXgY,7966
-fprime_gds/executables/fprime_cli.py,sha256=CMoT7zWNwM8h2mSZW03AR96wl_XnZXoLNiOZN_sDi38,12431
-fprime_gds/executables/run_deployment.py,sha256=Zl0Y9-6i6c8tZhcS7XkAeVQtzn0d9fV-3UJQZ0bnBrc,7237
+fprime_gds/executables/fprime_cli.py,sha256=9_eNU7AzUOMhz4FLPkD_byA9C13c509wGPZN-kdw9Ok,12429
+fprime_gds/executables/run_deployment.py,sha256=4K3isTF7C8FojFvzxLC8vaj1GZpKOuPZQ3CtIYdyhRE,7638
 fprime_gds/executables/tcpserver.py,sha256=KspVpu5YIuiWKOk5E6UDMKvqXYrRB1j9aX8CkMxysfw,17555
 fprime_gds/executables/utils.py,sha256=SbzXRe1p41qMPdifvPap5_4v0T42gZZ_Rs_OYfITd80,7626
 fprime_gds/flask/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -245,10 +244,10 @@ fprime_gds/flask/static/third-party/webfonts/fa-solid-900.woff2,sha256=mDS4KtJuK
 fprime_gds/plugin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/plugin/definitions.py,sha256=QlxW1gNvoiqGMslSJjh3dTFZuv0igFHawN__3XJ0Wns,5355
 fprime_gds/plugin/system.py,sha256=M9xb-8jBhCUUx3X1z2uAP8Wx_v6NkL8JeaFgGcMnQqY,13432
-fprime_gds-4.0.2a1.dist-info/licenses/LICENSE.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-fprime_gds-4.0.2a1.dist-info/licenses/NOTICE.txt,sha256=vXjA_xRcQhd83Vfk5D_vXg5kOjnnXvLuMi5vFKDEVmg,1612
-fprime_gds-4.0.2a1.dist-info/METADATA,sha256=7qyu-NnTZ5K22Lo9dJ4Db_4FqR05UWoWZnNDesd__Ks,24576
-fprime_gds-4.0.2a1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fprime_gds-4.0.2a1.dist-info/entry_points.txt,sha256=16r0xeF-Qn-ducW_QvHiyrFnNjnLK-OOaTbqQIQpd0o,494
-fprime_gds-4.0.2a1.dist-info/top_level.txt,sha256=6vzFLIX6ANfavKaXFHDMSLFtS94a6FaAsIWhjgYuSNE,27
-fprime_gds-4.0.2a1.dist-info/RECORD,,
+fprime_gds-4.0.2a2.dist-info/licenses/LICENSE.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+fprime_gds-4.0.2a2.dist-info/licenses/NOTICE.txt,sha256=vXjA_xRcQhd83Vfk5D_vXg5kOjnnXvLuMi5vFKDEVmg,1612
+fprime_gds-4.0.2a2.dist-info/METADATA,sha256=t7Idkx-zA1DrvKJaxm_zVGZoTDFxw_UJtLY35Xje4R4,24576
+fprime_gds-4.0.2a2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fprime_gds-4.0.2a2.dist-info/entry_points.txt,sha256=16r0xeF-Qn-ducW_QvHiyrFnNjnLK-OOaTbqQIQpd0o,494
+fprime_gds-4.0.2a2.dist-info/top_level.txt,sha256=6vzFLIX6ANfavKaXFHDMSLFtS94a6FaAsIWhjgYuSNE,27
+fprime_gds-4.0.2a2.dist-info/RECORD,,

fprime_gds/common/models/common/channel_telemetry.py

@@ -1,174 +0,0 @@
-"""
-Created on Apr. 27, 2015
-
-@author: reder
-"""
-
-from fprime.common.models.serialize.type_base import BaseType
-
-# Import the types this way so they do not need prefixing for execution.
-from fprime.common.models.serialize.type_exceptions import (
-    TypeException,
-    TypeMismatchException,
-)
-
-
-class Channel:
-    """
-    Channel class is for deserialize channel telemetry value.
-    Really this is a container since the type will have it's own deserialize
-    implementation.
-    """
-
-    def __init__(
-        self,
-        name,
-        channel_id,
-        comp_name,
-        ch_description,
-        ch_type,
-        ch_format_string,
-        low_red,
-        low_orange,
-        low_yellow,
-        high_yellow,
-        high_orange,
-        high_red,
-    ):
-        """
-        Constructor
-        """
-        #
-        # Make sure correct types are passed
-        #
-        if not isinstance(name, str):
-            raise TypeMismatchException(str, type(name))
-
-        if not isinstance(channel_id, int):
-            raise TypeMismatchException(int, type(channel_id))
-
-        if not isinstance(ch_description, str):
-            raise TypeMismatchException(str, type(ch_description))
-
-        if not isinstance(ch_type, BaseType):
-            raise TypeMismatchException(BaseType, type(ch_type))
-
-        # Initialize event internal variables
-        self.__name = name
-        self.__comp_name = comp_name
-        self.__id = channel_id
-        self.__ch_desc = ch_description
-        self.__ch_type = ch_type
-        self.__format_string = ch_format_string
-        self.__low_red = low_red
-        self.__low_orange = low_orange
-        self.__low_yellow = low_yellow
-        self.__high_yellow = high_yellow
-        self.__high_orange = high_orange
-        self.__high_red = high_red
-        #
-        self.__time_base = None
-        self.__time_context = None
-        self.__time_sec = None
-        self.__time_usec = None
-        #
-        self.__changed = False
-
-    def deserialize(self, ser_data, offset):
-        """
-        Deserialize event arguments
-        :param ser_data: Binary input of the channel value.
-        :param offset: offset in data to deserialize from
-        :return: value from deserialized channel
-        """
-        try:
-            self.__ch_type.deserialize(ser_data, offset)
-            val = self.__ch_type.val
-        except TypeException as e:
-            print(f"Channel deserialize exception {e.getMsg()}")
-            val = "ERR"
-
-        #
-        return val
-
-    def setTime(self, time_base, time_context, time_sec, time_usec):
-        """
-        Channel telemetry time updater.
-        """
-        self.__time_base = time_base
-        self.__time_context = time_context
-        self.__time_sec = time_sec
-        self.__time_usec = time_usec
-
-    def getTime(self):
-        """
-        Return time tuple for UI updater use.
-        """
-        return (
-            self.__time_base,
-            self.__time_context,
-            self.__time_sec,
-            self.__time_usec,
-        )
-
-    def getName(self):
-        return self.__name
-
-    def getCompName(self):
-        return self.__comp_name
-
-    def getId(self):
-        return self.__id
-
-    def getChDesc(self):
-        return self.__ch_desc
-
-    def getType(self):
-        return self.__ch_type
-
-    def getTimeBase(self):
-        return self.__time_base
-
-    def getTimeContext(self):
-        return self.__time_context
-
-    def getTimeSec(self):
-        return self.__time_sec
-
-    def getTimeUsec(self):
-        return self.__time_usec
-
-    def getFormatString(self):
-        return self.__format_string
-
-    def getLowRed(self):
-        return self.__low_red
-
-    def getLowOrange(self):
-        return self.__low_orange
-
-    def getLowYellow(self):
-        return self.__low_yellow
-
-    def getHighYellow(self):
-        return self.__high_yellow
-
-    def getHighOrange(self):
-        return self.__high_orange
-
-    def getHighRed(self):
-        return self.__high_red
-
-    @property
-    def changed(self):
-        """
-        change is True if recently updated.
-        change is False if not changed.
-        """
-        return self.__changed
-
-    @changed.setter
-    def changed(self, ch):
-        if ch is not False or ch is not True:
-            ch = True
-        self.__changed = ch

fprime_gds/common/models/common/event.py

@@ -1,121 +0,0 @@
-"""
-Created on Feb. 9, 2015
-
-@author: reder
-"""
-
-import traceback
-from enum import Enum
-
-from fprime.common.models.serialize.type_base import BaseType
-
-# Import the types this way so they do not need prefixing for execution.
-from fprime.common.models.serialize.type_exceptions import (
-    TypeException,
-    TypeMismatchException,
-)
-
-Severity = Enum(
-    "Severity", "COMMAND ACTIVITY_LO ACTIVITY_HI WARNING_LO WARNING_HI DIAGNOSTIC FATAL"
-)
-
-
-class Event:
-    """
-    Event class is for deserializing log event messages.
-    THis is essentially the equivalent of EVR's in MSL, SMAP, etc.
-    """
-
-    def __init__(
-        self, name, event_id, severity, format_string, event_description, arguments
-    ):
-        """
-        Constructor
-        """
-
-        # Make sure correct types are passed
-
-        if not isinstance(name, str):
-            raise TypeMismatchException(str, type(name))
-
-        if not isinstance(event_id, int):
-            raise TypeMismatchException(int, type(event_id))
-
-        if not isinstance(format_string, str):
-            raise TypeMismatchException(str, type(format_string))
-
-        if not isinstance(event_description, str):
-            raise TypeMismatchException(str, type(event_description))
-
-        if not isinstance(arguments, list):
-            raise TypeMismatchException(list, type(arguments))
-
-        for (argname, argdesc, argtype) in arguments:
-            #
-            if not isinstance(argname, str):
-                raise TypeMismatchException(str, type(argname))
-            #
-            if not isinstance(argdesc, str):
-                raise TypeMismatchException(str, type(argdesc))
-            #
-            if not isinstance(argtype, BaseType):
-                raise TypeMismatchException(BaseType, type(argtype))
-
-        # Initialize event internal variables
-        self.__name = name
-        self.__id = event_id
-        self.__severity = severity
-        self.__format_string = format_string
-        self.__event_description = event_description
-        self.__arguments = arguments
-
-    def deserialize(self, ser_data):
-        """
-        Deserialize event arguments
-        @param ser_data: Binary input data of id followed by args
-        """
-        vals = []
-        #
-        # Next parse the arguments.
-        #
-        args = list(self.__arguments)
-        offset = 0
-        for arg in args:
-            arg_obj = arg[2]
-            try:
-                # print arg_obj
-                arg_obj.deserialize(ser_data, offset)
-                vals.append(arg_obj.val)
-            except TypeException as e:
-                print(f"Event deserialize exception {e.getMsg()}")
-                traceback.print_exc()
-                vals.append("ERR")
-            offset = offset + arg_obj.getSize()
-
-        vals = [0] + vals
-        return vals
-
-    def stringify(self, event_args_list):
-        """
-        Return a formatted string of event args.
-        """
-        # print event_args_list
-        return self.__format_string % tuple(event_args_list[1:])
-
-    def getName(self):
-        return self.__name
-
-    def getId(self):
-        return self.__id
-
-    def getSeverity(self):
-        return self.__severity
-
-    def getFormatString(self):
-        return self.__format_string
-
-    def getEventDescription(self):
-        return self.__event_description
-
-    def getArgs(self):
-        return self.__arguments