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

fprime_gds/common/communication/adapters/uart.py

@@ -59,7 +59,7 @@ class SerialAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
         4000000,
     ]
 
-    def __init__(self, device, baud):
+    def __init__(self, device, baud, skip_check):
         """
         Initialize the serial adapter using the default settings. This does not open the serial port, but sets up all
         the internal variables used when opening the device.
@@ -77,9 +77,14 @@ class SerialAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
         Opens the serial port based on previously supplied settings. If the port is already open, then close it first.
         Then open the port up again.
         """
-        self.close()
-        self.serial = serial.Serial(self.device, self.baud)
-        return self.serial is not None
+        try:
+            self.close()
+            self.serial = serial.Serial(self.device, self.baud)
+            return self.serial is not None
+        except serial.serialutil.SerialException as exc:
+            LOGGER.warning("Serial exception caught: %s. Reconnecting.", (str(exc)))
+            self.close()
+            return False
 
     def close(self):
         """
@@ -100,12 +105,11 @@ class SerialAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
         :return: True, when data was sent through the UART. False otherwise.
         """
         try:
-            if self.serial is None:
-                self.open()
-            written = self.serial.write(frame)
-            # Not believed to be possible to not send everything without getting a timeout exception
-            assert written == len(frame)
-            return True
+            if self.serial is not None or self.open():
+                written = self.serial.write(frame)
+                # Not believed to be possible to not send everything without getting a timeout exception
+                assert written == len(frame)
+                return True
         except serial.serialutil.SerialException as exc:
             LOGGER.warning("Serial exception caught: %s. Reconnecting.", (str(exc)))
             self.close()
@@ -121,17 +125,16 @@ class SerialAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
         """
         data = b""
         try:
-            if self.serial is None:
-                self.open()
-            # Read as much data as possible, while ensuring to block if no data is available at this time. Note: as much
-            # data is read as possible to avoid a long-return time to this call. Minimum data to read is one byte in
-            # order to block this function while data is incoming.
-            self.serial.timeout = timeout
-            data = self.serial.read(1)  # Force a block for at least 1 character
-            while self.serial.in_waiting:
-                data += self.serial.read(
-                    self.serial.in_waiting
-                )  # Drain the incoming data queue
+            if self.serial is not None or self.open():                
+                # Read as much data as possible, while ensuring to block if no data is available at this time. Note: as much
+                # data is read as possible to avoid a long-return time to this call. Minimum data to read is one byte in
+                # order to block this function while data is incoming.
+                self.serial.timeout = timeout
+                data = self.serial.read(1)  # Force a block for at least 1 character
+                while self.serial.in_waiting:
+                    data += self.serial.read(
+                        self.serial.in_waiting
+                    )  # Drain the incoming data queue
         except serial.serialutil.SerialException as exc:
             LOGGER.warning("Serial exception caught: %s. Reconnecting.", (str(exc)))
             self.close()
@@ -161,6 +164,12 @@ class SerialAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
                 "default": 9600,
                 "help": "Baud rate of the serial device.",
             },
+            ("--uart-skip-port-check",): {
+                "dest": "skip_check",
+                "default": False,
+                "action": "store_true",
+                "help": "Skip checking that the port exists"
+            }
         }
 
     @classmethod
@@ -175,20 +184,20 @@ class SerialAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
         return cls
 
     @classmethod
-    def check_arguments(cls, device, baud):
+    def check_arguments(cls, device, baud, skip_check):
         """
         Code that should check arguments of this adapter. If there is a problem with this code, then a "ValueError"
         should be raised describing the problem with these arguments.
 
         :param args: arguments as dictionary
         """
-        ports = map(lambda info: info.device, list_ports.comports(include_links=True))
-        if device not in ports:
+        ports = list(map(lambda info: info.device, list_ports.comports(include_links=True)))
+        if not skip_check and device not in ports:
             msg = f"Serial port '{device}' not valid. Available ports: {ports}"
             raise ValueError(
                 msg
             )
-        # Note: baud rate may not *always* work. These are a superset
+        # Note: baud rate may not *always* work. These are a superset.
         try:
             baud = int(baud)
         except ValueError:

fprime_gds/executables/cli.py

@@ -19,6 +19,9 @@ import os
 import platform
 import re
 import sys
+
+import yaml
+
 from abc import ABC, abstractmethod
 from pathlib import Path
 from typing import Any, Dict, List, Tuple
@@ -185,8 +188,32 @@ class ParserBase(ABC):
         Returns: namespace with processed results of arguments.
         """
 
-    @staticmethod
+    @classmethod
+    def parse_known_args(
+        cls,
+        parser_classes,
+        description="No tool description provided",
+        arguments=None,
+        **kwargs,
+    ):
+        """Parse and post-process arguments
+
+        Create a parser for the given application using the description provided. This will then add all specified
+        ParserBase subclasses' get_parser output as parent parses for the created parser. Then all of the handle
+        arguments methods will be called, and the final namespace will be returned. This will allow unknown arguments
+        which are returned as the last tuple result.
+
+        Args:
+            parser_classes: a list of ParserBase subclasses that will be used to
+            description: description passed ot the argument parser
+            arguments: arguments to process, None to use command line input
+        Returns: namespace with all parsed arguments from all provided ParserBase subclasses
+        """
+        return cls._parse_args(parser_classes, description, arguments, use_parse_known=True, **kwargs)
+
+    @classmethod
     def parse_args(
+        cls,
         parser_classes,
         description="No tool description provided",
         arguments=None,
@@ -194,20 +221,53 @@ class ParserBase(ABC):
     ):
         """Parse and post-process arguments
 
+        Create a parser for the given application using the description provided. This will then add all specified
+        ParserBase subclasses' get_parser output as parent parses for the created parser. Then all of the handle
+        arguments methods will be called, and the final namespace will be returned. This does not allow unknown
+        arguments.
+
+        Args:
+            parser_classes: a list of ParserBase subclasses that will be used to
+            description: description passed ot the argument parser
+            arguments: arguments to process, None to use command line input
+        Returns: namespace with all parsed arguments from all provided ParserBase subclasses
+        """
+        return cls._parse_args(parser_classes, description, arguments, **kwargs)
+
+
+    @staticmethod
+    def _parse_args(
+        parser_classes,
+        description="No tool description provided",
+        arguments=None,
+        use_parse_known=False,
+        **kwargs,
+    ):
+        """Parse and post-process arguments helper
+
         Create a parser for the given application using the description provided. This will then add all specified
         ParserBase subclasses' get_parser output as parent parses for the created parser. Then all of the handle
         arguments methods will be called, and the final namespace will be returned.
 
+        This takes a function that will take in a parser and return the parsing function to call on arguments.
+
         Args:
+            parse_function_processor: takes a parser, returns the parse function to call
             parser_classes: a list of ParserBase subclasses that will be used to
             description: description passed ot the argument parser
             arguments: arguments to process, None to use command line input
+            use_parse_known: use parse_known_arguments from argparse
+
         Returns: namespace with all parsed arguments from all provided ParserBase subclasses
         """
         composition = CompositeParser(parser_classes, description)
         parser = composition.get_parser()
         try:
-            args_ns = parser.parse_args(arguments)
+            if use_parse_known:
+                args_ns, *unknowns = parser.parse_known_args(arguments)
+            else:
+                args_ns = parser.parse_args(arguments)
+                unknowns = []
             args_ns = composition.handle_arguments(args_ns, **kwargs)
         except ValueError as ver:
             print(f"[ERROR] Failed to parse arguments: {ver}", file=sys.stderr)
@@ -216,7 +276,7 @@ class ParserBase(ABC):
         except Exception as exc:
             print(f"[ERROR] {exc}", file=sys.stderr)
             sys.exit(-1)
-        return args_ns, parser
+        return args_ns, parser, *unknowns
 
     @staticmethod
     def find_in(token, deploy, is_file=True):
@@ -236,6 +296,106 @@ class ParserBase(ABC):
         return None
 
 
+class ConfigDrivenParser(ParserBase):
+    """ Parser that allows options from configuration and command line
+
+    This parser reads a configuration file (if supplied) and uses the values to drive the inputs to arguments. Command
+    line arguments will still take precedence over the configured values.
+    """
+    DEFAULT_CONFIGURATION_PATH = Path("fprime-gds.yml")
+
+    @classmethod
+    def set_default_configuration(cls, path: Path):
+        """ Set path for (global) default configuration file
+
+        Set the path for default configuration file. If unset, will use 'fprime-gds.yml'. Set to None to disable default
+        configuration.
+        """
+        cls.DEFAULT_CONFIGURATION_PATH = path
+
+    @classmethod
+    def parse_args(
+        cls,
+        parser_classes,
+        description="No tool description provided",
+        arguments=None,
+        **kwargs,
+    ):
+        """ Parse and post-process arguments using inputs and config
+
+        Parse the arguments in two stages: first parse the configuration data, ignoring unknown inputs, then parse the
+        full argument set with the supplied configuration to fill in additional options.
+
+        Args:
+            parser_classes: a list of ParserBase subclasses that will be used to
+            description: description passed ot the argument parser
+            arguments: arguments to process, None to use command line input
+        Returns: namespace with all parsed arguments from all provided ParserBase subclasses
+        """
+        arguments = sys.argv[1:] if arguments is None else arguments
+
+        # Help should spill all the arguments, so delegate to the normal parsing flow including
+        # this and supplied parsers
+        if "-h" in arguments or "--help" in arguments:
+            parsers = [ConfigDrivenParser] + parser_classes
+            ParserBase.parse_args(parsers, description, arguments, **kwargs)
+            sys.exit(0)
+
+        # Custom flow involving parsing the arguments of this parser first, then passing the configured values
+        # as part of the argument source
+        ns_config, _, remaining = ParserBase.parse_known_args([ConfigDrivenParser], description, arguments, **kwargs)
+        config_options = ns_config.config_values.get("command-line-options", {})
+        config_args = cls.flatten_options(config_options)
+        # Argparse allows repeated (overridden) arguments, thus the CLI override is accomplished by providing
+        # remaining arguments after the configured ones
+        ns_full, parser = ParserBase.parse_args(parser_classes, description, config_args + remaining, **kwargs)
+        ns_final =  argparse.Namespace(**vars(ns_config), **vars(ns_full))
+        return ns_final, parser
+
+    @staticmethod
+    def flatten_options(configured_options):
+        """ Flatten options down to arguments """
+        flattened = []
+        for option, value in configured_options.items():
+            flattened.append(f"--{option}")
+            if value is not None:
+                flattened.extend(value if isinstance(value, (list, tuple)) else [f"{value}"])
+        return flattened
+
+    def get_arguments(self) -> Dict[Tuple[str, ...], Dict[str, Any]]:
+        """Arguments needed for config processing"""
+        return {
+            ("-c", "--config"): {
+                "dest": "config",
+                "required": False,
+                "default": self.DEFAULT_CONFIGURATION_PATH,
+                "type": Path,
+                "help": f"Argument configuration file path.",
+            }
+        }
+
+    def handle_arguments(self, args, **kwargs):
+        """ Handle the arguments
+
+        Loads the configuration file specified and fills in the `config_values` attribute of the namespace with the
+        loaded configuration dictionary.
+        """
+        args.config_values = {}
+        # Specified but non-existent config file is a hard error
+        if ("-c" in sys.argv[1:] or "--config" in sys.argv[1:]) and not args.config.exists():
+            raise ValueError(f"Specified configuration file '{args.config}' does not exist")
+        # Read configuration if the file was set and exists
+        if args.config is not None  and args.config.exists():
+            print(f"[INFO] Reading command-line configuration from: {args.config}")
+            with open(args.config, "r") as file_handle:
+                try:
+                    loaded = yaml.safe_load(file_handle)
+                    args.config_values = loaded if loaded is not None else {}
+                except Exception as exc:
+                    raise ValueError(f"Malformed configuration {args.config}: {exc}", exc)
+        return args
+
+
 class DetectionParser(ParserBase):
     """Parser that detects items from a root/directory or deployment"""
 

fprime_gds/executables/run_deployment.py

@@ -9,6 +9,7 @@ import webbrowser
 
 from fprime_gds.executables.cli import (
     BinaryDeployment,
+    ConfigDrivenParser,
     CommParser,
     GdsParser,
     ParserBase,
@@ -37,7 +38,7 @@ def parse_args():
         PluginArgumentParser,
     ]
     # Parse the arguments, and refine through all handlers
-    args, parser = ParserBase.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
 
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fprime-gds
-Version: 4.0.0a1
+Version: 4.0.0a2
 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: 
@@ -240,6 +240,7 @@ Requires-Dist: Jinja2>=2.11.3
 Requires-Dist: openpyxl>=3.0.10
 Requires-Dist: pyserial>=3.5
 Requires-Dist: pydantic>=2.6
+Requires-Dist: PyYAML>=6.0.2
 Dynamic: license-file
 
 # F´ GDS

{fprime_gds-4.0.0a1.dist-info → fprime_gds-4.0.0a2.dist-info}/RECORD

@@ -13,7 +13,7 @@ fprime_gds/common/communication/updown.py,sha256=UhfCIIA2eM5g2FsIhOGJJH6HzHurUPg
 fprime_gds/common/communication/adapters/__init__.py,sha256=ivGtzUTqhBYuve5mhN9VOHITwgZjNMVv7sxuac2Ll3c,470
 fprime_gds/common/communication/adapters/base.py,sha256=i3mf4HC-4tuf4mNkhdXCKlngRhODyTriia2pw6XBoSQ,3393
 fprime_gds/common/communication/adapters/ip.py,sha256=vCDclpsb3rVRXSxKqdt9UfkM2M6oCxnsKdzbzhMc0kM,17074
-fprime_gds/common/communication/adapters/uart.py,sha256=6SrN42ShVjwNubFg-1YrO09o1uJtu1rFqeMpLDNWlW4,6647
+fprime_gds/common/communication/adapters/uart.py,sha256=5WkA8xpQ8E7nv2DbN168fibz1l-GddJUKnf6Hcd4hvU,7194
 fprime_gds/common/controllers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/common/data_types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/common/data_types/ch_data.py,sha256=RP9zSyzNcH0nJ3MYyW_IATnmnHYZ6d0KmoJUJantdBI,6111
@@ -112,11 +112,11 @@ fprime_gds/common/utils/event_severity.py,sha256=7qPXHrDaM_REJ7sKBUEJTZIE0D4qVnV
 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=iyHloLaHJOkcZF6O3oXZX6YpoS2SBBZVPilf25l0Q98,13138
-fprime_gds/executables/cli.py,sha256=kdwQ3Wqi7zg0v3QkOyy3YEh3w3T520yGmIMJEk4mAzs,43180
+fprime_gds/executables/cli.py,sha256=7tqSMgFTSb20g9iMb02LOWrTYhePhX8Qe2kPZCzvquI,50381
 fprime_gds/executables/comm.py,sha256=08rO0o0MJgTRngB7Ygu2IL_gEAWKF7WFvFyro1CqReE,5214
 fprime_gds/executables/data_product_writer.py,sha256=aXnQ75hQ8bapz-sr21mrPCrXIfqQblfBuB49GGZrFLg,34965
 fprime_gds/executables/fprime_cli.py,sha256=CMoT7zWNwM8h2mSZW03AR96wl_XnZXoLNiOZN_sDi38,12431
-fprime_gds/executables/run_deployment.py,sha256=sOtvVcNOSUZMvELc4cDVAXhBNAFIWM3OjxLq_sXf0tc,7177
+fprime_gds/executables/run_deployment.py,sha256=x6auxjsDyCj4216JbO0bSskv2H9r7n3vuu5Z3O5cGwY,7209
 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
@@ -233,10 +233,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=UiNrUqfi-KJOgRIOR8uyFMKdquSPZh_txpNq8eH35-Y,13285
-fprime_gds-4.0.0a1.dist-info/licenses/LICENSE.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-fprime_gds-4.0.0a1.dist-info/licenses/NOTICE.txt,sha256=vXjA_xRcQhd83Vfk5D_vXg5kOjnnXvLuMi5vFKDEVmg,1612
-fprime_gds-4.0.0a1.dist-info/METADATA,sha256=BLViE79kzUK1-kjXnrjPrsQ1Syaugyyo4eWgL9EiqVM,24457
-fprime_gds-4.0.0a1.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-fprime_gds-4.0.0a1.dist-info/entry_points.txt,sha256=qFBHIR7CZ5CEeSEdZ-ZVQN9ZfUOZfm0PvvDZAAheuLk,445
-fprime_gds-4.0.0a1.dist-info/top_level.txt,sha256=6vzFLIX6ANfavKaXFHDMSLFtS94a6FaAsIWhjgYuSNE,27
-fprime_gds-4.0.0a1.dist-info/RECORD,,
+fprime_gds-4.0.0a2.dist-info/licenses/LICENSE.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+fprime_gds-4.0.0a2.dist-info/licenses/NOTICE.txt,sha256=vXjA_xRcQhd83Vfk5D_vXg5kOjnnXvLuMi5vFKDEVmg,1612
+fprime_gds-4.0.0a2.dist-info/METADATA,sha256=8DZ3LB73jYM-qOHVEWFVzK_R2pfh18gkk1zWK0LIHhE,24486
+fprime_gds-4.0.0a2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fprime_gds-4.0.0a2.dist-info/entry_points.txt,sha256=qFBHIR7CZ5CEeSEdZ-ZVQN9ZfUOZfm0PvvDZAAheuLk,445
+fprime_gds-4.0.0a2.dist-info/top_level.txt,sha256=6vzFLIX6ANfavKaXFHDMSLFtS94a6FaAsIWhjgYuSNE,27
+fprime_gds-4.0.0a2.dist-info/RECORD,,

{fprime_gds-4.0.0a1.dist-info → fprime_gds-4.0.0a2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.7.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any