ACL uses enums, some more tests, other stuff.

[python_utils.git] / config.py

diff --git a/config.py b/config.py
index bc0dcdf14f23b5edd8582a4fd8afcd9425a5bd36..e7094f3a5ba6d6c4646a579d2e5e1e47cc8e330a 100644 (file)
--- a/config.py
+++ b/config.py
@@ -55,17 +55,24 @@ different modules).  Usage:
       --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
+
+# 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.
@@ -96,7 +103,7 @@ class LoadFromFile(argparse.Action):
 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
 
@@ -104,6 +111,9 @@ 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."""
@@ -137,11 +147,70 @@ group.add_argument(
 )
 
 
+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]:
+    import string_utils
+
     """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:
@@ -149,11 +218,11 @@ def parse() -> Dict[str, Any]:
 
     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
 
@@ -162,3 +231,11 @@ def dump_config():
     """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(_)