Question

I need to write a command line application, like a shell. So it will include commands etc. The thing is I don’t know how to pass parameters to the funcions in a module. For example:

User writes: function1 folder1
Program should now pass the ‘folder1’ parameter to the function1 function, and run it. But also it has to support other functions with different parameters ex:

User input: function2 folder2 –exampleparam

How to make this to work? I mean, I could just write a module, import it in python and just use the python console, but this is not the case. I need a script that takes command input and runs it.

I tried to use eval(), but that doesn’t solve the problem with params. Or maybe it does but I don’t see it?

Answer 1

The first part of your problem — parsing the command line — can be solved with argparse.

The second part — converting the string name of a function into a function call — can be done with exec or a dispatching dict which maps from strings to function objects.

I would recommend NOT using exec for this, since
allowing a user to call arbitrary Python functions from the command line might be dangerous. Instead, make a whitelist of allowable functions:

import argparse


def foo(path):
    print('Running foo(%r)' % (path, ))


def bar(path):
    print('Running bar(%r)' % (path, ))

dispatch = {
    'foo': foo,
    'bar': bar,
}

parser = argparse.ArgumentParser()
parser.add_argument('function')
parser.add_argument('arguments', nargs='*')
args = parser.parse_args()

dispatch[args.function](*args.arguments)

---

% test.py foo 1
Running foo('1')
% test.py bar 2
Running bar('2')
% test.py baz 3
KeyError: 'baz'

---

The above works when the command is typed into the command-line itself. If the command is being typed into stdin, then we’ll need to do something a bit different.

A simple way would be to call raw_input to grab the string from stdin. We could then parse the string with argparse, as we did above:

shmod.py:

import argparse


def foo(path):
    print('Running foo(%r)' % (path, ))


def bar(path):
    print('Running bar(%r)' % (path, ))

dispatch = {
    'foo': foo,
    'bar': bar,
}

def parse_args(cmd):
    parser = argparse.ArgumentParser()
    parser.add_argument('function')
    parser.add_argument('arguments', nargs='*')
    args = parser.parse_args(cmd.split())
    return args

main.py:

import shmod

while True:
    cmd = raw_input('> ')
    args = shmod.parse_args(cmd)
    try:
        shmod.dispatch[args.function](*args.arguments)
    except KeyError:
        print('Invalid input: {!r}'.format(cmd))

---

Another, more sophisticated way to handle this is to use the cmd module, as @chepner mentioned in the comments.

from cmd import Cmd


class MyInterpreter(Cmd):

    prompt = '> '

    def do_prompt(self, line):
        "Change the interactive prompt"
        self.prompt = line + ': '

    def do_EOF(self, line):
        return True

    def do_foo(self, line):
        print('Running foo {l}'.format(l=line))

    def do_bar(self, line):
        print('Running bar {l}'.format(l=line))

if __name__ == '__main__':
    MyInterpreter().cmdloop()

For more information on how to use the cmd module, see Doug Hellman’s excellent tutorial.

---

Running the code above yields a result like this:

% test.py
> foo 1
Running foo 1
> foo 1 2 3
Running foo 1 2 3
> bar 2
Running bar 2
> baz 3
*** Unknown syntax: baz 3