~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/progress.py

  • Committer: Patch Queue Manager
  • Date: 2011-09-22 14:12:18 UTC
  • mfrom: (6155.3.1 jam)
  • Revision ID: pqm@pqm.ubuntu.com-20110922141218-86s4uu6nqvourw4f
(jameinel) Cleanup comments bzrlib/smart/__init__.py (John A Meinel)

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005 Aaron Bentley <aaron.bentley@utoronto.ca>
2
 
# Copyright (C) 2005, 2006 Canonical <canonical.com>
3
 
#
4
 
#    This program is free software; you can redistribute it and/or modify
5
 
#    it under the terms of the GNU General Public License as published by
6
 
#    the Free Software Foundation; either version 2 of the License, or
7
 
#    (at your option) any later version.
8
 
#
9
 
#    This program is distributed in the hope that it will be useful,
10
 
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
 
#    GNU General Public License for more details.
13
 
#
14
 
#    You should have received a copy of the GNU General Public License
15
 
#    along with this program; if not, write to the Free Software
16
 
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
 
 
18
 
 
19
 
"""Simple text-mode progress indicator.
20
 
 
21
 
To display an indicator, create a ProgressBar object.  Call it,
22
 
passing Progress objects indicating the current state.  When done,
23
 
call clear().
24
 
 
25
 
Progress is suppressed when output is not sent to a terminal, so as
26
 
not to clutter log files.
 
1
# Copyright (C) 2005-2010 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
 
 
18
"""Progress indicators.
 
19
 
 
20
The usual way to use this is via bzrlib.ui.ui_factory.nested_progress_bar which
 
21
will manage a conceptual stack of nested activities.
27
22
"""
28
23
 
29
 
# TODO: should be a global option e.g. --silent that disables progress
30
 
# indicators, preferably without needing to adjust all code that
31
 
# potentially calls them.
32
 
 
33
 
# TODO: If not on a tty perhaps just print '......' for the benefit of IDEs, etc
34
 
 
35
 
# TODO: Optionally show elapsed time instead/as well as ETA; nicer
36
 
# when the rate is unpredictable
37
 
 
38
24
 
39
25
import sys
40
26
import time
41
27
import os
42
 
from collections import deque
43
 
 
44
 
 
45
 
import bzrlib.errors as errors
46
 
from bzrlib.trace import mutter 
 
28
 
 
29
 
 
30
from bzrlib.symbol_versioning import (
 
31
    deprecated_in,
 
32
    deprecated_method,
 
33
    )
47
34
 
48
35
 
49
36
def _supports_progress(f):
50
 
    if not hasattr(f, 'isatty'):
51
 
        return False
52
 
    if not f.isatty():
53
 
        return False
 
37
    """Detect if we can use pretty progress bars on file F.
 
38
 
 
39
    If this returns true we expect that a human may be looking at that
 
40
    output, and that we can repaint a line to update it.
 
41
 
 
42
    This doesn't check the policy for whether we *should* use them.
 
43
    """
 
44
    isatty = getattr(f, 'isatty', None)
 
45
    if isatty is None:
 
46
        return False
 
47
    if not isatty():
 
48
        return False
 
49
    # The following case also handles Win32 - on that platform $TERM is
 
50
    # typically never set, so the case None is treated as a smart terminal,
 
51
    # not dumb.  <https://bugs.launchpad.net/bugs/334808>  win32 files do have
 
52
    # isatty methods that return true.
54
53
    if os.environ.get('TERM') == 'dumb':
55
54
        # e.g. emacs compile window
56
55
        return False
57
56
    return True
58
57
 
59
58
 
60
 
 
61
 
def ProgressBar(to_file=None, **kwargs):
62
 
    """Abstract factory"""
63
 
    if to_file is None:
64
 
        to_file = sys.stderr
65
 
    if _supports_progress(to_file):
66
 
        return TTYProgressBar(to_file=to_file, **kwargs)
67
 
    else:
68
 
        return DotsProgressBar(to_file=to_file, **kwargs)
 
59
class ProgressTask(object):
 
60
    """Model component of a progress indicator.
 
61
 
 
62
    Most code that needs to indicate progress should update one of these,
 
63
    and it will in turn update the display, if one is present.
 
64
 
 
65
    Code updating the task may also set fields as hints about how to display
 
66
    it: show_pct, show_spinner, show_eta, show_count, show_bar.  UIs
 
67
    will not necessarily respect all these fields.
69
68
    
70
 
 
71
 
class ProgressBarStack(object):
72
 
    """A stack of progress bars."""
73
 
 
74
 
    def __init__(self,
75
 
                 to_file=None,
76
 
                 show_pct=False,
77
 
                 show_spinner=True,
78
 
                 show_eta=False,
79
 
                 show_bar=True,
80
 
                 show_count=True,
81
 
                 to_messages_file=None,
82
 
                 klass=None):
83
 
        """Setup the stack with the parameters the progress bars should have."""
84
 
        if to_file is None:
85
 
            to_file = sys.stderr
86
 
        if to_messages_file is None:
87
 
            to_messages_file = sys.stdout
88
 
        self._to_file = to_file
89
 
        self._show_pct = show_pct
90
 
        self._show_spinner = show_spinner
91
 
        self._show_eta = show_eta
92
 
        self._show_bar = show_bar
93
 
        self._show_count = show_count
94
 
        self._to_messages_file = to_messages_file
95
 
        self._stack = []
96
 
        self._klass = klass or TTYProgressBar
97
 
 
98
 
    def top(self):
99
 
        if len(self._stack) != 0:
100
 
            return self._stack[-1]
101
 
        else:
102
 
            return None
103
 
 
104
 
    def bottom(self):
105
 
        if len(self._stack) != 0:
106
 
            return self._stack[0]
107
 
        else:
108
 
            return None
109
 
 
110
 
    def get_nested(self):
111
 
        """Return a nested progress bar."""
112
 
        if len(self._stack) == 0:
113
 
            func = self._klass
114
 
        else:
115
 
            func = self.top().child_progress
116
 
        new_bar = func(to_file=self._to_file,
117
 
                       show_pct=self._show_pct,
118
 
                       show_spinner=self._show_spinner,
119
 
                       show_eta=self._show_eta,
120
 
                       show_bar=self._show_bar,
121
 
                       show_count=self._show_count,
122
 
                       to_messages_file=self._to_messages_file,
123
 
                       _stack=self)
124
 
        self._stack.append(new_bar)
125
 
        return new_bar
126
 
 
127
 
    def return_pb(self, bar):
128
 
        """Return bar after its been used."""
129
 
        if bar is not self._stack[-1]:
130
 
            raise errors.MissingProgressBarFinish()
131
 
        self._stack.pop()
132
 
 
133
 
 
134
 
class _BaseProgressBar(object):
135
 
 
136
 
    def __init__(self,
137
 
                 to_file=None,
138
 
                 show_pct=False,
139
 
                 show_spinner=False,
140
 
                 show_eta=True,
141
 
                 show_bar=True,
142
 
                 show_count=True,
143
 
                 to_messages_file=None,
144
 
                 _stack=None):
145
 
        object.__init__(self)
146
 
        if to_file is None:
147
 
            to_file = sys.stderr
148
 
        if to_messages_file is None:
149
 
            to_messages_file = sys.stdout
150
 
        self.to_file = to_file
151
 
        self.to_messages_file = to_messages_file
152
 
        self.last_msg = None
153
 
        self.last_cnt = None
154
 
        self.last_total = None
155
 
        self.show_pct = show_pct
156
 
        self.show_spinner = show_spinner
157
 
        self.show_eta = show_eta
158
 
        self.show_bar = show_bar
159
 
        self.show_count = show_count
160
 
        self._stack = _stack
161
 
        # seed throttler
162
 
        self.MIN_PAUSE = 0.1 # seconds
163
 
        now = time.clock()
164
 
        # starting now
165
 
        self.start_time = now
166
 
        # next update should not throttle
167
 
        self.last_update = now - self.MIN_PAUSE - 1
 
69
    :ivar update_latency: The interval (in seconds) at which the PB should be
 
70
        updated.  Setting this to zero suggests every update should be shown
 
71
        synchronously.
 
72
 
 
73
    :ivar show_transport_activity: If true (default), transport activity
 
74
        will be shown when this task is drawn.  Disable it if you're sure 
 
75
        that only irrelevant or uninteresting transport activity can occur
 
76
        during this task.
 
77
    """
 
78
 
 
79
    def __init__(self, parent_task=None, ui_factory=None, progress_view=None):
 
80
        """Construct a new progress task.
 
81
 
 
82
        :param parent_task: Enclosing ProgressTask or None.
 
83
 
 
84
        :param progress_view: ProgressView to display this ProgressTask.
 
85
 
 
86
        :param ui_factory: The UI factory that will display updates; 
 
87
            deprecated in favor of passing progress_view directly.
 
88
 
 
89
        Normally you should not call this directly but rather through
 
90
        `ui_factory.nested_progress_bar`.
 
91
        """
 
92
        self._parent_task = parent_task
 
93
        self._last_update = 0
 
94
        self.total_cnt = None
 
95
        self.current_cnt = None
 
96
        self.msg = ''
 
97
        # TODO: deprecate passing ui_factory
 
98
        self.ui_factory = ui_factory
 
99
        self.progress_view = progress_view
 
100
        self.show_pct = False
 
101
        self.show_spinner = True
 
102
        self.show_eta = False,
 
103
        self.show_count = True
 
104
        self.show_bar = True
 
105
        self.update_latency = 0.1
 
106
        self.show_transport_activity = True
 
107
 
 
108
    def __repr__(self):
 
109
        return '%s(%r/%r, msg=%r)' % (
 
110
            self.__class__.__name__,
 
111
            self.current_cnt,
 
112
            self.total_cnt,
 
113
            self.msg)
 
114
 
 
115
    def update(self, msg, current_cnt=None, total_cnt=None):
 
116
        self.msg = msg
 
117
        self.current_cnt = current_cnt
 
118
        if total_cnt:
 
119
            self.total_cnt = total_cnt
 
120
        if self.progress_view:
 
121
            self.progress_view.show_progress(self)
 
122
        else:
 
123
            self.ui_factory._progress_updated(self)
 
124
 
 
125
    def tick(self):
 
126
        self.update(self.msg)
168
127
 
169
128
    def finished(self):
170
 
        """Return this bar to its progress stack."""
171
 
        self.clear()
172
 
        assert self._stack is not None
173
 
        self._stack.return_pb(self)
174
 
 
175
 
    def note(self, fmt_string, *args, **kwargs):
176
 
        """Record a note without disrupting the progress bar."""
177
 
        self.clear()
178
 
        self.to_messages_file.write(fmt_string % args)
179
 
        self.to_messages_file.write('\n')
180
 
 
181
 
    def child_progress(self, **kwargs):
182
 
        return ChildProgress(**kwargs)
183
 
 
184
 
 
185
 
class DummyProgress(_BaseProgressBar):
 
129
        if self.progress_view:
 
130
            self.progress_view.task_finished(self)
 
131
        else:
 
132
            self.ui_factory._progress_finished(self)
 
133
 
 
134
    def make_sub_task(self):
 
135
        return ProgressTask(self, ui_factory=self.ui_factory,
 
136
            progress_view=self.progress_view)
 
137
 
 
138
    def _overall_completion_fraction(self, child_fraction=0.0):
 
139
        """Return fractional completion of this task and its parents
 
140
 
 
141
        Returns None if no completion can be computed."""
 
142
        if self.current_cnt is not None and self.total_cnt:
 
143
            own_fraction = (float(self.current_cnt) + child_fraction) / self.total_cnt
 
144
        else:
 
145
            # if this task has no estimation, it just passes on directly
 
146
            # whatever the child has measured...
 
147
            own_fraction = child_fraction
 
148
        if self._parent_task is None:
 
149
            return own_fraction
 
150
        else:
 
151
            if own_fraction is None:
 
152
                own_fraction = 0.0
 
153
            return self._parent_task._overall_completion_fraction(own_fraction)
 
154
 
 
155
    def clear(self):
 
156
        # TODO: deprecate this method; the model object shouldn't be concerned
 
157
        # with whether it's shown or not.  Most callers use this because they
 
158
        # want to write some different non-progress output to the screen, but
 
159
        # they should probably instead use a stream that's synchronized with
 
160
        # the progress output.  It may be there is a model-level use for
 
161
        # saying "this task's not active at the moment" but I don't see it. --
 
162
        # mbp 20090623
 
163
        if self.progress_view:
 
164
            self.progress_view.clear()
 
165
        else:
 
166
            self.ui_factory.clear_term()
 
167
 
 
168
 
 
169
class DummyProgress(object):
186
170
    """Progress-bar standin that does nothing.
187
171
 
188
 
    This can be used as the default argument for methods that
189
 
    take an optional progress indicator."""
 
172
    This was previously often constructed by application code if no progress
 
173
    bar was explicitly passed in.  That's no longer recommended: instead, just
 
174
    create a progress task from the ui_factory.  This class can be used in
 
175
    test code that needs to fake a progress task for some reason.
 
176
    """
 
177
 
190
178
    def tick(self):
191
179
        pass
192
180
 
198
186
 
199
187
    def clear(self):
200
188
        pass
201
 
        
202
 
    def note(self, fmt_string, *args, **kwargs):
203
 
        """See _BaseProgressBar.note()."""
204
189
 
205
190
    def child_progress(self, **kwargs):
206
191
        return DummyProgress(**kwargs)
207
192
 
208
193
 
209
 
class DotsProgressBar(_BaseProgressBar):
210
 
 
211
 
    def __init__(self, **kwargs):
212
 
        _BaseProgressBar.__init__(self, **kwargs)
213
 
        self.last_msg = None
214
 
        self.need_nl = False
215
 
        
216
 
    def tick(self):
217
 
        self.update()
218
 
        
219
 
    def update(self, msg=None, current_cnt=None, total_cnt=None):
220
 
        if msg and msg != self.last_msg:
221
 
            if self.need_nl:
222
 
                self.to_file.write('\n')
223
 
            self.to_file.write(msg + ': ')
224
 
            self.last_msg = msg
225
 
        self.need_nl = True
226
 
        self.to_file.write('.')
227
 
        
228
 
    def clear(self):
229
 
        if self.need_nl:
230
 
            self.to_file.write('\n')
231
 
        self.need_nl = False
232
 
        
233
 
    def child_update(self, message, current, total):
234
 
        self.tick()
235
 
 
236
 
    
237
 
class TTYProgressBar(_BaseProgressBar):
238
 
    """Progress bar display object.
239
 
 
240
 
    Several options are available to control the display.  These can
241
 
    be passed as parameters to the constructor or assigned at any time:
242
 
 
243
 
    show_pct
244
 
        Show percentage complete.
245
 
    show_spinner
246
 
        Show rotating baton.  This ticks over on every update even
247
 
        if the values don't change.
248
 
    show_eta
249
 
        Show predicted time-to-completion.
250
 
    show_bar
251
 
        Show bar graph.
252
 
    show_count
253
 
        Show numerical counts.
254
 
 
255
 
    The output file should be in line-buffered or unbuffered mode.
256
 
    """
257
 
    SPIN_CHARS = r'/-\|'
258
 
 
259
 
 
260
 
    def __init__(self, **kwargs):
261
 
        from bzrlib.osutils import terminal_width
262
 
        _BaseProgressBar.__init__(self, **kwargs)
263
 
        self.spin_pos = 0
264
 
        self.width = terminal_width()
265
 
        self.start_time = None
266
 
        self.last_updates = deque()
267
 
        self.child_fraction = 0
268
 
    
269
 
 
270
 
    def throttle(self):
271
 
        """Return True if the bar was updated too recently"""
272
 
        # time.time consistently takes 40/4000 ms = 0.01 ms.
273
 
        # but every single update to the pb invokes it.
274
 
        # so we use time.clock which takes 20/4000 ms = 0.005ms
275
 
        # on the downside, time.clock() appears to have approximately
276
 
        # 10ms granularity, so we treat a zero-time change as 'throttled.'
277
 
        
278
 
        now = time.clock()
279
 
        interval = now - self.last_update
280
 
        # if interval > 0
281
 
        if interval < self.MIN_PAUSE:
282
 
            return True
283
 
 
284
 
        self.last_updates.append(now - self.last_update)
285
 
        self.last_update = now
286
 
        return False
287
 
        
288
 
    def tick(self):
289
 
        self.update(self.last_msg, self.last_cnt, self.last_total, 
290
 
                    self.child_fraction)
291
 
 
292
 
    def child_update(self, message, current, total):
293
 
        if current is not None and total != 0:
294
 
            child_fraction = float(current) / total
295
 
            if self.last_cnt is None:
296
 
                pass
297
 
            elif self.last_cnt + child_fraction <= self.last_total:
298
 
                self.child_fraction = child_fraction
299
 
            else:
300
 
                mutter('not updating child fraction')
301
 
        if self.last_msg is None:
302
 
            self.last_msg = ''
303
 
        self.tick()
304
 
 
305
 
    def update(self, msg, current_cnt=None, total_cnt=None, 
306
 
               child_fraction=0):
307
 
        """Update and redraw progress bar."""
308
 
        if msg is None:
309
 
            msg = self.last_msg
310
 
 
311
 
        if total_cnt is None:
312
 
            total_cnt = self.last_total
313
 
 
314
 
        if current_cnt < 0:
315
 
            current_cnt = 0
316
 
            
317
 
        if current_cnt > total_cnt:
318
 
            total_cnt = current_cnt
319
 
        
320
 
        ## # optional corner case optimisation 
321
 
        ## # currently does not seem to fire so costs more than saved.
322
 
        ## # trivial optimal case:
323
 
        ## # NB if callers are doing a clear and restore with
324
 
        ## # the saved values, this will prevent that:
325
 
        ## # in that case add a restore method that calls
326
 
        ## # _do_update or some such
327
 
        ## if (self.last_msg == msg and
328
 
        ##     self.last_cnt == current_cnt and
329
 
        ##     self.last_total == total_cnt and
330
 
        ##     self.child_fraction == child_fraction):
331
 
        ##     return
332
 
 
333
 
        old_msg = self.last_msg
334
 
        # save these for the tick() function
335
 
        self.last_msg = msg
336
 
        self.last_cnt = current_cnt
337
 
        self.last_total = total_cnt
338
 
        self.child_fraction = child_fraction
339
 
 
340
 
        # each function call takes 20ms/4000 = 0.005 ms, 
341
 
        # but multiple that by 4000 calls -> starts to cost.
342
 
        # so anything to make this function call faster
343
 
        # will improve base 'diff' time by up to 0.1 seconds.
344
 
        if old_msg == self.last_msg and self.throttle():
345
 
            return
346
 
 
347
 
        if self.show_eta and self.start_time and self.last_total:
348
 
            eta = get_eta(self.start_time, self.last_cnt + self.child_fraction, 
349
 
                    self.last_total, last_updates = self.last_updates)
350
 
            eta_str = " " + str_tdelta(eta)
351
 
        else:
352
 
            eta_str = ""
353
 
 
354
 
        if self.show_spinner:
355
 
            spin_str = self.SPIN_CHARS[self.spin_pos % 4] + ' '            
356
 
        else:
357
 
            spin_str = ''
358
 
 
359
 
        # always update this; it's also used for the bar
360
 
        self.spin_pos += 1
361
 
 
362
 
        if self.show_pct and self.last_total and self.last_cnt:
363
 
            pct = 100.0 * ((self.last_cnt + self.child_fraction) / self.last_total)
364
 
            pct_str = ' (%5.1f%%)' % pct
365
 
        else:
366
 
            pct_str = ''
367
 
 
368
 
        if not self.show_count:
369
 
            count_str = ''
370
 
        elif self.last_cnt is None:
371
 
            count_str = ''
372
 
        elif self.last_total is None:
373
 
            count_str = ' %i' % (self.last_cnt)
374
 
        else:
375
 
            # make both fields the same size
376
 
            t = '%i' % (self.last_total)
377
 
            c = '%*i' % (len(t), self.last_cnt)
378
 
            count_str = ' ' + c + '/' + t 
379
 
 
380
 
        if self.show_bar:
381
 
            # progress bar, if present, soaks up all remaining space
382
 
            cols = self.width - 1 - len(self.last_msg) - len(spin_str) - len(pct_str) \
383
 
                   - len(eta_str) - len(count_str) - 3
384
 
 
385
 
            if self.last_total:
386
 
                # number of markers highlighted in bar
387
 
                markers = int(round(float(cols) * 
388
 
                              (self.last_cnt + self.child_fraction) / self.last_total))
389
 
                bar_str = '[' + ('=' * markers).ljust(cols) + '] '
390
 
            elif False:
391
 
                # don't know total, so can't show completion.
392
 
                # so just show an expanded spinning thingy
393
 
                m = self.spin_pos % cols
394
 
                ms = (' ' * m + '*').ljust(cols)
395
 
                
396
 
                bar_str = '[' + ms + '] '
397
 
            else:
398
 
                bar_str = ''
399
 
        else:
400
 
            bar_str = ''
401
 
 
402
 
        m = spin_str + bar_str + self.last_msg + count_str + pct_str + eta_str
403
 
 
404
 
        assert len(m) < self.width
405
 
        self.to_file.write('\r' + m.ljust(self.width - 1))
406
 
        #self.to_file.flush()
407
 
            
408
 
    def clear(self):        
409
 
        self.to_file.write('\r%s\r' % (' ' * (self.width - 1)))
410
 
        #self.to_file.flush()        
411
 
 
412
 
 
413
 
class ChildProgress(_BaseProgressBar):
414
 
    """A progress indicator that pushes its data to the parent"""
415
 
 
416
 
    def __init__(self, _stack, **kwargs):
417
 
        _BaseProgressBar.__init__(self, _stack=_stack, **kwargs)
418
 
        self.parent = _stack.top()
419
 
        self.current = None
420
 
        self.total = None
421
 
        self.child_fraction = 0
422
 
        self.message = None
423
 
 
424
 
    def update(self, msg, current_cnt=None, total_cnt=None):
425
 
        self.current = current_cnt
426
 
        self.total = total_cnt
427
 
        self.message = msg
428
 
        self.child_fraction = 0
429
 
        self.tick()
430
 
 
431
 
    def child_update(self, message, current, total):
432
 
        if current is None or total == 0:
433
 
            self.child_fraction = 0
434
 
        else:
435
 
            self.child_fraction = float(current) / total
436
 
        self.tick()
437
 
 
438
 
    def tick(self):
439
 
        if self.current is None:
440
 
            count = None
441
 
        else:
442
 
            count = self.current+self.child_fraction
443
 
            if count > self.total:
444
 
                if __debug__:
445
 
                    mutter('clamping count of %d to %d' % (count, self.total))
446
 
                count = self.total
447
 
        self.parent.child_update(self.message, count, self.total)
448
 
 
449
 
    def clear(self):
450
 
        pass
451
 
 
452
 
    def note(self, *args, **kwargs):
453
 
        self.parent.note(*args, **kwargs)
454
 
 
455
 
 
456
194
def str_tdelta(delt):
457
195
    if delt is None:
458
196
        return "-:--:--"
475
213
    if current > total:
476
214
        return None                     # wtf?
477
215
 
478
 
    elapsed = time.clock() - start_time
 
216
    elapsed = time.time() - start_time
479
217
 
480
218
    if elapsed < 2.0:                   # not enough time to estimate
481
219
        return None
482
 
    
 
220
 
483
221
    total_duration = float(elapsed) * float(total) / float(current)
484
222
 
485
 
    assert total_duration >= elapsed
486
 
 
487
223
    if last_updates and len(last_updates) >= n_recent:
488
 
        while len(last_updates) > n_recent:
489
 
            last_updates.popleft()
490
224
        avg = sum(last_updates) / float(len(last_updates))
491
225
        time_left = avg * (total - current)
492
226
 
512
246
            self.cur_phase = 0
513
247
        else:
514
248
            self.cur_phase += 1
515
 
        assert self.cur_phase < self.total 
516
249
        self.pb.update(self.message, self.cur_phase, self.total)
517
 
 
518
 
 
519
 
def run_tests():
520
 
    import doctest
521
 
    result = doctest.testmod()
522
 
    if result[1] > 0:
523
 
        if result[0] == 0:
524
 
            print "All tests passed"
525
 
    else:
526
 
        print "No tests to run"
527
 
 
528
 
 
529
 
def demo():
530
 
    sleep = time.sleep
531
 
    
532
 
    print 'dumb-terminal test:'
533
 
    pb = DotsProgressBar()
534
 
    for i in range(100):
535
 
        pb.update('Leoparden', i, 99)
536
 
        sleep(0.1)
537
 
    sleep(1.5)
538
 
    pb.clear()
539
 
    sleep(1.5)
540
 
    
541
 
    print 'smart-terminal test:'
542
 
    pb = ProgressBar(show_pct=True, show_bar=True, show_spinner=False)
543
 
    for i in range(100):
544
 
        pb.update('Elephanten', i, 99)
545
 
        sleep(0.1)
546
 
    sleep(2)
547
 
    pb.clear()
548
 
    sleep(1)
549
 
 
550
 
    print 'done!'
551
 
 
552
 
if __name__ == "__main__":
553
 
    demo()