Beautiful CLIs With The Rich Python Library

I write content for AWS, Kubernetes, Python, JavaScript and more. To view all the latest content, be sure to visit my blog and subscribe to my newsletter. Follow me on Twitter.

This is Day 13 of the #100DaysOfPython challenge.

This post will use the rich library to demonstrate how to add some color and formatting to your Python CLI output.

Prerequisites

1. Familiarity with Pipenv. See here for my post on Pipenv.
2. Read Pretty errors in Python for my post on how to make pretty error output in Python.
3. Read CLI Prompts in Python for my post on how to make CLI prompts in Python.
4. Read Building CLIs with python-fire for my intro on building CLIs with python-fire that will be used today.
5. Familiarity with how Python Fire works.

This works from the content of a previous post on Pretty errors in Python.

While not necessary to understand the post, it is recommended that you read it if you are hoping to use the same code.

Getting started

At this stage of the series, our code in cli.py for the project folder should look like the following:

#!/usr/bin/env python
import fire
from PyInquirer import prompt
import pretty_errors


class IngestionStage(object):
    def run(self):
        return 'Ingesting! Nom nom nom...'


class DigestionStage(object):
    def __init__(self):
        self.satiated = False

    def run(self, volume: int) -> str:
        questions = [
            {
                'type': 'input',
                'name': 'volume',
                'message': 'How many burps?',
            }
        ]
        if volume == 0:
            volume = int(prompt(questions)['volume'])
        self.satiated = True
        return ' '.join(['Burp!'] * volume)

    def breakfast(self):
        questions = [
            {
                'type': 'list',
                'name': 'breakfast',
                'message': 'What did you want for breakfast?',
                'choices': ['eggs', 'bacon', 'toast']
            }
        ]
        switcher = {
            'eggs': 1,
            'bacon': 2,
            'toast': 3,
        }
        volume = switcher.get(prompt(questions)['breakfast'], 0)

        self.satiated = True
        return ' '.join(['Burp!'] * volume)

    def status(self):
        return 'Satiated.' if self.satiated else 'Not satiated.'


class Pipeline(object):

    def __init__(self):
        self.ingestion = IngestionStage()
        self.digestion = DigestionStage()

    def run(self, volume: int = 1):
        print(self.ingestion.run())
        print(self.digestion.run(volume=volume))
        print(self.digestion.status())
        return 'Pipeline complete'


if __name__ == '__main__':
    fire.Fire(Pipeline)

In today's post, we are hoping to just to show a demo of how easy it is to use rich to add some color to our output.

We can add the rich library to our current Pipenv environment by running the following command:

# Add rich to dependencies
$ pipenv install rich

We are now ready to update our input.

Adding color to our output

We will demo how rich works with simple example of adding color to the DigestionStage class method status.

Currently, the method looks like so:

def status(self):
        return 'Satiated.' if self.satiated else 'Not satiated.'

Currently, if we run our the following commands in the terminal, we get output without color:

$ python cli.py run --volume 2
Ingesting! Nom nom nom...
Burp! Burp!
Satiated.
Pipeline complete
$ python cli.py digestion status
Not satiated.

What we would like to do is to add some color to the output but updating the function to use the print function from the rich library and update what we return at the end.

We can do this with the following:

# Top of the file
from rich import print

# ... code omitted for brevity

# Back at the `status` definition.
def status(self):
        print('[bold green]Satiated.[/bold green]') if self.satiated else print(
                '[bold red]Not satiated.[/bold red]')
        return 'Status complete'

Re-running the above commands will adjust the output slightly, but now self.satiated output printed in bold green when true and self.satiated output is printed in red when false.

$ python cli.py run
Ingesting! Nom nom nom...
Burp!
Satiated.
Status complete
Pipeline complete
$ python cli.py digestion status
Not satiated.
Status complete

Summary

Today's post demonstrated how to use the rich package to add some color to our output.

Resources and further reading

1. The ABCs of Pipenv
2. Pipenv
3. Pretty errors in Python
4. CLI Prompts in Python
5. Building CLIs with python-fire
6. Python Fire
7. rich

Photo credit: pawel_czerwinski

Originally posted on my blog. To see new posts without delay, read the posts there and subscribe to my newsletter.