What's the best way to parse command line arguments?

python

prompt-engineering

argparse

cli

byNikita Barsukov·Dec 1, 2024

For command-line argument parsing in Python, the standard library offers the argparse module. It enables creation of user-friendly command-line interfaces (CLI). Here is a compact yet functional example:

import argparse

# initializing the parser (Like waking up a grumpy wizard 🧙‍♂️)
parser = argparse.ArgumentParser(description='Process some integers.')

# defining positional argument 'integers' (Sending the wizard on a quest 🏹)
parser.add_argument('integers', metavar='N', type=int, nargs='+',
                    help='an integer for the accumulator')

# defining optional flag `--sum` (Turning the grumpy wizard into a mathematician 🧮)
parser.add_argument('--sum', dest='accumulate', action='store_const',
                    const=sum, default=max,
                    help='sum the integers (default: find the max)')

# parsing the arguments (Getting the quest results 🎁)
args = parser.parse_args()

# displaying the results (Enjoying the spoils 🎉)
print(args.accumulate(args.integers))

This code illustrates defining a positional argument integers and an optional flag --sum that alters the script's function.

Delving Deeper with argparse

argparse equips you to architect elaborate CLI applications. It offers subparsers for sub-commands, custom types and actions for sophisticated parsing, and argument groups for logical argument organization.

Establishing Nested Sub-commands

Create sub-commands using add_subparsers(), fashioning your CLI into a multi-tier command tree:

# Adding gremlin of subparsers ⚙️
subparsers = parser.add_subparsers(help='sub-command help')

# Defining a subparser for a "start" command
start_parser = subparsers.add_parser('start', help='Starts the server')
# Now the wizard have a gremlin helper, yay! 🎉
start_parser.add_argument('port', type=int, help='Port to listen on')

Crafting Custom Types and Actions

Formulate custom types for validation and custom actions for code execution during argument parsing:

# The wizard has learned a new spell. Date validation! 📘⏰
def valid_date(s):
    try:
        return datetime.strptime(s, "%Y-%m-%d")
    except ValueError:
        msg = "Not a valid date: '{0}'.".format(s)
        raise argparse.ArgumentTypeError(msg)

# cast the spell on the start date argument
parser.add_argument('--start-date', type=valid_date)

Grouping Arguments Logically

Use add_argument_group() to group connected arguments, enhancing the visual organization and understandability:

# A group of advanced arguments that only select wizards can use 🧙‍♀️🧙‍♂️🔮
advanced_group = parser.add_argument_group('Advanced arguments')
advanced_group.add_argument('--timeout', type=int, help='Operation timeout')

Creating Minimalist and Elegant CLI with Click and python-fire

Go Minimal with Click

Click employs decorator-based syntax, reducing boilerplate and pleasing those who favor brevity:

import click

@click.command()
@click.option('--count', default=1, help='Number of greetings')
# 🤝 Let's be hospitable and greet properly
@click.argument('name')
def hello(count, name):
    for _ in range(count):
        click.echo(f'Hello {name}!')

# In case you didn't notice, we just made the wizard social! 👥👋
if __name__ == '__main__':
    hello()

Hassle-Free with python-fire

Python-fire distinguishes itself with its ability to convert any Python object into a CLI spontaneously:

import fire

class Calculator(object):
  """A simple calculator class."""

  def add(self, x, y):
      return x + y
# An ordinary, harmless calculator... Or is it? 😉
if __name__ == '__main__':
    fire.Fire(Calculator)

Harnessing docopt and Click for Simplified, Attractive CLIs

Simplify Your CLI with docopt

With docopt, your help message is your CLI's definition. It's user-friendly and intuitive:

"""Usage: myprogram.py [-hso OPTIONS] <input-file>

-h --help    show this help message
-s --sorted  sorted output
-o OPTIONS   specify options
"""
from docopt import docopt
# The wizard just read a magic scroll and now we have a CLI. Magic! ✨📜
arguments = docopt(__doc__)

Prettying Up Help Pages with Click

Click gracefully handles help pages, formatting them without redundant effort:

@click.command()
@click.option('--username', prompt='Your username',
              help='The person to greet.')
# And who said wizards aren't polite? 🎩👋
def greet(username):
    click.echo(f'Hello {username}!')

# Look Ma! The wizard just said hello! 👏
if __name__ == '__main__':
    greet()

Building Robust and Scalable CLIs with Cement

Advanced CLI Applications with Cement:

Cement is an advanced CLI application framework for Python. It's perfect for developers who adore structure and design patterns:

from cement import App

class MyApp(App):
    class Meta:
        label = 'myapp'

# Well look at that! The wizard just got a new house 🧙‍♂️🏠
with MyApp() as app:
    app.run()