$ pip install enlighten

import time
import enlighten
pbar = enlighten.Counter(total=100, desc='Basic', unit='ticks')
for num in range(100):


    time.sleep(0.1)  # Simulate work


    pbar.update()

import time
import enlighten
manager = enlighten.get_manager()
ticks = manager.counter(total=100, desc='Ticks', unit='ticks')
tocks = manager.counter(total=20, desc='Tocks', unit='tocks')
for num in range(100):


    time.sleep(0.1)  # Simulate work


    print(num)


    ticks.update()


    if not num % 5:


        tocks.update()
manager.stop()

import time
import enlighten
counter = enlighten.Counter(desc='Basic', unit='ticks')
for num in range(100):


    time.sleep(0.1)  # Simulate work


    counter.update()

import enlighten
import time
manager = enlighten.get_manager()
status_bar = manager.status_bar('Static Message',


                                color='white_on_red',


                                justify=enlighten.Justify.CENTER)
time.sleep(1)
status_bar.update('Updated static message')
time.sleep(1)

import enlighten
import time
manager = enlighten.get_manager()
status_format = '{program}{fill}Stage: {stage}{fill} Status {status}'
status_bar = manager.status_bar(status_format=status_format,


                                color='bold_slategray',


                                program='Demo',


                                stage='Loading',


                                status='OKAY')
time.sleep(1)
status_bar.update(stage='Initializing', status='OKAY')
time.sleep(1)
status_bar.update(status='FAIL')

import time
import enlighten
counter = enlighten.Counter(total=100, desc='Colorized', unit='ticks', color='red')
for num in range(100):


    time.sleep(0.1)  # Simulate work
counter.update()

import enlighten
manager = enlighten.get_manager()
# Standard bar format
std_bar_format = u'{desc}{desc_pad}{percentage:3.0f}%|{bar}| ' + \


                 u'{count:{len_total}d}/{total:d} ' + \


                 u'[{elapsed}<{eta}, {rate:.2f}{unit_pad}{unit}/s]'
# Red text
bar_format = manager.term.red(std_bar_format)
# Red on white background
bar_format = manager.term.red_on_white(std_bar_format)
# X11 colors
bar_format = manager.term.peru_on_seagreen(std_bar_format)
# RBG text
bar_format = manager.term.color_rgb(2, 5, 128)(std_bar_format)
# RBG background
bar_format = manager.term.on_color_rgb(255, 190, 195)(std_bar_format)
# RGB text and background
bar_format = manager.term.on_color_rgb(255, 190, 195)(std_bar_format)
bar_format = manager.term.color_rgb(2, 5, 128)(bar_format)
# Apply color to select parts
bar_format = manager.term.red(u'{desc}') + u'{desc_pad}' + \


             manager.term.blue(u'{percentage:3.0f}%') + u'|{bar}|'
# Apply to counter
ticks = manager.counter(total=100, desc='Ticks', unit='ticks', bar_format=bar_format)

import random
import time
import enlighten
bar_format = u'{desc}{desc_pad}{percentage:3.0f}%|{bar}| ' + \


            u'S:{count_0:{len_total}d} ' + \


            u'F:{count_2:{len_total}d} ' + \


            u'E:{count_1:{len_total}d} ' + \


            u'[{elapsed}<{eta}, {rate:.2f}{unit_pad}{unit}/s]'
success = enlighten.Counter(total=100, desc='Testing', unit='tests',


                            color='green', bar_format=bar_format)
errors = success.add_subcounter('white')
failures = success.add_subcounter('red')
while success.count < 100:


    time.sleep(random.uniform(0.1, 0.3))  # Random processing time


    result = random.randint(0, 10)


    if result == 7:


        errors.update()


    if result in (5, 6):


        failures.update()


    else:


        success.update()

import random
import time
import enlighten
services = 100
bar_format = u'{desc}{desc_pad}{percentage_2:3.0f}%|{bar}|' + \


            u' {count_2:{len_total}d}/{total:d} ' + \


            u'[{elapsed}<{eta_2}, {rate_2:.2f}{unit_pad}{unit}/s]'
initializing = enlighten.Counter(total=services, desc='Starting', unit='services',


                                color='red', bar_format=bar_format)
starting = initializing.add_subcounter('yellow')
started = initializing.add_subcounter('green', all_fields=True)
while started.count < services:


    remaining = services - initializing.count


    if remaining:


        num = random.randint(0, min(4, remaining))


        initializing.update(num)


    ready = initializing.count - initializing.subcount


    if ready:


        num = random.randint(0, min(3, ready))


        starting.update_from(initializing, num)


    if starting.count:


        num = random.randint(0, min(2, starting.count))


        started.update_from(starting, num)


    time.sleep(random.uniform(0.1, 0.5))  # Random processing time

import sys
import enlighten
# Example configuration object
config = {'stream': sys.stdout,


          'useCounter': False}
enableCounter = config['useCounter'] and stream.isatty()
manager = enlighten.Manager(stream=config['stream'], enabled=enableCounter)

import enlighten
# Example configuration object
config = {'stream': None,  # Defaults to sys.stdout


          'useCounter': False}
manager = enlighten.get_manager(stream=config['stream'], enabled=config['useCounter'])

import enlighten
SPLINES = 100
with enlighten.Manager() as manager:


    with manager.counter(total=SPLINES, desc='Reticulating:', unit='splines') as retic:


        for num in range(SPLINES + 1):


            retic.update()

import time
import enlighten
flock1 = ['Harry', 'Sally', 'Randy', 'Mandy', 'Danny', 'Joe']
flock2 = ['Punchy', 'Kicky', 'Spotty', 'Touchy', 'Brenda']
total = len(flock1) + len(flock2)
manager = enlighten.Manager()
pbar = manager.counter(total=total, desc='Counting Sheep', unit='sheep')
for sheep in pbar(flock1, flock2):


    time.sleep(0.2)


    print('%s: Baaa' % sheep)

import enlighten
import random
import time
bar_format = u'{desc}{desc_pad}{source} {percentage:3.0f}%|{bar}| ' + \


             u'{count:{len_total}d}/{total:d} ' + \


             u'[{elapsed}<{eta}, {rate:.2f}{unit_pad}{unit}/s]'
manager = enlighten.get_manager(bar_format=bar_format)
bar = manager.counter(total=100, desc='Loading', unit='files', source='server.a')
for num in range(100):


    time.sleep(0.1)  # Simulate work


    if not num % 5:


        bar.update(source=random.choice(['server.a', 'server.b', 'server.c']))


    else:


        bar.update()

Parameters

counter(position=None, **kwargs)

Get a new progress bar instance

If position is specified, the counter's position will be pinned. A ValueError will be raised if position exceeds the screen height or has already been pinned by another counter.

If autorefresh is True, this bar will be redrawn whenever another bar is drawn assuming it had been min_delta seconds since the last update. This is usually unnecessary.

NOTE:

status_bar(*args, **kwargs)

Get a new status bar instance

If position is specified, the counter's position can change dynamically if additional counters are called without a position argument.

If autorefresh is True, this bar will be redrawn whenever another bar is drawn assuming it had been min_delta seconds since the last update. Generally, only need when elapsed is used in status_format.

stop()

Clean up and reset terminal

This method should be called when the manager and counters will no longer be needed.

Any progress bars that have leave set to True or have not been closed will remain on the console. All others will be cleared.

Manager and all counters will be disabled.

Parameters

add_subcounter(color, count=0, all_fields=False)

Add a subcounter for multicolored progress bars

clear(flush=True)

Clear bar

close(clear=False)

Do final refresh and remove from manager

If leave is True, the default, the effect is the same as refresh().

property color

Color property

Preferred to be a string or iterable of three integers for RGB. Single integer supported for backwards compatibility

property fill

Fill character used in formatting

format(width=None, elapsed=None)

Format progress bar or counter

refresh(flush=True, elapsed=None)

Redraw bar

property subcount

Sum of counts from all subcounters

update(incr=1, force=False, **fields)

Increment progress bar and redraw

Progress bar is only redrawn if min_delta seconds past since the last update

Parameters

clear(flush=True)

Clear bar

close(clear=False)

Do final refresh and remove from manager

If leave is True, the default, the effect is the same as refresh().

property color

Color property

Preferred to be a string or iterable of three integers for RGB. Single integer supported for backwards compatibility

property fill

Fill character used in formatting

format(width=None, elapsed=None)

Format status bar

property justify

Maps to justify method determined by justify parameter

refresh(flush=True, elapsed=None)

Redraw bar

update(*objects, **fields)

Update status and redraw

Status bar is only redrawn if min_delta seconds past since the last update

update(incr=1, force=False)

Increment progress bar and redraw

Both this counter and the parent are incremented.

Progress bar is only redrawn if min_delta seconds past since the last update on the parent.

update_from(source, incr=1, force=False)

Move a value to this counter from another counter.

source must be the parent Counter instance or a SubCounter with the same parent

Parameters

Returns

Manager instance

Return type

Manager

CENTER

Justify center

LEFT

Justify left

RIGHT

Justify right