How to pass global debug flag variable throughout my code; should I use argparse?

Question

Let's say I have a main program (test.py) and a little utilities program (test_utils.py) that has helper functions called by the main program. I would like to turn on debug statements in the code by passing a debug_flag boolean, which is read in via argparse.

Now I would like functions within my test_utils.py program to print debug statements as well, according to the value of debug_flag. I could always add debug_flag as a parameter to each function definition in test_utils.py and pass the parameter when the function is called, but is there a better way here, like make debug_flag a global variable? But if I do declare debug_flag to be global from test.py, how would that be imported into test_utils.py?

What would be the most elegant/Pythonic approach here?

test.py:

import argparse
from test_utils import summation

def main():
    args = get_args()
    debug_flag = True if args[debug] == 'True' else False
    print summation(5, 6, 7)

def get_args():
    parser = argparse.ArgumentParser(description='Test program')
    parser.add_argument('-d','--debug', help='Debug True/False', default=False)
    args = vars(parser.parse_args())
    return args

test_utils.py:

from test import debug_flag

def summation(x, y, z):
    if debug_flag:
        print 'I am going to add %s %s and %s' % (x, y, z)
    return x + y + z

EDIT1: To clarify - if I pass in the debug flag through argparse and thereby do set debug_flag to True - how would this be propagated to functions within test_utils.py?

EDIT2: Based on the suggestion by @joran-beasley, here's what I've got.

test.py:

import argparse
import logging
from test_utils import summation

def main():
    args = get_args()
    logging.getLogger("my_logger").setLevel(logging.DEBUG if args['debug'] == 'True' else logging.WARNING)
    print summation(5, 6, 7)

def get_args():
    parser = argparse.ArgumentParser(description='Test program')
    parser.add_argument('-d','--debug', help='Debug True/False', required=True)
    args = vars(parser.parse_args())
    return args

main()

test_utils.py

import logging

log = logging.getLogger('my_logger')

def summation(x, y, z):
    log.debug('I am going to add %s %s and %s' % (x, y, z))
    return x + y + z

When I run test.py, I get:

$ python test.py -d True
No handlers could be found for logger "my_logger"
18

Answer 1

use logging

# this logger will always now be logging.DEBUG level
logging.getLogger("my_logger").setLevel(logging.DEBUG if args.debug else logging.WARNING)

then use

log = logging.getLogger("my_logger")
...
log.warn("some text that should always be seen!")
log.debug("some debug info!")

you can then do things where you have multiple levels of logging

log_level = logging.WARNING
if args.verbose > 0:
   log_level = logging.INFO
elif args.verbose > 3:
   log_level = logging.DEBUG

if for some reason you needed to retrieve the currentEffectiveLogLevel (you really shouldnt in most cases ... simply use log.debug when you want debug level output)

logging.getLogger("my_logger").getEffectiveLevel()

[edit to clarify]

log = logging.getLogger('my_logger')

def summation(x, y, z):
   log.debug('I am going to add %s %s and %s' % (x, y, z)) # will not print if my_logger does not have an effective level of debug
   return x + y + z

print(summation(2, 3, 4))
log.setLevel(logging.DEBUG)
print(summation(4, 5, 6))

or you can wrie a helper funtion

def is_debug():
    return logging.getLogger("my_logger").getEffectiveLevel() == logging.DEBUG

of coarse you can always do some horrible hacky crap also like writing it to a flat file and reading it in or using truly global variables (harder than you might think and lots of edge cases to worry about)

Answer 2

You can acheive a "package-wide" global in Python by passing around a mutable. My favored approach in these situations is to create a custom Flags class. You then share an instance of Flags between all of your modules, and its attributes function like globals. Here's an example in terms of the code you posted:

test_utils.py

__all__ = ['flags', 'summation']

class Flags(object):
    def __init__(self, *items):
        for key,val in zip(items[:-1], items[1:]):
            setattr(self,key,val)

flags = Flags('debug', False)

def summation(x, y, z):
    if flags.debug:
        print 'I am going to add %s %s and %s' % (x, y, z)
    return x + y + z

test.py

#!/usr/bin/env python2
import argparse
import sys

from test_utils import summation, flags

def main():
    args = get_args()
    flags.debug = args['debug']
    print summation(5, 6, 7)

def get_args():
    parser = argparse.ArgumentParser(description='Test program')
    parser.add_argument('-d','--debug', action='store_true', help='Debug True/False', default=False)
    args = vars(parser.parse_args())
    return args

if __name__=='__main__':
    main()

I moved flags to test_utils.py to avoid a circular import issue, but that shouldn't affect anything. A more robust solution (appropriate for larger projects) would be to have a separate config.py (or something) module in which flags is initialized.

Answer 3

Simple answer. Assign a dict in the main file. Then import it via all the other modules.

Test.py

debug_flag = {'setting' : False}

test_utils.py

from test import debug_flag

def print_flag():
    print(debug_flag['setting'])

def set_flag(setting):
    debug_flag['setting'] = setting

set_flag(True)
print_flag()

Now anytime you import the debug_flag from the main module, it will have whatever setting you set the flag too once you processed the arg parse. You could then change this at anytime, and subsequent calls will pick up the change.