python: stop imported module from parsing command line arguments

Question

I'm using an external python module, which is not written by me therefore cannot be changed. This module, called magnum (http://micromagnum.informatik.uni-hamburg.de), processes all optional command line arguments. Here an example to illustrate the behavior:

script1.py

#!/usr/bin/env python
import magnum

executing the script yields:

>>> ./script1.py -h
[WARNING] - Python Imaging Library not found!
[WARNING] - -> This means that the ImageShapeCreator and related classes are not available!
[   INFO] - Imported FFTW wisdom from file
Usage: scipt1.py [options]

Options:
  --version             show program's version number and exit
  -h, --help            show this help message and exit

  Hardware options:
    Options that control which hardware is used.

    -g GPU_ID           enable GPU processing (using 32-bit accuracy) on cuda
                    device GPU_ID. The simulator will fall back to CPU
                    mode if it was not compiled with CUDA support or when
                    no CUDA capable graphics cards were detected.
    -G GPU_ID           enable GPU processing (using 64-bit accuracy) on cuda
                    device GPU_ID. TODO: Describe fallback behaviour.
    -t NUM_THREADS, --threads=NUM_THREADS
                    enable CPU multithreading with NUM_THREADS (1..64)
                    threads. This parameter instructs the fftw library to
                    use NUM_THREADS threads for computing FFTs.

  Logging options:
    Options related to logging and benchmarking.

    -l LEVEL, --loglevel=LEVEL
                    set log level (0:Debug, 1:Info, 2:Warn, 4:Error,
                    5:Critical), default is Debug (0).
    --prof              Log profiling info at program exit.

  Parameter sweep options:
    These options have only an effect when the simulation script uses a
    Controller object to sweep through a parameter range.

    -p RANGE, --param-range=RANGE
                    select parameter set to run, e.g. --param-range=0,64
                    to run sets 0 to 63.
    --print-num-params  print number of sweep parameters to stdout and exit.
    --print-all-params  print all sweep parameters to stdout and exit.

  Miscellanous options:
    --on_io_error=MODE  Specifies what to do when an i/o error occurs when
                    writing an .omf/.vtk file. 0: Abort (default), 1:
                    Retry a few times, then abort, 2: Retry a few times,
                    then pause and ask for user intervention

Now I want to write a small script that takes its own command line arguments and then uses the magnum module to perform some small calculation. I would like to use argparse to parse the arguments. However, argparse seems to have a lower priority than the argument processing of this external module and my own arguments fail to be recognized:

script2.py

#!/usr/bin/env python
import argparse
import magnum
parser = argparse.ArgumentParser(
        description='TEST')
parser.add_argument('--x',
        help='test_arg')
args = parser.parse_args()
print args.x

Calling it:

>>>./scrip2.py --x 3
[WARNING] - Python Imaging Library not found!
[WARNING] - -> This means that the ImageShapeCreator and related classes are not available!
[   INFO] - Imported FFTW wisdom from file
Usage: test.py [options]

test.py: error: no such option: --x

It does not matter if I import argparse before or after magnum. The argparse works if I don'f import magnum:

script3.py

#!/usr/bin/env python
import argparse
parser = argparse.ArgumentParser(
        description='TEST')
parser.add_argument('--x',
        help='test_arg')
args = parser.parse_args()
print args.x

Executing it yields:

>>>./scrip2.py --x 3
3

My question is: How can I stop magnum from processing my command line arguments, without editing magnum?

I don't think you can, frankly. It seems poorly architected if it tries to parse arguments on import. — jonrsharpe
– jonrsharpe, Commented Oct 22, 2015 at 15:22
argparse does nothing on import, as it should, that's why the order doesn't matter. import magnum after using argparse (parse_args) and set sys.argv to [] or whatever magnum needs — user3850
– user3850, Commented Oct 22, 2015 at 15:49
It doesn't look like magnum is meant to be imported. Is it perhaps a script frontend to an importable module? — hpaulj
– hpaulj, Commented Oct 22, 2015 at 16:17
No, it is really meant to be imported. At least all their documentation and examples say so. — Felix
– Felix, Commented Oct 22, 2015 at 17:08
micromagnum.informatik.uni-hamburg.de/pydoc2/cmdargs.html says: Any script that loads MicroMagnum using the ‘import magnum’ command is subject to these command line arguments:. So this import is meant to setup a computing environment. — hpaulj
– hpaulj, Commented Oct 22, 2015 at 17:34

opticaliqlusion · Accepted Answer · 2015-10-22 15:43:43Z

2

While I don't think there are any 'good' solutions, you can monkeypatch argparse to make it nop:

class EmptyParser():
    def parse_args():
        return
    ... (more redirects for add_argument)
argparse.ArgumentParser = EmptyParser
import magnum

Alternatively, you can wrap importing magnum in a function and create an interface to it through that function and creating arguments before magnum parses them.

def magnum(param1, param2):
    sys.argv = [param1, '--x', param2]
    import magnum

Both approaches are super hacky, though.

answered Oct 22, 2015 at 15:43

opticaliqlusion

3372 silver badges13 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

user3850 Over a year ago

magnum may not use argparse (and judging by the error message, it doesn't)

Felix Over a year ago

Sorry, wrong comment before. Importing magnum after changing sys.argv works.

Felix · Accepted Answer · 2015-10-22 17:12:43Z

For future reference, here the working solution based on the comments / answers above:

script3.py

#!/usr/bin/env python
import argparse
import sys
parser = argparse.ArgumentParser(
    description='TEST')
parser.add_argument('--x',
    help='test_arg')
args = parser.parse_args()
sys.argv = [sys.argv[0]]
import magnum
print args.x

Executing the script indicates that magnum is imported correctly but also that the arguments have been parsed and stored in the args variable:

>>>./script3.py --x 3
[WARNING] - Python Imaging Library not found!
[WARNING] - -> This means that the ImageShapeCreator and related classes are not available!
[   INFO] - Imported FFTW wisdom from file
[   INFO] - ----------------------------------------------------------------------
[   INFO] - MicroMagnum 0.2rc3
[   INFO] - Copyright (C) 2012 by the MicroMagnum team.
[   INFO] - This program comes with ABSOLUTELY NO WARRANTY.
[   INFO] - This is free software, and you are welcome to redistribute it under
[   INFO] - certain conditions; see the file COPYING in the distribution package.
[   INFO] - ----------------------------------------------------------------------
[   INFO] - FFTW using 1 threads from now on
[   INFO] - CUDA GPU support: no
3

This solution will not forward any arguments to magnum, which is what I wanted to achieve.

hpaulj · Accepted Answer · 2015-10-22 17:56:02Z

1

Looking at the github source, https://github.com/MicroMagnum

import magnum

imports a package (magnum/__init__.py). And the key action in the init is

config.cfg.initialize(sys.argv)

That defines and creates a cfg = MagnumConfig(). That checks the environment. It also defines and runs an optparse parser.

So there's no obvious way of bypassing its parser and still setup the computing environment. Doing your own parsing and tweaking sys.argv before import magnum appears to be the only solution.

answered Oct 22, 2015 at 17:56

hpaulj

233k14 gold badges260 silver badges392 bronze badges

Collectives™ on Stack Overflow

python: stop imported module from parsing command line arguments

3 Answers 3

2 Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

2 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related