X-Git-Url: https://wannabe.guru.org/gitweb/?a=blobdiff_plain;f=config.py;h=f543b0aab2ed1c2a72760b934c813426426df3a8;hb=865825894beeedd47d26dd092d40bfee582f5475;hp=cf6d5a1e0f0d53cbf9fc3977bd553928e859d8ec;hpb=f49bb9db0c6d1a8622dca1717db68462a4209112;p=python_utils.git diff --git a/config.py b/config.py index cf6d5a1..f543b0a 100644 --- a/config.py +++ b/config.py @@ -1,7 +1,9 @@ #!/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: ---------- @@ -36,7 +38,8 @@ different modules). Usage: 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] @@ -73,10 +76,6 @@ from typing import Any, Dict, List, Optional # 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] = [] @@ -84,23 +83,26 @@ 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 = ""): @@ -116,20 +118,30 @@ group.add_argument( '--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.' + ), ) @@ -141,34 +153,20 @@ def is_flag_already_in_argv(var: str): return False -def parse(entry_module: Optional[str]) -> Dict[str, Any]: - """Main program should call this early in main()""" - global config_parse_called - if config_parse_called: - logger.warning('config.parse has already been called; ignoring spurious invocation') - return config +def reorder_arg_action_groups(entry_module: Optional[str]): + reordered_action_groups = [] + for group in args._action_groups: + if entry_module is not None and entry_module in group.title: + reordered_action_groups.append(group) + elif program_name in group.title: + reordered_action_groups.append(group) + else: + reordered_action_groups.insert(0, group) + return reordered_action_groups - global saved_messages - # If we're about to do the usage message dump, put the main module's - # argument group last in the list (if possible) so that when the user - # passes -h or --help, it will be visible on the screen w/o scrolling. - reordered_action_groups = [] - global prog - for arg in sys.argv: - if arg == '--help' or arg == '-h': - for group in args._action_groups: - if entry_module is not None and entry_module in group.title: - reordered_action_groups.append(group) - elif program_name in group.title: - reordered_action_groups.append(group) - else: - 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 - # variable would be called EXAMPLE_FLAG. +def augment_sys_argv_from_environment_variables(): + global saved_messages usage_message = args.format_usage() optional = False var = '' @@ -196,6 +194,7 @@ def parse(entry_module: Optional[str]) -> Dict[str, Any]: 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: @@ -203,10 +202,10 @@ def parse(entry_module: Optional[str]) -> Dict[str, Any]: sys.argv.append(value) var = '' env = '' - else: - next - # Look for loadfile and read/parse it if present. + +def augment_sys_argv_from_loadfile(): + global saved_messages loadfile = None saw_other_args = False grab_next_arg = False @@ -223,19 +222,51 @@ def parse(entry_module: Optional[str]) -> Dict[str, Any]: saw_other_args = True if loadfile is not None: - if saw_other_args: - msg = f'WARNING: 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) - sys.exit(-1) + raise Exception( + f'ERROR: --config_loadfile argument must be a file, {loadfile} not found.' + ) + if saw_other_args: + msg = f'Augmenting commandline arguments with those from {loadfile}.' + else: + msg = f'Reading commandline arguments from {loadfile}.' + print(msg, file=sys.stderr) + saved_messages.append(msg) + with open(loadfile, 'r') as rf: newargs = rf.readlines() newargs = [arg.strip('\n') for arg in newargs if 'config_savefile' not in arg] sys.argv += newargs + +def parse(entry_module: Optional[str]) -> Dict[str, Any]: + """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: + return config + global saved_messages + + # If we're about to do the usage message dump, put the main + # module's argument group last in the list (if possible) so that + # when the user passes -h or --help, it will be visible on the + # screen w/o scrolling. + for arg in sys.argv: + if arg == '--help' or arg == '-h': + args._action_groups = reorder_arg_action_groups(entry_module) + + # Examine the environment for variables that match known flags. + # For a flag called --example_flag the corresponding environment + # variable would be called EXAMPLE_FLAG. If found, hackily add + # these into sys.argv to be parsed. + augment_sys_argv_from_environment_variables() + + # Look for loadfile and read/parse it if present. This also + # works by jamming these values onto sys.argv. + augment_sys_argv_from_loadfile() + # Parse (possibly augmented, possibly completely overwritten) # commandline args with argparse normally and populate config. known, unknown = args.parse_known_args() @@ -245,15 +276,21 @@ def parse(entry_module: Optional[str]) -> Dict[str, Any]: # 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']: @@ -273,6 +310,7 @@ def dump_config(): """Print the current config to stdout.""" print("Global Configuration:", file=sys.stderr) pprint.pprint(config, stream=sys.stderr) + print() def late_logging():