#!/usr/bin/env python3
-"""Global configuration driven by commandline arguments (even across
-different modules). Usage:
+"""Global configuration driven by commandline arguments, environment variables
+and saved configuration files. This works across several modules.
+
+Usage:
module.py:
----------
config.parse() # Very important, this must be invoked!
If you set this up and remember to invoke config.parse(), all commandline
- arguments will play nicely together:
+ arguments will play nicely together. This is done automatically for you
+ if you're using the bootstrap module's initialize wrapper.
% main.py -h
usage: main.py [-h]
# This module is commonly used by others in here and should avoid
# taking any unnecessary dependencies back on them.
-# Note: at this point in time, logging hasn't been configured and
-# anything we log will come out the root logger.
-logger = logging.getLogger(__name__)
-
# Defer logging messages until later when logging has been initialized.
saved_messages: List[str] = []
program_name = os.path.basename(sys.argv[0])
original_argv = [arg for arg in sys.argv]
+
# A global parser that we will collect arguments into.
args = argparse.ArgumentParser(
description=None,
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
fromfile_prefix_chars="@",
- epilog=f'-----------------------------------------------------------------------------\n{program_name} uses config.py ({__file__}) for global, cross-module configuration setup and parsing.\n-----------------------------------------------------------------------------'
+ epilog=f'{program_name} uses config.py ({__file__}) for global, cross-module configuration setup and parsing.',
)
# Keep track of if we've been called and prevent being called more
# than once.
config_parse_called = False
+
# A global configuration dictionary that will contain parsed arguments.
# It is also this variable that modules use to access parsed arguments.
# This is the data that is most interesting to our callers; it will hold
# the configuration result.
-config: Dict[str, Any] = {}
+config = {}
+# It would be really nice if this shit worked from interactive python
def add_commandline_args(title: str, description: str = ""):
'--config_loadfile',
metavar='FILENAME',
default=None,
- help='Config file from which to read args in lieu or in addition to commandline.',
+ help='Config file (populated via --config_savefile) from which to read args in lieu or in addition to commandline.',
)
group.add_argument(
'--config_dump',
default=False,
action='store_true',
- help='Display the global configuration on STDERR at program startup.',
+ help='Display the global configuration (possibly derived from multiple sources) on STDERR at program startup.',
)
group.add_argument(
'--config_savefile',
type=str,
metavar='FILENAME',
default=None,
- help='Populate config file compatible --config_loadfile to save config for later use.',
+ help='Populate config file compatible with --config_loadfile to save global config for later use.',
+)
+group.add_argument(
+ '--config_rejects_unrecognized_arguments',
+ default=False,
+ action='store_true',
+ help=(
+ 'If present, config will raise an exception if it doesn\'t recognize an argument. The '
+ + 'default behavior is to ignore this so as to allow interoperability with programs that '
+ + 'want to use their own argparse calls to parse their own, separate commandline args.'
+ ),
)
def parse(entry_module: Optional[str]) -> Dict[str, Any]:
- """Main program should call this early in main()"""
+ """Main program should call this early in main(). Note that the
+ bootstrap.initialize wrapper takes care of this automatically.
+
+ """
global config_parse_called
if config_parse_called:
- logger.warning('config.parse has already been called; ignoring spurious invocation')
return config
global saved_messages
reordered_action_groups.insert(0, group)
args._action_groups = reordered_action_groups
- # Examine the environment variables that match known flags. For a
- # flag called --example_flag the corresponding environment
+ # Examine the environment for variables that match known flags.
+ # For a flag called --example_flag the corresponding environment
# variable would be called EXAMPLE_FLAG.
usage_message = args.format_usage()
optional = False
f'Initialized from environment: {var} = {value}'
)
from string_utils import to_bool
+
if len(chunks) == 1 and to_bool(value):
sys.argv.append(var)
elif len(chunks) > 1:
if loadfile is not None:
if saw_other_args:
- msg = f'WARNING: Augmenting commandline arguments with those from {loadfile}.'
+ msg = f'Augmenting commandline arguments with those from {loadfile}.'
print(msg, file=sys.stderr)
saved_messages.append(msg)
if not os.path.exists(loadfile):
- print(f'--config_loadfile argument must be a file, {loadfile} not found.',
- file=sys.stderr)
+ print(
+ f'ERROR: --config_loadfile argument must be a file, {loadfile} not found.',
+ file=sys.stderr,
+ )
sys.exit(-1)
with open(loadfile, 'r') as rf:
newargs = rf.readlines()
# future argument parsers. For example, unittest_main in python
# has some of its own flags. If we didn't recognize it, maybe
# someone else will.
+ if len(unknown) > 0:
+ if config['config_rejects_unrecognized_arguments']:
+ raise Exception(
+ f'Encountered unrecognized config argument(s) {unknown} with --config_rejects_unrecognized_arguments enabled; halting.'
+ )
+ saved_messages.append(
+ f'Config encountered unrecognized commandline arguments: {unknown}'
+ )
sys.argv = sys.argv[:1] + unknown
# Check for savefile and populate it if requested.
savefile = config['config_savefile']
if savefile and len(savefile) > 0:
with open(savefile, 'w') as wf:
- wf.write(
- "\n".join(original_argv[1:])
- )
+ wf.write("\n".join(original_argv[1:]))
# Also dump the config on stderr if requested.
if config['config_dump']:
"""Print the current config to stdout."""
print("Global Configuration:", file=sys.stderr)
pprint.pprint(config, stream=sys.stderr)
+ print()
def late_logging():