Merge remote-tracking branch 'origin/configs'

Author: martinjm97

README.md

@@ -55,6 +55,7 @@ pip install -e .
       - [Save](#save)
       - [Load](#load)
       - [Load from dict](#load-from-dict)
+    + [Loading from configuration files](#loading-from-configuration-files)
 
 ## Tap is Python-native
 To see this, let's look at an example:
@@ -446,3 +447,22 @@ args.from_dict({
 ```
 
 Note: As with `load`, all required arguments must be present in the dictionary if not already set in the Tap object. All values in the provided dictionary will overwrite values currently in the Tap object.
+
+### Loading from configuration files
+Configuration files can be loaded along with arguments with the optional flag `config_files: List[str]`. Arguments passed in from the command line overwrite arguments from the configuration files. Arguments in configuration files that appear later in the list overwrite the arguments in previous configuration files.
+
+For example, if you have the config file `my_config.txt` 
+```
+--arg1 1
+--arg2 two
+```
+then you can write
+```python
+from tap import Tap
+
+class Args(Tap):
+    arg1: int
+    arg2: str
+
+args = Args(config_files=['my_config']).parse_args()
+```

tap/tap.py

@@ -1,4 +1,4 @@
-from argparse import ArgumentParser, _SubParsersAction
+from argparse import ArgumentParser
 from collections import OrderedDict
 from copy import deepcopy
 import json
@@ -53,6 +53,7 @@ def __init__(self,
                  *args,
                  underscores_to_dashes: bool = False,
                  explicit_bool: bool = False,
+                 config_files: Optional[List[str]] = None,
                  **kwargs):
         """Initializes the Tap instance.
 
@@ -61,6 +62,10 @@ def __init__(self,
         :param explicit_bool: Booleans can be specified on the command line as "--arg True" or "--arg False"
                               rather than "--arg". Additionally, booleans can be specified by prefixes of True and False
                               with any capitalization as well as 1 or 0.
+        :param config_files: A list of paths to configuration files containing the command line arguments
+                             (e.g., '--arg1 a1 --arg2 a2'). Arguments passed in from the command line
+                             overwrite arguments from the configuration files. Arguments in configuration files
+                             that appear later in the list overwrite the arguments in previous configuration files.
         :param kwargs: Keyword arguments passed to the super class ArgumentParser.
         """
         # Whether the Tap object has been initialized
@@ -96,6 +101,9 @@ def __init__(self,
         # Stores all of the subparsers
         self._subparsers = None
 
+        # Load in the configuration files
+        self.args_from_configs = self._load_from_config_files(config_files)
+
         # Perform additional configuration such as modifying add_arguments or adding subparsers
         self._configure()
 
@@ -377,6 +385,12 @@ def parse_args(self: TapType,
         if self._parsed:
             raise ValueError('parse_args can only be called once.')
 
+        # Collect arguments from all of the configs
+        config_args = [arg for args_from_config in self.args_from_configs for arg in args_from_config.split()]
+
+        # Add config args at lower precedence and extract args from the command line if they are not passed explicitly
+        args = config_args + (sys.argv[1:] if args is None else list(args))
+
         # Parse args using super class ArgumentParser's parse_args or parse_known_args function
         if known_only:
             default_namespace, self.extra_args = super(Tap, self).parse_known_args(args)
@@ -602,6 +616,25 @@ def load(self,
 
         return self
 
+    def _load_from_config_files(self, config_files: Optional[List[str]]) -> List[str]:
+        """Loads arguments from a list of configuration files containing command line arguments.
+
+        :param config_files: A list of paths to configuration files containing the command line arguments
+                             (e.g., '--arg1 a1 --arg2 a2'). Arguments passed in from the command line
+                             overwrite arguments from the configuration files. Arguments in configuration files
+                             that appear later in the list overwrite the arguments in previous configuration files.
+        :return: A list of the contents of each config file in order of increasing precedence (highest last).
+        """
+        args_from_config = []
+
+        if config_files is not None:
+            # Read arguments from all configs from the lowest precedence config to the highest
+            for file in config_files:
+                with open(file) as f:
+                    args_from_config.append(f.read().strip())
+
+        return args_from_config
+
     def __str__(self) -> str:
         """Returns a string representation of self.
 

tests/test_load_config_files.py

@@ -0,0 +1,120 @@
+import sys
+from tempfile import NamedTemporaryFile
+import unittest
+from unittest import TestCase
+
+from tap import Tap
+
+
+class LoadConfigFilesTests(TestCase):
+
+    def setUp(self) -> None:
+        class DevNull:
+            def write(self, msg):
+                pass
+        self.dev_null = DevNull()
+
+    def test_file_does_not_exist(self) -> None:
+        class EmptyTap(Tap):
+            pass
+
+        with self.assertRaises(FileNotFoundError):
+            EmptyTap(config_files=['nope']).parse_args([])
+
+    def test_single_config(self) -> None:
+        class SimpleTap(Tap):
+            a: int
+            b: str = 'b'
+
+        with NamedTemporaryFile() as f:
+            f.write(b'--a 1')
+            f.flush()
+            args = SimpleTap(config_files=[f.name]).parse_args([])
+
+        self.assertEqual(args.a, 1)
+        self.assertEqual(args.b, 'b')
+
+    def test_single_config_overwriting(self) -> None:
+        class SimpleOverwritingTap(Tap):
+            a: int
+            b: str = 'b'
+
+        with NamedTemporaryFile() as f:
+            f.write(b'--a 1 --b two')
+            f.flush()
+            args = SimpleOverwritingTap(config_files=[f.name]).parse_args('--a 2'.split())
+
+        self.assertEqual(args.a, 2)
+        self.assertEqual(args.b, 'two')
+
+    def test_single_config_known_only(self) -> None:
+        class KnownOnlyTap(Tap):
+            a: int
+            b: str = 'b'
+
+        with NamedTemporaryFile() as f:
+            f.write(b'--a 1 --c seeNothing')
+            f.flush()
+            args = KnownOnlyTap(config_files=[f.name]).parse_args([], known_only=True)
+
+        self.assertEqual(args.a, 1)
+        self.assertEqual(args.b, 'b')
+        self.assertEqual(args.extra_args, ['--c', 'seeNothing'])
+
+    def test_single_config_required_still_required(self) -> None:
+        class KnownOnlyTap(Tap):
+            a: int
+            b: str = 'b'
+
+        with NamedTemporaryFile() as f, self.assertRaises(SystemExit):
+            sys.stderr = self.dev_null
+            f.write(b'--b fore')
+            f.flush()
+            KnownOnlyTap(config_files=[f.name]).parse_args([])
+
+    def test_multiple_configs(self) -> None:
+        class MultipleTap(Tap):
+            a: int
+            b: str = 'b'
+
+        with NamedTemporaryFile() as f1, NamedTemporaryFile() as f2:
+            f1.write(b'--b two')
+            f1.flush()
+            f2.write(b'--a 1')
+            f2.flush()
+            args = MultipleTap(config_files=[f1.name, f2.name]).parse_args([])
+
+        self.assertEqual(args.a, 1)
+        self.assertEqual(args.b, 'two')
+
+    def test_multiple_configs_overwriting(self) -> None:
+        class MultipleOverwritingTap(Tap):
+            a: int
+            b: str = 'b'
+            c: str = 'c'
+
+        with NamedTemporaryFile() as f1, NamedTemporaryFile() as f2:
+            f1.write(b'--a 1 --b two')
+            f1.flush()
+            f2.write(b'--a 2 --c see')
+            f2.flush()
+            args = MultipleOverwritingTap(config_files=[f1.name, f2.name]).parse_args('--b four'.split())
+
+        self.assertEqual(args.a, 2)
+        self.assertEqual(args.b, 'four')
+        self.assertEqual(args.c, 'see')
+
+    def test_junk_config(self) -> None:
+        class JunkConfigTap(Tap):
+            a: int
+            b: str = 'b'
+
+        with NamedTemporaryFile() as f1, self.assertRaises(SystemExit):
+            sys.stderr = self.dev_null
+            f1.write(b'is not a file that can reasonably be parsed')
+            f1.flush()
+            JunkConfigTap(config_files=[f1.name]).parse_args()
+
+
+if __name__ == '__main__':
+    unittest.main()