alive-progress

Install the package using the standard Python package manager:

pip install alive-progress

To include longer messages without shrinking the progress bar or removing widgets, enable dual_line=True. This places a message area below the progress bar, allowing standard print() or logging messages to scroll above it while the bar remains stable at the bottom.

letters = [chr(ord('A') + x) for x in range(26)]
with alive_bar(26, dual_line=True, title='Alphabet') as bar:
    for c in letters:
        bar.text = f'-> Teaching the letter: {c}, please wait...'
        if c in 'HKWZ':
            print(f'fail "{c}", retry later')
        time.sleep(0.3)
        bar()

If you are processing large datasets in batches or from a cache and need to skip items that are already completed, you can inform alive_bar to prevent the ETA from being ruined.

There are two ways to do this:

1. If you know the exact number of skipped items: Call bar(N, skipped=True) once with the count of skipped items before starting your loop.
2. If items are scattered: Call bar(skipped=True) whenever you encounter an item that is already done.

# Option 1: Known number of skipped items
with alive_bar(120000) as bar:
    bar(60000, skipped=True)
    for i in range(60000, 120000):
        # process item
        bar()

# Option 2: Scattered skipped items
with alive_bar(120000) as bar:
    for i in range(120000):
        if done(i):
            bar(skipped=True)
            continue

        # process item
        bar()

If you are monitoring a fixed sequence of steps rather than a loop, use manual=True in alive_bar. This prevents the progress bar from jumping erratically if steps take different amounts of time.

Instead of calling bar() without arguments, call bar(percentage) where percentage is the cumulative progress (e.g., 0.1 for 10%, 0.4 for 40%). The final call should always be bar(1.) to indicate 100% completion.

You can assemble custom spinners by using various factory types. These factories are passed to alive_bar or config_handler. The available factory types are:

• frames: Plays a sequence of characters frame by frame.
• scrolling: Generates a smooth flow of characters from one side to the other, wrapping or hiding at borders.
• bouncing: Similar to scrolling, but the animation bounces back to the start.
• sequential: Plays multiple factories one after another in sequence.
• alongside: Plays multiple factories simultaneously (allows choosing an animation pivot).
• delayed: Takes another factory and creates multiple copies, increasingly skipping frames to create a trailing effect.

By default, ctrl_c=True is set, which allows CTRL+C to work as usual. If you want to prevent CTRL+C from raising a stack trace (making it smoother for interactive use or top-level programs), set ctrl_c=False.

Warning: If used inside a loop, CTRL+C will simply move to the next iteration of that loop.

for i in range(10):
    with alive_bar(100, ctrl_c=False, title=f'Download {i}') as bar:
        for i in range(100):
            time.sleep(0.02)
            bar()

The alive_bar context manager is the primary way to wrap a loop and manually control progress. You declare the expected total when entering the context, and call bar() at the end of each iteration to advance the bar.

Key features:

• Automatic Hooking: Standard Python print(), logging, and click.echo() are automatically hooked to display messages integrated with the progress bar without breaking the animation.
• Deviation Detection: If you call bar() more or less frequently than expected based on the total, the bar will visually indicate the overflow or underflow.
• Independence: The bar is independent of the loop; you can call bar() multiple times per iteration or use it to monitor unrelated background tasks.