fprime-gds 4.0.2a1__tar.gz → 4.0.2a3__tar.gz

{fprime_gds-4.0.2a1 → fprime_gds-4.0.2a3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fprime-gds
-Version: 4.0.2a1
+Version: 4.0.2a3
 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 → fprime_gds-4.0.2a3}/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.2a1 → fprime_gds-4.0.2a3}/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.2a1 → fprime_gds-4.0.2a3}/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.2a1 → fprime_gds-4.0.2a3}/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.2a1 → fprime_gds-4.0.2a3}/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.2a1 → fprime_gds-4.0.2a3}/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.2a1 → fprime_gds-4.0.2a3}/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.2a1 → fprime_gds-4.0.2a3}/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.2a1 → fprime_gds-4.0.2a3}/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.2a1 → fprime_gds-4.0.2a3}/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.2a1 → fprime_gds-4.0.2a3}/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.2a1 → fprime_gds-4.0.2a3}/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.2a1/src/fprime_gds/common/pipeline → fprime_gds-4.0.2a3/src/fprime_gds/common/models}/dictionaries.py

@@ -49,6 +49,9 @@ class Dictionaries:
         self._fw_type_name_dict = None
         self._versions = None
         self._metadata = None
+        self._dictionary_path = None
+        self._packet_spec_path = None
+        self._packet_set_name = None
 
     def load_dictionaries(self, dictionary, packet_spec, packet_set_name):
         """
@@ -57,7 +60,13 @@ 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
         """
+        # Update the "from" values
+        self._dictionary_path = dictionary
+        self._packet_spec_path = packet_spec
+        self._packet_set_name = packet_set_name
+
         if Path(dictionary).is_file() and ".json" in Path(dictionary).suffixes:
             # Events
             json_event_loader = (
@@ -203,6 +212,21 @@ class Dictionaries:
         for legacy reasons. New code should use the metadata property."""
         return self._metadata
 
+    @property
+    def dictionary_path(self):
+        """ Dictionary Path """
+        return self._dictionary_path
+
+    @property
+    def packet_spec_path(self):
+        """ Dictionary Path """
+        return self._packet_spec_path
+    
+    @property
+    def packet_set_name(self):
+        """ Dictionary Path """
+        return self._packet_set_name
+
     @property
     def packet(self):
         """Packet dictionary"""

fprime_gds-4.0.2a3/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.2a1 → fprime_gds-4.0.2a3}/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,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
         )
@@ -253,3 +239,8 @@ class StandardPipeline:
         :return: filing compositions
         """
         return self.__filing
+
+    @property
+    def dictionaries(self):
+        """ Dictionaries member """
+        return self.__dictionaries

{fprime_gds-4.0.2a1 → fprime_gds-4.0.2a3}/src/fprime_gds/common/testing_fw/api.py

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

{fprime_gds-4.0.2a1 → fprime_gds-4.0.2a3}/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):

{fprime_gds-4.0.2a1 → fprime_gds-4.0.2a3}/src/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)(