How to use a module with arguments?

Question

I have a module, called T, has a couple of functions and the main part, where calls these functions. From another module, I want to use this module. The main scheme is like:

"""Module T"""
def parse_args():
    parser = argparse.ArgumentParser(description='Desc')
    parser.add_argument('something')

def foo():
    pass

if __name__ == "__main__":
    args = parse_args()
    foo()

And the other module I want to use:

"""Module M"""
def foo():
    pass

def do_something():
    """Where I want to use module T's main"""

I have used module T from terminal with arguments and worked fine. The question may be easy but, how can I use it's main with parameters?

If you really need to call its main, I think the only way to do it is calling it as an external program. But why would you want to call its main in the first place? Why not simply calling `T`s methods inside directly? — Tobias Brösamle, Nov 16 '18 at 13:58
Seems like the easiest solution might just be to pull those two lines into a `main()` function inside `T`, then call `main()` both from `T` and from `M`. — 0x5453, Nov 16 '18 at 13:58
@TobiasBrösamle I'm new to python and it's logic about main. I have searched an answer to this but didn't find any. I thought a solution as the same as 0x5453's but insisted to find an easier way. You both of you might be right. — emremrah, Nov 16 '18 at 14:02

Mad Physicist · Accepted Answer · 2018-11-16T14:38:09.473

2

Add a run function (or main or whatever you like) to your module that accepts your command line, and make sure that parse_args optionally accepts an arbitrary list as well:

def parse_args(args=None):
    parser = argparse.ArgumentParser(description='Desc')
    parser.add_argument('something')
    return parser.parse_args(args)

def foo():
    pass

def run(args=None):
    args = parse_args(args)
    foo()

if __name__ == "__main__":
    run()

Basically, instead of trying to simulate the import operation and injecting sys.argv (which might actually be possible), you can just factor out the part that the import runs that's of interest to you, and provide access to it:

import T

T.run()  # Uses sys.argv
T.run(['my', 'list', '--of', 'args'])

While totally untested, you can possibly also do something like the following (please don't though, this is just for fun):

import sys
from importlib import reload

sys.argv[1:] = my_args

if 'T' in sys.modules:
    reload(sys.modules['T'])
else:
    import T

But then you'd need to remove the import guard in T.py. Unless you wanted to implement your own module loading sequence, which would let you inject T.__name__, rather than having to modify the import guard: Injecting variables into an import namespace

edited Nov 16 '18 at 14:38

answered Nov 16 '18 at 14:00

Mad Physicist

107,652
25
181
264

I think you'll want to call `run`, not `foo`, from the guarded block. – chepner Nov 16 '18 at 14:00
@chepner. Yes. Fixed. Typing fast on mobile :) – Mad Physicist Nov 16 '18 at 14:01
So I just need to import `T` in `M`, then do `T.run()`? If so, why I need the main part? – emremrah Nov 16 '18 at 14:05
I also think you wanted to give `args` to `parse_args` inside your `run` method. – Tobias Brösamle Nov 16 '18 at 14:05
I think this is the solution then. I will inform you. Thanks a lot. Easier than I thought :) – emremrah Nov 16 '18 at 14:07
@emerath. So you can also run it as a script. I've found that to be a useful feature sometimes. – Mad Physicist Nov 16 '18 at 14:10
@Tobias. Good catch. Thanks – Mad Physicist Nov 16 '18 at 14:12
@MadPhysicist In the main, it's `run()`, but `def run(args)` takes a parameter. Is that going to work? Because IntelliJ is giving a warning. – emremrah Nov 16 '18 at 14:19
@emremrah. That's quite deliberate. The default `args` is `None` throughout, which makes `ArgumentParser` use `sys.argv` when you call it like that. – Mad Physicist Nov 16 '18 at 14:22
@MadPhysicist Okay I edited it to `run(passed_args=None)` in the `__main__`. Thanks a lot, I think this will work. – emremrah Nov 16 '18 at 14:26
@emremrah. I agree that the variable names can stand some improvement. But you shouldn't need to pass None explicitly. That's the whole point of a default argument. – Mad Physicist Nov 16 '18 at 14:27

Charles Landau · Answer 2 · 2018-11-16T14:06:29.683

2

The if __name__ ... pattern is executed if the script is called directly, so the real solution is to call foo in your entrypoint. The if __name__ ... patter basically protects lines of code from being executed on import. For example, this is a very convenient pattern for testing - just put your tests in the protected block. The straightforward way to do what you're asking:

"""Module M"""
def bar():
    pass

def do_something(args):
    args = parse_args()
    module_t.foo()

If you want module M to be completely "fire and forget" then Mad Physicist's answer is for you.

edited Nov 16 '18 at 14:06

answered Nov 16 '18 at 14:01

Charles Landau

4,187
1
8
24

What is `module_m`? – Mad Physicist Nov 16 '18 at 14:05
Good catch should have been module_t @MadPhysicist! – Charles Landau Nov 16 '18 at 14:06

How to use a module with arguments?

2 Answers2