fprime-gds 4.0.0a1__tar.gz → 4.0.0a2__tar.gz

{fprime_gds-4.0.0a1 → fprime_gds-4.0.0a2}/PKG-INFO

@@ -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 → fprime_gds-4.0.0a2}/pyproject.toml

@@ -42,7 +42,8 @@ dependencies = [
     "Jinja2>=2.11.3",
     "openpyxl>=3.0.10",
     "pyserial>=3.5",
-    "pydantic>=2.6"
+    "pydantic>=2.6",
+    "PyYAML>=6.0.2"
 ]
 
 [project.urls]

{fprime_gds-4.0.0a1 → fprime_gds-4.0.0a2}/src/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-4.0.0a1 → fprime_gds-4.0.0a2}/src/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-4.0.0a1 → fprime_gds-4.0.0a2}/src/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 → fprime_gds-4.0.0a2}/src/fprime_gds.egg-info/PKG-INFO

@@ -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 → fprime_gds-4.0.0a2}/src/fprime_gds.egg-info/requires.txt

@@ -10,3 +10,4 @@ Jinja2>=2.11.3
 openpyxl>=3.0.10
 pyserial>=3.5
 pydantic>=2.6
+PyYAML>=6.0.2