Access argparse variables from external module

Question

I have 4 modules:

• entry_point.py
• utils.py
• runner.py
• client.py

I use argparse in utils.py and I want to be able to retrieve the value of one of those arguments in client.py.

• Entry point module (the one that gets called from console):

  import utils
  def main():
      console_args = utils.parse_arguments() # Get command-line arguments
      runner.run(console_args) # The main function in the program
  
  if __name__ == '__main__':
      main()
  

• utils.py module:

  def parse_arguments():
      parser = argparse.ArgumentParser()
      parser.add_argument(
          # Several arguments, one of which should be 'url'
      )
      return parser.parse_args()
  

• runner.py module:

  import client
  
  def run(arguments):
      user = User.new(arguments.user_id)
      client.get_user_info(user)
  

• client.py module:

  def get_user_info(user):
      url = _compose_url('user_status')
      resp = requests.post(url, data=user.id)
  
  def _compose_url(method):
      # TODO: get base_url from console arguments
      # base_url = ?
      return base_url + str(method)
  

I don't want to pass url as a parameter to client.get_user_info() because I don't think it would be good to have it as a parameter for that function.

So I would like to be able to retrieve the argparse arguments I got from utils.parse_arguments() directly. Is there a way to do that?

Answer 1

Like the suggestion my comment and Mike Müller's answer, the below code sets a module-level variable.
To prevent argument parsing upon import, however, I set the variable only once parse_arguments is called. Since the variable is set to None before that happens, I also only import the variable when needed.
This way, parse_arguments is only run when you call it, not when you import the module. It is probably not needed in your specific case, but can be convenient when e.g. a module like utils is used in a package.

utils.py:

CONSOLE_ARGUMENTS = None

def parse_arguments():
    parser = argparse.ArgumentParser()
    parser.add_argument(
        # Several arguments, one of which should be 'url'
    )
     parser.parse_args()
    global CONSOLE_ARGUMENTS
    CONSOLE_ARGUMENTS = parser.parse_args()
    return CONSOLE_ARGUMENTS

client.py:

def _compose_url(method):
    from .utils import CONSOLE_ARGUMENTS
    base_url = CONSOLE_ARGUMENTS.base_url
    return base_url + str(method)

Answer 2

Make a new module console_args.py:

"""
Parsing of command line arguments.

No other functionality should be added to this module.
The typically usage is:

>>> from console_args import CONSOLE_ARGS 
"""

def _parse_arguments():
    parser = argparse.ArgumentParser()
    parser.add_argument(
        # Several arguments, one of which should be 'url'
    )
    return parser.parse_args()

CONSOLE_ARGS =  _parse_arguments()

# optional: delete function after use to prevent calling from other place
del _parse_arguments

Now you use it in all modules:

from console_args import CONSOLE_ARGS

The function _parse_arguments() will be executed only once. Modules in Python are singletons, i.e. they will only executed at the first import. Each subsequent import will get a module object without doing the whole import procedure, that executes all module level code, again.

The underscore in _parse_arguments()indicates that this function is not supposed to be used outside the module console_args.py. Deleting _parse_arguments after it was called will prevent any other call of _parse_arguments() during the run time of the program (as long as no reload tricks are applied).