progressbar.py

Go to the documentation of this file.

import os
import sys
import time
import math
 
 
 
 
try:
    from abc import ABCMeta, abstractmethod
except ImportError:
    AbstractWidget = object
    abstractmethod = lambda fn: fn
else:
    AbstractWidget = ABCMeta('AbstractWidget', (object,), {})
class UnknownLength: pass
class Widget(AbstractWidget):
    '''The base class for all widgets
 
    The ProgressBar will call the widget's update value when the widget should
    be updated. The widget's size may change between calls, but the widget may
    display incorrectly if the size changes drastically and repeatedly.
 
    The boolean TIME_SENSITIVE informs the ProgressBar that it should be
    updated more often because it is time sensitive.
    '''
 
    TIME_SENSITIVE = False
    __slots__ = ()
 
    @abstractmethod
    def update(self, pbar):
        '''Updates the widget.
 
        pbar - a reference to the calling ProgressBar
        '''
class Timer(Widget):
    'Widget which displays the elapsed seconds.'
 
    __slots__ = ('format',)
    TIME_SENSITIVE = True
 
    def __init__(self, format='Elapsed Time: %s'):
        self.format = format
 
    @staticmethod
    def format_time(seconds):
        'Formats time as the string "HH:MM:SS".'
 
        return str(datetime.timedelta(seconds=int(seconds)))
 
 
    def update(self, pbar):
        'Updates the widget to show the elapsed time.'
 
        return self.format % self.format_time(pbar.seconds_elapsed)
class WidgetHFill(Widget):
    '''The base class for all variable width widgets.
 
    This widget is much like the \\hfill command in TeX, it will expand to
    fill the line. You can use more than one in the same line, and they will
    all have the same width, and together will fill the line.
    '''
 
    @abstractmethod
    def update(self, pbar, width):
        '''Updates the widget providing the total width the widget must fill.
 
        pbar - a reference to the calling ProgressBar
        width - The total width the widget must fill
        '''
class Bar(WidgetHFill):
    'A progress bar which stretches to fill the line.'
 
    __slots__ = ('marker', 'left', 'right', 'fill', 'fill_left')
 
    def __init__(self, marker='#', left='|', right='|', fill=' ',
                 fill_left=True):
        '''Creates a customizable progress bar.
 
        marker - string or updatable object to use as a marker
        left - string or updatable object to use as a left border
        right - string or updatable object to use as a right border
        fill - character to use for the empty part of the progress bar
        fill_left - whether to fill from the left or the right
        '''
        self.marker = marker
        self.left = left
        self.right = right
        self.fill = fill
        self.fill_left = fill_left
 
 
    def update(self, pbar, width):
        'Updates the progress bar and its subcomponents'
 
        left, marked, right = (format_updatable(i, pbar) for i in
            (self.left, self.marker, self.right))
 
        width -= len(left) + len(right)
        # Marked must *always* have length of 1
        if pbar.maxval:
            marked *= int(pbar.currval / pbar.maxval * width)
        else:
            marked = ''
 
        if self.fill_left:
            return '%s%s%s' % (left, marked.ljust(width, self.fill), right)
        else:
            return '%s%s%s' % (left, marked.rjust(width, self.fill), right)
class BouncingBar(Bar):
    def update(self, pbar, width):
        'Updates the progress bar and its subcomponents'
 
        left, marker, right = (format_updatable(i, pbar) for i in
            (self.left, self.marker, self.right))
 
        width -= len(left) + len(right)
 
        if pbar.finished: return '%s%s%s' % (left, width * marker, right)
 
        position = int(pbar.currval % (width * 2 - 1))
        if position > width: position = width * 2 - position
        lpad = self.fill * (position - 1)
        rpad = self.fill * (width - len(marker) - len(lpad))
 
        # Swap if we want to bounce the other way
        if not self.fill_left: rpad, lpad = lpad, rpad
 
        return '%s%s%s%s%s' % (left, lpad, marker, rpad, right)
 
class FormatLabel(Timer):
    'Displays a formatted label'
 
    mapping = {
        'elapsed': ('seconds_elapsed', Timer.format_time),
        'finished': ('finished', None),
        'last_update': ('last_update_time', None),
        'max': ('maxval', None),
        'seconds': ('seconds_elapsed', None),
        'start': ('start_time', None),
        'value': ('currval', None)
    }
 
    __slots__ = ('format',)
    def __init__(self, format):
        self.format = format
 
    def update(self, pbar):
        context = {}
        for name, (key, transform) in self.mapping.items():
            try:
                value = getattr(pbar, key)
 
                if transform is None:
                    context[name] = value
                else:
                    context[name] = transform(value)
            except: pass
 
        return self.format % context
 
class ProgressBar(object):
    '''The ProgressBar class which updates and prints the bar.
 
    A common way of using it is like:
    >>> pbar = ProgressBar().start()
    >>> for i in range(100):
    ...    # do something
    ...    pbar.update(i+1)
    ...
    >>> pbar.finish()
 
    You can also use a ProgressBar as an iterator:
    >>> progress = ProgressBar()
    >>> for i in progress(some_iterable):
    ...    # do something
    ...
 
    Since the progress bar is incredibly customizable you can specify
    different widgets of any type in any order. You can even write your own
    widgets! However, since there are already a good number of widgets you
    should probably play around with them before moving on to create your own
    widgets.
 
    The term_width parameter represents the current terminal width. If the
    parameter is set to an integer then the progress bar will use that,
    otherwise it will attempt to determine the terminal width falling back to
    80 columns if the width cannot be determined.
 
    When implementing a widget's update method you are passed a reference to
    the current progress bar. As a result, you have access to the
    ProgressBar's methods and attributes. Although there is nothing preventing
    you from changing the ProgressBar you should treat it as read only.
 
    Useful methods and attributes include (Public API):
     - currval: current progress (0 <= currval <= maxval)
     - maxval: maximum (and final) value
     - finished: True if the bar has finished (reached 100%)
     - start_time: the time when start() method of ProgressBar was called
     - seconds_elapsed: seconds elapsed since start_time and last call to
                        update
     - percentage(): progress in percent [0..100]
    '''
 
    __slots__ = ('currval', 'fd', 'finished', 'last_update_time',
                 'left_justify', 'maxval', 'next_update', 'num_intervals',
                 'poll', 'seconds_elapsed', 'signal_set', 'start_time',
                 'term_width', 'update_interval', 'widgets', '_time_sensitive',
                 '__iterable')
 
    _DEFAULT_MAXVAL = 100
    _DEFAULT_TERMSIZE = 80
 
    def __init__(self, maxval=None, widgets=None, term_width=None, poll=1,
                 left_justify=True, fd=sys.stderr):
        '''Initializes a progress bar with sane defaults'''
 
        self.maxval = maxval
        self.widgets = widgets
        self.fd = fd
        self.left_justify = left_justify
 
        self.signal_set = False
        if term_width is not None:
            self.term_width = term_width
        else:
            try:
                self._handle_resize()
                signal.signal(signal.SIGWINCH, self._handle_resize)
                self.signal_set = True
            except (SystemExit, KeyboardInterrupt): raise
            except:
                self.term_width = self._env_size()
 
        self.__iterable = None
        self._update_widgets()
        self.currval = 0
        self.finished = False
        self.last_update_time = None
        self.poll = poll
        self.seconds_elapsed = 0
        self.start_time = None
        self.update_interval = 1
 
 
    def __call__(self, iterable):
        'Use a ProgressBar to iterate through an iterable'
 
        try:
            self.maxval = len(iterable)
        except:
            if self.maxval is None:
                self.maxval = UnknownLength
 
        self.__iterable = iter(iterable)
        return self
 
 
    def __iter__(self):
        return self
 
 
    def __next__(self):
        try:
            value = next(self.__iterable)
            if self.start_time is None: self.start()
            else: self.update(self.currval + 1)
            return value
        except StopIteration:
            self.finish()
            raise
 
 
    # Create an alias so that Python 2.x won't complain about not being
    # an iterator.
    next = __next__
 
 
    def _env_size(self):
        'Tries to find the term_width from the environment.'
 
        return int(os.environ.get('COLUMNS', self._DEFAULT_TERMSIZE)) - 1
 
 
    def _handle_resize(self, signum=None, frame=None):
        'Tries to catch resize signals sent from the terminal.'
 
        h, w = array('h', ioctl(self.fd, termios.TIOCGWINSZ, '\0' * 8))[:2]
        self.term_width = w
 
 
    def percentage(self):
        'Returns the progress as a percentage.'
        return self.currval * 100.0 / self.maxval
 
    percent = property(percentage)
 
 
    def _format_widgets(self):
        result = []
        expanding = []
        width = self.term_width
 
        for index, widget in enumerate(self.widgets):
            if isinstance(widget, WidgetHFill):
                result.append(widget)
                expanding.insert(0, index)
            else:
                widget = format_updatable(widget, self)
                result.append(widget)
                width -= len(widget)
 
        count = len(expanding)
        while count:
            portion = max(int(math.ceil(width * 1. / count)), 0)
            index = expanding.pop()
            count -= 1
 
            widget = result[index].update(self, portion)
            width -= len(widget)
            result[index] = widget
 
        return result
 
 
    def _format_line(self):
        'Joins the widgets and justifies the line'
 
        widgets = ''.join(self._format_widgets())
 
        if self.left_justify: return widgets.ljust(self.term_width)
        else: return widgets.rjust(self.term_width)
 
 
    def _need_update(self):
        'Returns whether the ProgressBar should redraw the line.'
        if self.currval >= self.next_update or self.finished: return True
 
        delta = time.time() - self.last_update_time
        return self._time_sensitive and delta > self.poll
 
 
    def _update_widgets(self):
        'Checks all widgets for the time sensitive bit'
 
        self._time_sensitive = any(getattr(w, 'TIME_SENSITIVE', False)
            for w in self.widgets)
 
 
    def update(self, value=None):
        'Updates the ProgressBar to a new value.'
 
        if value is not None and value is not UnknownLength:
            if (self.maxval is not UnknownLength
                and not 0 <= value <= self.maxval):
 
                raise ValueError('Value out of range')
 
            self.currval = value
 
 
        if not self._need_update(): return
        if self.start_time is None:
            raise RuntimeError('You must call "start" before calling "update"')
 
        now = time.time()
        self.seconds_elapsed = now - self.start_time
        self.next_update = self.currval + self.update_interval
        self.fd.write(self._format_line() + '\r')
        self.last_update_time = now
 
 
    def start(self):
        '''Starts measuring time, and prints the bar at 0%.
 
        It returns self so you can use it like this:
        >>> pbar = ProgressBar().start()
        >>> for i in range(100):
        ...    # do something
        ...    pbar.update(i+1)
        ...
        >>> pbar.finish()
        '''
 
        if self.maxval is None:
            self.maxval = self._DEFAULT_MAXVAL
 
        self.num_intervals = max(100, self.term_width)
        self.next_update = 0
 
        if self.maxval is not UnknownLength:
            if self.maxval < 0: raise ValueError('Value out of range')
            self.update_interval = self.maxval / self.num_intervals
 
 
        self.start_time = self.last_update_time = time.time()
        self.update(0)
 
        return self
 
 
    def finish(self):
        'Puts the ProgressBar bar in the finished state.'
 
        self.finished = True
        self.update(self.maxval)
        self.fd.write('\n')
        if self.signal_set:
            signal.signal(signal.SIGWINCH, signal.SIG_DFL)
def format_updatable(updatable, pbar):
    if hasattr(updatable, 'update'): return updatable.update(pbar)
    else: return updatable
 
 
class infinite_iterator(object):
    def __init__(self):
        self.n = 1
    def __iter__(self):
        return self
    def next(self):
        return 1