/brz/remove-bazaar

# Copyright (C) 2005 Aaron Bentley <aaron.bentley@utoronto.ca>

# Copyright (C) 2005 Canonical <canonical.com>

#

#    This program is free software; you can redistribute it and/or modify

#    it under the terms of the GNU General Public License as published by

#    the Free Software Foundation; either version 2 of the License, or

#    (at your option) any later version.

#

#    This program is distributed in the hope that it will be useful,

#    but WITHOUT ANY WARRANTY; without even the implied warranty of

#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

#    GNU General Public License for more details.

#

#    You should have received a copy of the GNU General Public License

#    along with this program; if not, write to the Free Software

#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

"""

Simple text-mode progress indicator.

Everyone loves ascii art!

To display an indicator, create a ProgressBar object.  Call it,

passing Progress objects indicating the current state.  When done,

call clear().

Progress is suppressed when output is not sent to a terminal, so as

not to clutter log files.

"""

# TODO: remove functions in favour of keeping everything in one class

# TODO: should be a global option e.g. --silent that disables progress

# indicators, preferably without needing to adjust all code that

# potentially calls them.

import sys

import datetime

def _width():

    """Return estimated terminal width.

    TODO: Do something smart on Windows?

    TODO: Is there anything that gets a better update when the window

          is resized while the program is running?

    """

    import os

    try:

        return int(os.environ['COLUMNS'])

    except (IndexError, KeyError, ValueError):

        return 80

def _supports_progress(f):

    return hasattr(f, 'isatty') and f.isatty()

class Progress(object):

    def __init__(self, units, current, total=None):

        self.units = units

        self.current = current

        self.total = total

    def _get_percent(self):

        if self.total is not None and self.current is not None:

            return 100.0 * self.current / self.total

    percent = property(_get_percent)

    def __str__(self):

        if self.total is not None:

            return "%i of %i %s %.1f%%" % (self.current, self.total, self.units,

                                         self.percent)

        else:

            return "%i %s" (self.current, self.units)

class ProgressBar(object):

    def __init__(self, to_file=sys.stderr):

        object.__init__(self)

        self.start = None

        self.to_file = to_file

        self.suppressed = not _supports_progress(self.to_file)

    def __call__(self, progress):

        if self.start is None:

            self.start = datetime.datetime.now()

        if not self.suppressed:

            draw_progress_bar(progress, start_time=self.start,

                              to_file=self.to_file)

    def clear(self):

        if not self.suppressed:

            clear_progress_bar(self.to_file)

def divide_timedelta(delt, divisor):

    """Divides a timedelta object"""

    return datetime.timedelta(float(delt.days)/divisor, 

                              float(delt.seconds)/divisor, 

                              float(delt.microseconds)/divisor)

def str_tdelta(delt):

    if delt is None:

        return "-:--:--"

    return str(datetime.timedelta(delt.days, delt.seconds))

def get_eta(start_time, progress, enough_samples=20):

    if start_time is None or progress.current == 0:

        return None

    elif progress.current < enough_samples:

        return None

    elapsed = datetime.datetime.now() - start_time

    total_duration = divide_timedelta((elapsed) * long(progress.total), 

                                      progress.current)

    if elapsed < total_duration:

        eta = total_duration - elapsed

    else:

        eta = total_duration - total_duration

    return eta

def draw_progress_bar(progress, start_time=None, to_file=sys.stderr):

    eta = get_eta(start_time, progress)

    if start_time is not None:

        eta_str = " "+str_tdelta(eta)

    else:

        eta_str = ""

    fmt = " %i of %i %s (%.1f%%)"

    f = fmt % (progress.total, progress.total, progress.units, 100.0)

    cols = _width() - 3 - len(f)

    if start_time is not None:

        cols -= len(eta_str)

    markers = int (float(cols) * progress.current / progress.total)

    txt = fmt % (progress.current, progress.total, progress.units,

                 progress.percent)

    to_file.write("\r[%s%s]%s%s" % ('='*markers, ' '*(cols-markers), txt, 

                                       eta_str))

def clear_progress_bar(to_file=sys.stderr):

    to_file.write('\r%s\r' % (' '*79))

def spinner_str(progress, show_text=False):

    """

    Produces the string for a textual "spinner" progress indicator

    :param progress: an object represinting current progress

    :param show_text: If true, show progress text as well

    :return: The spinner string

    >>> spinner_str(Progress("baloons", 0))

    '|'

    >>> spinner_str(Progress("baloons", 5))

    '/'

    >>> spinner_str(Progress("baloons", 6), show_text=True)

    '- 6 baloons'

    """

    positions = ('|', '/', '-', '\\')

    text = positions[progress.current % 4]

    if show_text:

        text+=" %i %s" % (progress.current, progress.units)

    return text

def spinner(progress, show_text=False, output=sys.stderr):

    """

    Update a spinner progress indicator on an output

    :param progress: The progress to display

    :param show_text: If true, show text as well as spinner

    :param output: The output to write to

    >>> spinner(Progress("baloons", 6), show_text=True, output=sys.stdout)

    \r- 6 baloons

    """

    output.write('\r%s' % spinner_str(progress, show_text))

def run_tests():

    import doctest

    result = doctest.testmod()

    if result[1] > 0:

        if result[0] == 0:

            print "All tests passed"

    else:

        print "No tests to run"

def demo():

    from time import sleep

    pb = ProgressBar()

    for i in range(100):

        pb(Progress('Elephanten', i, 100))

        sleep(0.3)

    print 'done!'

if __name__ == "__main__":

    demo()