fprime-gds 4.0.0a5__tar.gz → 4.0.0a6__tar.gz

{fprime_gds-4.0.0a5 → fprime_gds-4.0.0a6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fprime-gds
-Version: 4.0.0a5
+Version: 4.0.0a6
 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.0a5 → fprime_gds-4.0.0a6}/src/fprime_gds/common/pipeline/dictionaries.py

@@ -128,7 +128,13 @@ class Dictionaries:
             msg = f"[ERROR] Dictionary '{dictionary}' does not exist."
             raise Exception(msg)
         # Check for packet specification
-        if self._metadata["dictionary_type"] == "json":
+        if packet_spec is not None:
+            packet_loader = fprime_gds.common.loaders.pkt_xml_loader.PktXmlLoader()
+            self._packet_dict = packet_loader.get_id_dict(
+                packet_spec, self._channel_name_dict
+            )
+        # Otherwise use JSON dictionary to attempt automatic packet loading
+        elif self._metadata["dictionary_type"] == "json":
             packet_loader = fprime_gds.common.loaders.pkt_json_loader.PktJsonLoader(dictionary)
             if packet_set_name is None:
                 names = packet_loader.get_packet_set_names(None)
@@ -141,11 +147,6 @@ class Dictionaries:
             self._packet_dict = packet_loader.get_id_dict(
                 None, packet_set_name, self._channel_name_dict
             )
-        elif packet_spec is not None:
-            packet_loader = fprime_gds.common.loaders.pkt_xml_loader.PktXmlLoader(dictionary)
-            self._packet_dict = packet_loader.get_id_dict(
-                packet_spec, self._channel_name_dict
-            )
         else:
             self._packet_dict = None
 

{fprime_gds-4.0.0a5 → fprime_gds-4.0.0a6}/src/fprime_gds/executables/apps.py

@@ -237,14 +237,18 @@ class GdsStandardApp(GdsApp):
         arguments needed for the given parsers.  When main is loaded, it will dispatch to the sub-classing plugin's
         start method. The subclassing plugin will already have had the arguments supplied via the PluginParser's
         construction of plugin objects.
+
+        Returns:
+            list of arguments to pass to subprocess
         """
         cls = self.__class__.__name__
         module = self.__class__.__module__
 
-        namespace = Namespace(**self.arguments)
-        args = CompositeParser(
+        composite_parser = CompositeParser(
             [self.get_cli_parser(), StandardPipelineParser]
-        ).reproduce_cli_args(namespace)
+        )
+        namespace, _, _ = ParserBase.parse_known_args([composite_parser])
+        args = composite_parser.reproduce_cli_args(namespace)
         return [sys.executable, "-c", f"import {module}\n{module}.{cls}.main()"] + args
 
     @classmethod
@@ -260,9 +264,10 @@ class GdsStandardApp(GdsApp):
             # 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__)()
             parsed_arguments, _ = ParserBase.parse_args(
                 [cls.get_cli_parser(), StandardPipelineParser, PluginArgumentParser],
-                f"{cls.get_name()}: a standard app plugin",
+                f"{plugin_name}: a standard app plugin",
             )
             pipeline = StandardPipeline()
             # Turn off history and filing

{fprime_gds-4.0.0a5 → fprime_gds-4.0.0a6}/src/fprime_gds/executables/run_deployment.py

@@ -177,7 +177,7 @@ def launch_comm(parsed_args):
 
 def launch_plugin(plugin_class_instance):
     """Launch a plugin instance"""
-    plugin_name = getattr(plugin_class_instance, "get_name", lambda: cls.__name__)()
+    plugin_name = getattr(plugin_class_instance, "get_name", lambda: plugin_class_instance.__class__.__name__)()
     return launch_process(
         plugin_class_instance.get_process_invocation(),
         name=f"{ plugin_name } Plugin App",

{fprime_gds-4.0.0a5 → fprime_gds-4.0.0a6}/src/fprime_gds.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fprime-gds
-Version: 4.0.0a5
+Version: 4.0.0a6
 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.0a5 → fprime_gds-4.0.0a6}/test/fprime_gds/test_plugins.py

@@ -12,17 +12,19 @@ import signal
 import subprocess
 import sys
 import time
+from typing import Dict, Tuple
 
 import pytest
 
 from pathlib import Path
-from tempfile import NamedTemporaryFile
+from tempfile import NamedTemporaryFile, TemporaryDirectory
 from fprime_gds.common.communication.adapters.ip import IpAdapter
 from fprime_gds.common.communication.adapters.base import NoneAdapter
 from fprime_gds.common.communication.adapters.uart import SerialAdapter
 from fprime_gds.common.communication.framing import FramerDeframer, FpFramerDeframer
+from fprime_gds.common.pipeline.standard import StandardPipeline
 from fprime_gds.executables.cli import ParserBase, PluginArgumentParser
-from fprime_gds.executables.apps import GdsFunction, GdsApp
+from fprime_gds.executables.apps import GdsFunction, GdsApp, GdsStandardApp
 from fprime_gds.plugin.definitions import gds_plugin_implementation, gds_plugin
 from fprime_gds.plugin.system import Plugins
 
@@ -192,6 +194,54 @@ class StartApp(GdsApp):
         """Register a good plugin"""
         return cls
 
+@gds_plugin(GdsStandardApp)
+class StandardAppTester(GdsStandardApp):
+    """A test plugin that uses the standard app functionality"""
+    INIT_CALLED = False
+
+    def __init__(self, test_arg, test_arg_with_default, start_up_file, **pipeline_arguments):
+        """Initialize the standard app tester"""
+        super().__init__(**pipeline_arguments)
+        self.test_arg = test_arg
+        self.test_arg_with_default = test_arg_with_default
+        self.start_up_file = start_up_file
+
+    @classmethod
+    def get_additional_arguments(cls) -> Dict[Tuple, Dict[str, str]]:
+        """Function to provide additional command line arguments beyond the standard pipeline
+
+        Override this function to provide additional arguments. The form of the arguments are the same as returned by
+        standard plugins: a dictionary of tuple flags to argparse kwargs inputs.
+
+        Return:
+            dictionary of flag tuple to argparse kwargs
+        """
+        return {
+            ("--test-arg",): {"type": str, "help": "Test argument", "required": True},
+            ("--test-arg-with-default",): {"type": str, "help": "Test argument with default", "default": "test-default"},
+            ("--start-up-file",): {
+                "type": str,
+                "help": "File to run start-up function on",
+                "required": True,
+            }
+        }
+
+    @classmethod
+    def init(cls):
+        """Allows standard application plugins to initialize before argument parsing is performed"""
+        cls.INIT_CALLED = True
+
+
+    def start(self, pipeline: StandardPipeline):
+        """Start function to contain behavior based in standard pipeline """
+        with open(self.start_up_file, "a+") as file_handle:
+            if self.INIT_CALLED:
+                print("[TestStandardApp] init called", file=file_handle)
+            print("[TestStandardApp] start called", file=file_handle)
+            print("[TestStandardApp] test-arg", self.test_arg, file=file_handle)
+            print("[TestStandardApp] test-arg-with-default", self.test_arg_with_default, file=file_handle)
+
+
 
 @pytest.fixture()
 def plugins():
@@ -215,31 +265,34 @@ def start_up(request):
     parent_path = Path(__file__).parent
     extra_plugins, flags = request.param
 
-    command_arguments = [
-        "fprime-gds",
-        "-n",
-        "--dictionary",
-        str(parent_path / "sample" / "dictionary.xml"),
-        "--zmq-transport",
-        "ipc:///tmp/fprime-test-in",
-        "ipc:///tmp/fprime-test-out",
-        "-g",
-        "none",
-    ] + flags
-
     # Update the environment to side-load python
     environment = os.environ.copy()
     environment[Plugins.PLUGIN_ENVIRONMENT_VARIABLE] = extra_plugins
     environment["PYTHONPATH"] = f"{environment.get('PYTHONPATH', '')}:{parent_path}"
-    with NamedTemporaryFile(mode="w+") as temp_file:
-        assert "" == temp_file.read(), "Failed to read empty file"
-        command_arguments += ["--start-up-file", temp_file.name]
-        # Run subprocess for 3 seconds then kill the GDS with 5 seconds to shut down
-        process = subprocess.Popen(command_arguments, env=environment)
-        time.sleep(3)
-        process.send_signal(signal.SIGINT)
-        _ = process.communicate(None, 5)
-        yield temp_file
+    with TemporaryDirectory() as temp_dir:
+        # Command line arguments including a temporary directory for the ZMQ transport
+        # sockets used in this test.
+        command_arguments = [
+            "fprime-gds",
+            "-n",
+            "--dictionary",
+            str(parent_path / "sample" / "dictionary.xml"),
+            "--zmq-transport",
+            f"ipc://{temp_dir}/fprime-test-in",
+            f"ipc://{temp_dir}/fprime-test-out",
+            "-g",
+            "none",
+            "--disable-custom-data-handlers",
+        ] + flags
+        with NamedTemporaryFile(mode="w+", dir=temp_dir) as temp_file:
+            assert "" == temp_file.read(), "Failed to read empty file"
+            command_arguments += ["--start-up-file", temp_file.name]
+            # Run subprocess for 3 seconds then kill the GDS with 5 seconds to shut down
+            process = subprocess.Popen(command_arguments, env=environment)
+            time.sleep(3)
+            process.send_signal(signal.SIGINT)
+            _ = process.communicate(None, 5)
+            yield temp_file
 
 
 def test_base_plugin(plugins):
@@ -404,9 +457,40 @@ def test_disabled_start_app(start_up):
     """Test disabled start-up functions"""
     assert "" == start_up.read(), "Failed to read empty file"
 
+@pytest.mark.parametrize("start_up", [(f"{__name__}:StandardAppTester", ["--test-arg", "test"])], indirect=True)
+def test_standard_app(start_up):
+    """Test standard app functionality"""
+    lines = [line.strip() for line in start_up.readlines()]
+    expected_lines = [
+        "[TestStandardApp] init called",
+        "[TestStandardApp] start called",
+        "[TestStandardApp] test-arg test",
+        "[TestStandardApp] test-arg-with-default test-default",
+    ]
+    assert expected_lines[0] in lines, "Plugin not initialized"
+    assert expected_lines[1] in lines, "Plugin not started"
+    assert expected_lines[2] in lines, "Test argument not passed"
+    assert expected_lines[3] in lines, "Test argument with default not passed"
+    assert expected_lines == lines, "Ordering of lines not correct"
+
+@pytest.mark.parametrize("start_up", [(f"{__name__}:StandardAppTester", ["--test-arg", "test", "--test-arg-with-default", "test-non-default"])], indirect=True)
+def test_standard_app_with_non_defaults(start_up):
+    """Test standard app functionality"""
+    lines = [line.strip() for line in start_up.readlines()]
+    expected_lines = [
+        "[TestStandardApp] init called",
+        "[TestStandardApp] start called",
+        "[TestStandardApp] test-arg test",
+        "[TestStandardApp] test-arg-with-default test-non-default",
+    ]
+    assert expected_lines[0] in lines, "Plugin not initialized"
+    assert expected_lines[1] in lines, "Plugin not started"
+    assert expected_lines[2] in lines, "Test argument not passed"
+    assert expected_lines[3] in lines, "Test argument with overridden default not passed"
+    assert expected_lines == lines, "Ordering of lines not correct"
 
 def main():
-    """Run main entry point function
+    """Run main entry point function for StartApp plugin
 
     The main function is run when the file is invoked not as a pytest set of test, but rather when it is run as part of
     the StartApp plugin. This main program writes the second argument to the file represented as the first.