When we build our cli script, at same point we need to provide some arguments or parameters to the script. The main reason is to avoid having to hardcode certain values in the script. Take for example a script that deleting a bunch of directories, you might want to run as:-
./delete-dirs.sh dir1 dir2 dir3 ...
This will make the script usable to delete any directories. If you hardcode the directories to delete in the script, then when you need to delete a new set of directories, you have to edit the script first before running it.
In above example, the set of directories you want to delete might be finite, let say 3 directories only. Typically the arguments to script will be passed as list of values, where first argument can be accessed as
$1, second argument as
$2 and so on. If you need arbitrary arguments, bash provide the
$@ variable. This still look simple, but what if other than this arbitrary arguments, you also want to allow the script to accept some optional flag ? For example:-
./delete-dirs.sh --confirm dir2 dir2 dir3 ...
So for each of the arguments, you need to check first if the argument was prefixed with a
-- character and treat it differently. At this point, you realize that you have start to write a command line parser !
On most unix like environment, like Linux, there's a little command called
getopts. There's also similar command which exists earlier called
getopt (notice what is the difference ?), but you should just assume there's
getopts and forget that
getopt ever existed. While better than
getopt, parsing cli arguments with
getopts still not a fun exercise. Example of
getopts is like below:-
while getopts "h?vf:" opt; do case "$opt" in h|\?) show_help exit 0 ;; v) verbose=1 ;; f) output_file=$OPTARG ;; esac done
More on Stackoverflow.
At this point, we know that parsing command line arguments using traditional tool like
getopts is not fun at all. And as I don't write much shell script these days, I prefer to start looking into how parsing command line in Python look like. It turn out that Python also has a module named getopt. It look slightly easier than the unix tools, you can try it if you want.
getopt module, Python also has a module called
optparse. Parsing command line arguments with
optparse look like this (taken from the docs):-
from optparse import OptionParser [...] parser = OptionParser() parser.add_option("-f", "--file", dest="filename", help="write report to FILE", metavar="FILE") parser.add_option("-q", "--quiet", action="store_false", dest="verbose", default=True, help="don't print status messages to stdout") (options, args) = parser.parse_args()
The file optional argument then can be accessed as
options.file, and the
-q parameter can be accessed as
options.quiet, which would default to
False. It way much better now. But
optparse was deprecated since Python 3.2, so it's not a viable alternative anymore. In python 3, a new module was introduced called
argparse. There's some debates on
argparse but I don't want to get into that.
What more interesting here is that we might has come to realization, that to write a cli program in much saner way, we need more high level tools than just
argparse. This is where cli framework came into picture. Imagine if we can have a python program like this:-
def do_something(param1, param2, flag=False): pass if __name__ == '__main__': make_command(do_something)
And then automagically, we can have a cli like this:-
./myprogram param1 param2 ./myprogram param1 param2 --flag ./myprogram --help Usage: <myprogram> [options] Options: -h, --help show this help message and exit -f FLAG, --flag=Boolean Default to False
And if we have more than one functions in the script, like:-
def do_something(param1, param2, flag=False): pass def do_another_thing(param1): pass if __name__ == '__main__': make_command(do_something, do_another_thing)
And have a program like:-
./myprogram do_something param1 param2 --flag ./myprogram do_another_thing param1
That would be great, right ?
So the tools that I'm using most of the time is a package called Baker, you can get it from PyPI. It might not be the best but at that time when I'm looking for this kind of tools (7 years ago), it seem the most suitable for what I need. If starting again at present day, I might choose click.
Google also has similar tools called Fire. I used it for a while as it seem to be more powerful than Baker and also solve some issue I have with Baker. But then I realized it just doing too much. For example it automatically print out the return value from your command, and no option to disable it.
There are more tools available in Python and I think you can find some more I didn't mention here by just googling "python cli tools". Hopefully now you understand the need of these tools when writing your python script.