--dry_run
Should we really do the thing?
- Arguments themselves should be accessed via config.config['arg_name']. e.g.
+ Arguments themselves should be accessed via
+ config.config['arg_name']. e.g.
if not config.config['dry_run']:
module.do_the_thing()
+
"""
import argparse
+import logging
+import os
import pprint
import re
import sys
-from typing import Dict, Any
+from typing import Any, Dict, List
+
+import string_utils
# Note: at this point in time, logging hasn't been configured and
# anything we log will come out the root logger.
args = argparse.ArgumentParser(
description=f"This program uses config.py ({__file__}) for global, cross-module configuration.",
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
- fromfile_prefix_chars="@"
+ fromfile_prefix_chars="@",
)
config_parse_called = False
# It is also this variable that modules use to access parsed arguments
config: Dict[str, Any] = {}
+# Defer logging messages until later when logging has been initialized.
+saved_messages: List[str] = []
+
def add_commandline_args(title: str, description: str = ""):
"""Create a new context for arguments and return a handle."""
)
+def is_flag_already_in_argv(var: str):
+ """Is a particular flag passed on the commandline?"""
+ for _ in sys.argv:
+ if var in _:
+ return True
+ return False
+
+
def parse() -> Dict[str, Any]:
"""Main program should call this early in main()"""
global config_parse_called
+ if config_parse_called:
+ return
config_parse_called = True
- config.update(vars(args.parse_args()))
+ global saved_messages
+
+ # Examine the environment variables to settings that match
+ # known flags.
+ usage_message = args.format_usage()
+ optional = False
+ var = ''
+ for x in usage_message.split():
+ if x[0] == '[':
+ optional = True
+ if optional:
+ var += f'{x} '
+ if x[-1] == ']':
+ optional = False
+ var = var.strip()
+ var = var.strip('[')
+ var = var.strip(']')
+ chunks = var.split()
+ if len(chunks) > 1:
+ var = var.split()[0]
+
+ # Environment vars the same as flag names without
+ # the initial -'s and in UPPERCASE.
+ env = var.strip('-').upper()
+ if env in os.environ:
+ if not is_flag_already_in_argv(var):
+ value = os.environ[env]
+ saved_messages.append(
+ f'Initialized from environment: {var} = {value}'
+ )
+ if len(chunks) == 1 and string_utils.to_bool(value):
+ sys.argv.append(var)
+ elif len(chunks) > 1:
+ sys.argv.append(var)
+ sys.argv.append(value)
+ var = ''
+ env = ''
+ else:
+ next
+
+ # Parse (possibly augmented) commandline args with argparse normally.
+ #config.update(vars(args.parse_args()))
+ known, unknown = args.parse_known_args()
+ config.update(vars(known))
+
+ # Reconstruct the argv with unrecognized flags for the benefit of
+ # future argument parsers.
+ sys.argv = sys.argv[:1] + unknown
if config['config_savefile']:
with open(config['config_savefile'], 'w') as wf:
if config['config_dump']:
dump_config()
-
return config
def has_been_parsed() -> bool:
+ """Has the global config been parsed yet?"""
global config_parse_called
return config_parse_called
"""Print the current config to stdout."""
print("Global Configuration:", file=sys.stderr)
pprint.pprint(config, stream=sys.stderr)
+
+
+def late_logging():
+ """Log messages saved earlier now that logging has been initialized."""
+ logger = logging.getLogger(__name__)
+ global saved_messages
+ for _ in saved_messages:
+ logger.debug(_)