~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/progress.py

  • Committer: Vincent Ladeuil
  • Date: 2010-02-03 07:18:36 UTC
  • mto: (5008.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5009.
  • Revision ID: v.ladeuil+lp@free.fr-20100203071836-u9b86q68fr9ri5s6
Fix NEWS.

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, 2006, 2008, 2009 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
28
 
43
 
import bzrlib.errors as errors
 
29
 
 
30
from bzrlib import (
 
31
    errors,
 
32
    )
44
33
from bzrlib.trace import mutter
 
34
from bzrlib.symbol_versioning import (
 
35
    deprecated_function,
 
36
    deprecated_in,
 
37
    deprecated_method,
 
38
    )
45
39
 
46
40
 
47
41
def _supports_progress(f):
 
42
    """Detect if we can use pretty progress bars on file F.
 
43
 
 
44
    If this returns true we expect that a human may be looking at that
 
45
    output, and that we can repaint a line to update it.
 
46
 
 
47
    This doesn't check the policy for whether we *should* use them.
 
48
    """
48
49
    isatty = getattr(f, 'isatty', None)
49
50
    if isatty is None:
50
51
        return False
51
52
    if not isatty():
52
53
        return False
 
54
    # The following case also handles Win32 - on that platform $TERM is
 
55
    # typically never set, so the case None is treated as a smart terminal,
 
56
    # not dumb.  <https://bugs.launchpad.net/bugs/334808>  win32 files do have
 
57
    # isatty methods that return true.
53
58
    if os.environ.get('TERM') == 'dumb':
54
59
        # e.g. emacs compile window
55
60
        return False
56
61
    return True
57
62
 
58
63
 
59
 
_progress_bar_types = {}
60
 
 
61
 
 
 
64
class ProgressTask(object):
 
65
    """Model component of a progress indicator.
 
66
 
 
67
    Most code that needs to indicate progress should update one of these,
 
68
    and it will in turn update the display, if one is present.
 
69
 
 
70
    Code updating the task may also set fields as hints about how to display
 
71
    it: show_pct, show_spinner, show_eta, show_count, show_bar.  UIs
 
72
    will not necessarily respect all these fields.
 
73
    
 
74
    :ivar update_latency: The interval (in seconds) at which the PB should be
 
75
        updated.  Setting this to zero suggests every update should be shown
 
76
        synchronously.
 
77
 
 
78
    :ivar show_transport_activity: If true (default), transport activity
 
79
        will be shown when this task is drawn.  Disable it if you're sure 
 
80
        that only irrelevant or uninteresting transport activity can occur
 
81
        during this task.
 
82
    """
 
83
 
 
84
    def __init__(self, parent_task=None, ui_factory=None, progress_view=None):
 
85
        """Construct a new progress task.
 
86
 
 
87
        :param parent_task: Enclosing ProgressTask or None.
 
88
 
 
89
        :param progress_view: ProgressView to display this ProgressTask.
 
90
 
 
91
        :param ui_factory: The UI factory that will display updates; 
 
92
            deprecated in favor of passing progress_view directly.
 
93
 
 
94
        Normally you should not call this directly but rather through
 
95
        `ui_factory.nested_progress_bar`.
 
96
        """
 
97
        self._parent_task = parent_task
 
98
        self._last_update = 0
 
99
        self.total_cnt = None
 
100
        self.current_cnt = None
 
101
        self.msg = ''
 
102
        # TODO: deprecate passing ui_factory
 
103
        self.ui_factory = ui_factory
 
104
        self.progress_view = progress_view
 
105
        self.show_pct = False
 
106
        self.show_spinner = True
 
107
        self.show_eta = False,
 
108
        self.show_count = True
 
109
        self.show_bar = True
 
110
        self.update_latency = 0.1
 
111
        self.show_transport_activity = True
 
112
 
 
113
    def __repr__(self):
 
114
        return '%s(%r/%r, msg=%r)' % (
 
115
            self.__class__.__name__,
 
116
            self.current_cnt,
 
117
            self.total_cnt,
 
118
            self.msg)
 
119
 
 
120
    def update(self, msg, current_cnt=None, total_cnt=None):
 
121
        self.msg = msg
 
122
        self.current_cnt = current_cnt
 
123
        if total_cnt:
 
124
            self.total_cnt = total_cnt
 
125
        if self.progress_view:
 
126
            self.progress_view.show_progress(self)
 
127
        else:
 
128
            self.ui_factory._progress_updated(self)
 
129
 
 
130
    def tick(self):
 
131
        self.update(self.msg)
 
132
 
 
133
    def finished(self):
 
134
        if self.progress_view:
 
135
            self.progress_view.task_finished(self)
 
136
        else:
 
137
            self.ui_factory._progress_finished(self)
 
138
 
 
139
    def make_sub_task(self):
 
140
        return ProgressTask(self, ui_factory=self.ui_factory,
 
141
            progress_view=self.progress_view)
 
142
 
 
143
    def _overall_completion_fraction(self, child_fraction=0.0):
 
144
        """Return fractional completion of this task and its parents
 
145
 
 
146
        Returns None if no completion can be computed."""
 
147
        if self.current_cnt is not None and self.total_cnt:
 
148
            own_fraction = (float(self.current_cnt) + child_fraction) / self.total_cnt
 
149
        else:
 
150
            # if this task has no estimation, it just passes on directly
 
151
            # whatever the child has measured...
 
152
            own_fraction = child_fraction
 
153
        if self._parent_task is None:
 
154
            return own_fraction
 
155
        else:
 
156
            if own_fraction is None:
 
157
                own_fraction = 0.0
 
158
            return self._parent_task._overall_completion_fraction(own_fraction)
 
159
 
 
160
    @deprecated_method(deprecated_in((2, 1, 0)))
 
161
    def note(self, fmt_string, *args):
 
162
        """Record a note without disrupting the progress bar.
 
163
        
 
164
        Deprecated: use ui_factory.note() instead or bzrlib.trace.  Note that
 
165
        ui_factory.note takes just one string as the argument, not a format
 
166
        string and arguments.
 
167
        """
 
168
        if args:
 
169
            self.ui_factory.note(fmt_string % args)
 
170
        else:
 
171
            self.ui_factory.note(fmt_string)
 
172
 
 
173
    def clear(self):
 
174
        # TODO: deprecate this method; the model object shouldn't be concerned
 
175
        # with whether it's shown or not.  Most callers use this because they
 
176
        # want to write some different non-progress output to the screen, but
 
177
        # they should probably instead use a stream that's synchronized with
 
178
        # the progress output.  It may be there is a model-level use for
 
179
        # saying "this task's not active at the moment" but I don't see it. --
 
180
        # mbp 20090623
 
181
        if self.progress_view:
 
182
            self.progress_view.clear()
 
183
        else:
 
184
            self.ui_factory.clear_term()
 
185
 
 
186
 
 
187
@deprecated_function(deprecated_in((1, 16, 0)))
62
188
def ProgressBar(to_file=None, **kwargs):
63
 
    """Abstract factory"""
 
189
    """Construct a progress bar.
 
190
 
 
191
    Deprecated; ask the ui_factory for a progress task instead.
 
192
    """
64
193
    if to_file is None:
65
194
        to_file = sys.stderr
66
195
    requested_bar_type = os.environ.get('BZR_PROGRESS_BAR')
69
198
        if _supports_progress(to_file):
70
199
            return TTYProgressBar(to_file=to_file, **kwargs)
71
200
        else:
72
 
            return DotsProgressBar(to_file=to_file, **kwargs)
 
201
            return DummyProgress(to_file=to_file, **kwargs)
73
202
    else:
74
203
        # Minor sanitation to prevent spurious errors
75
204
        requested_bar_type = requested_bar_type.lower().strip()
81
210
                                                _progress_bar_types.keys())
82
211
        return _progress_bar_types[requested_bar_type](to_file=to_file, **kwargs)
83
212
 
84
 
 
85
 
class ProgressBarStack(object):
86
 
    """A stack of progress bars."""
87
 
 
88
 
    def __init__(self,
89
 
                 to_file=None,
90
 
                 show_pct=False,
91
 
                 show_spinner=True,
92
 
                 show_eta=False,
93
 
                 show_bar=True,
94
 
                 show_count=True,
95
 
                 to_messages_file=None,
96
 
                 klass=None):
97
 
        """Setup the stack with the parameters the progress bars should have."""
98
 
        if to_file is None:
99
 
            to_file = sys.stderr
100
 
        if to_messages_file is None:
101
 
            to_messages_file = sys.stdout
102
 
        self._to_file = to_file
103
 
        self._show_pct = show_pct
104
 
        self._show_spinner = show_spinner
105
 
        self._show_eta = show_eta
106
 
        self._show_bar = show_bar
107
 
        self._show_count = show_count
108
 
        self._to_messages_file = to_messages_file
109
 
        self._stack = []
110
 
        self._klass = klass or ProgressBar
111
 
 
112
 
    def top(self):
113
 
        if len(self._stack) != 0:
114
 
            return self._stack[-1]
115
 
        else:
116
 
            return None
117
 
 
118
 
    def bottom(self):
119
 
        if len(self._stack) != 0:
120
 
            return self._stack[0]
121
 
        else:
122
 
            return None
123
 
 
124
 
    def get_nested(self):
125
 
        """Return a nested progress bar."""
126
 
        if len(self._stack) == 0:
127
 
            func = self._klass
128
 
        else:
129
 
            func = self.top().child_progress
130
 
        new_bar = func(to_file=self._to_file,
131
 
                       show_pct=self._show_pct,
132
 
                       show_spinner=self._show_spinner,
133
 
                       show_eta=self._show_eta,
134
 
                       show_bar=self._show_bar,
135
 
                       show_count=self._show_count,
136
 
                       to_messages_file=self._to_messages_file,
137
 
                       _stack=self)
138
 
        self._stack.append(new_bar)
139
 
        return new_bar
140
 
 
141
 
    def return_pb(self, bar):
142
 
        """Return bar after its been used."""
143
 
        if bar is not self._stack[-1]:
144
 
            raise errors.MissingProgressBarFinish()
145
 
        self._stack.pop()
146
 
 
147
 
 
 
213
 
 
214
# NOTE: This is also deprecated; you should provide a ProgressView instead.
148
215
class _BaseProgressBar(object):
149
216
 
150
217
    def __init__(self,
174
241
        self._stack = _stack
175
242
        # seed throttler
176
243
        self.MIN_PAUSE = 0.1 # seconds
177
 
        now = time.clock()
 
244
        now = time.time()
178
245
        # starting now
179
246
        self.start_time = now
180
247
        # next update should not throttle
183
250
    def finished(self):
184
251
        """Return this bar to its progress stack."""
185
252
        self.clear()
186
 
        assert self._stack is not None
187
253
        self._stack.return_pb(self)
188
254
 
189
255
    def note(self, fmt_string, *args, **kwargs):
192
258
        self.to_messages_file.write(fmt_string % args)
193
259
        self.to_messages_file.write('\n')
194
260
 
 
261
    @deprecated_function(deprecated_in((1, 16, 0)))
195
262
    def child_progress(self, **kwargs):
196
263
        return ChildProgress(**kwargs)
197
264
 
201
268
 
202
269
    This can be used as the default argument for methods that
203
270
    take an optional progress indicator."""
 
271
 
204
272
    def tick(self):
205
273
        pass
206
274
 
212
280
 
213
281
    def clear(self):
214
282
        pass
215
 
        
 
283
 
216
284
    def note(self, fmt_string, *args, **kwargs):
217
285
        """See _BaseProgressBar.note()."""
218
286
 
220
288
        return DummyProgress(**kwargs)
221
289
 
222
290
 
223
 
_progress_bar_types['dummy'] = DummyProgress
224
 
_progress_bar_types['none'] = DummyProgress
225
 
 
226
 
 
227
291
class DotsProgressBar(_BaseProgressBar):
228
292
 
 
293
    @deprecated_function(deprecated_in((1, 16, 0)))
229
294
    def __init__(self, **kwargs):
230
295
        _BaseProgressBar.__init__(self, **kwargs)
231
296
        self.last_msg = None
232
297
        self.need_nl = False
233
 
        
 
298
 
234
299
    def tick(self):
235
300
        self.update()
236
 
        
 
301
 
237
302
    def update(self, msg=None, current_cnt=None, total_cnt=None):
238
303
        if msg and msg != self.last_msg:
239
304
            if self.need_nl:
242
307
            self.last_msg = msg
243
308
        self.need_nl = True
244
309
        self.to_file.write('.')
245
 
        
 
310
 
246
311
    def clear(self):
247
312
        if self.need_nl:
248
313
            self.to_file.write('\n')
249
314
        self.need_nl = False
250
 
        
 
315
 
251
316
    def child_update(self, message, current, total):
252
317
        self.tick()
253
318
 
254
319
 
255
 
_progress_bar_types['dots'] = DotsProgressBar
256
 
 
257
 
    
258
320
class TTYProgressBar(_BaseProgressBar):
259
321
    """Progress bar display object.
260
322
 
277
339
    """
278
340
    SPIN_CHARS = r'/-\|'
279
341
 
280
 
 
 
342
    @deprecated_function(deprecated_in((1, 16, 0)))
281
343
    def __init__(self, **kwargs):
282
344
        from bzrlib.osutils import terminal_width
283
345
        _BaseProgressBar.__init__(self, **kwargs)
287
349
        self._max_last_updates = 10
288
350
        self.child_fraction = 0
289
351
        self._have_output = False
290
 
    
291
352
 
292
353
    def throttle(self, old_msg):
293
354
        """Return True if the bar was updated too recently"""
294
355
        # time.time consistently takes 40/4000 ms = 0.01 ms.
295
 
        # but every single update to the pb invokes it.
296
 
        # so we use time.clock which takes 20/4000 ms = 0.005ms
297
 
        # on the downside, time.clock() appears to have approximately
298
 
        # 10ms granularity, so we treat a zero-time change as 'throttled.'
299
 
        now = time.clock()
 
356
        # time.clock() is faster, but gives us CPU time, not wall-clock time
 
357
        now = time.time()
300
358
        if self.start_time is not None and (now - self.start_time) < 1:
301
359
            return True
302
360
        if old_msg != self.last_msg:
311
369
        self.last_updates = self.last_updates[-self._max_last_updates:]
312
370
        self.last_update = now
313
371
        return False
314
 
        
 
372
 
315
373
    def tick(self):
316
 
        self.update(self.last_msg, self.last_cnt, self.last_total, 
 
374
        self.update(self.last_msg, self.last_cnt, self.last_total,
317
375
                    self.child_fraction)
318
376
 
319
377
    def child_update(self, message, current, total):
323
381
                pass
324
382
            elif self.last_cnt + child_fraction <= self.last_total:
325
383
                self.child_fraction = child_fraction
326
 
            else:
327
 
                mutter('not updating child fraction')
328
384
        if self.last_msg is None:
329
385
            self.last_msg = ''
330
386
        self.tick()
331
387
 
332
 
    def update(self, msg, current_cnt=None, total_cnt=None, 
333
 
               child_fraction=0):
334
 
        """Update and redraw progress bar."""
 
388
    def update(self, msg, current_cnt=None, total_cnt=None,
 
389
            child_fraction=0):
 
390
        """Update and redraw progress bar.
 
391
        """
335
392
        if msg is None:
336
393
            msg = self.last_msg
337
394
 
340
397
 
341
398
        if current_cnt < 0:
342
399
            current_cnt = 0
343
 
            
 
400
 
344
401
        if current_cnt > total_cnt:
345
402
            total_cnt = current_cnt
346
 
        
347
 
        ## # optional corner case optimisation 
 
403
 
 
404
        ## # optional corner case optimisation
348
405
        ## # currently does not seem to fire so costs more than saved.
349
406
        ## # trivial optimal case:
350
407
        ## # NB if callers are doing a clear and restore with
357
414
        ##     self.child_fraction == child_fraction):
358
415
        ##     return
359
416
 
 
417
        if msg is None:
 
418
            msg = ''
 
419
 
360
420
        old_msg = self.last_msg
361
421
        # save these for the tick() function
362
422
        self.last_msg = msg
364
424
        self.last_total = total_cnt
365
425
        self.child_fraction = child_fraction
366
426
 
367
 
        # each function call takes 20ms/4000 = 0.005 ms, 
 
427
        # each function call takes 20ms/4000 = 0.005 ms,
368
428
        # but multiple that by 4000 calls -> starts to cost.
369
429
        # so anything to make this function call faster
370
430
        # will improve base 'diff' time by up to 0.1 seconds.
372
432
            return
373
433
 
374
434
        if self.show_eta and self.start_time and self.last_total:
375
 
            eta = get_eta(self.start_time, self.last_cnt + self.child_fraction, 
 
435
            eta = get_eta(self.start_time, self.last_cnt + self.child_fraction,
376
436
                    self.last_total, last_updates = self.last_updates)
377
437
            eta_str = " " + str_tdelta(eta)
378
438
        else:
379
439
            eta_str = ""
380
440
 
381
441
        if self.show_spinner:
382
 
            spin_str = self.SPIN_CHARS[self.spin_pos % 4] + ' '            
 
442
            spin_str = self.SPIN_CHARS[self.spin_pos % 4] + ' '
383
443
        else:
384
444
            spin_str = ''
385
445
 
402
462
            # make both fields the same size
403
463
            t = '%i' % (self.last_total)
404
464
            c = '%*i' % (len(t), self.last_cnt)
405
 
            count_str = ' ' + c + '/' + t 
 
465
            count_str = ' ' + c + '/' + t
406
466
 
407
467
        if self.show_bar:
408
468
            # progress bar, if present, soaks up all remaining space
411
471
 
412
472
            if self.last_total:
413
473
                # number of markers highlighted in bar
414
 
                markers = int(round(float(cols) * 
 
474
                markers = int(round(float(cols) *
415
475
                              (self.last_cnt + self.child_fraction) / self.last_total))
416
476
                bar_str = '[' + ('=' * markers).ljust(cols) + '] '
417
477
            elif False:
419
479
                # so just show an expanded spinning thingy
420
480
                m = self.spin_pos % cols
421
481
                ms = (' ' * m + '*').ljust(cols)
422
 
                
 
482
 
423
483
                bar_str = '[' + ms + '] '
424
484
            else:
425
485
                bar_str = ''
426
486
        else:
427
487
            bar_str = ''
428
488
 
429
 
        m = spin_str + bar_str + self.last_msg + count_str + pct_str + eta_str
430
 
 
431
 
        assert len(m) < self.width
432
 
        self.to_file.write('\r' + m.ljust(self.width - 1))
 
489
        m = spin_str + bar_str + self.last_msg + count_str \
 
490
            + pct_str + eta_str
 
491
        self.to_file.write('\r%-*.*s' % (self.width - 1, self.width - 1, m))
433
492
        self._have_output = True
434
493
        #self.to_file.flush()
435
 
            
436
 
    def clear(self):        
 
494
 
 
495
    def clear(self):
437
496
        if self._have_output:
438
497
            self.to_file.write('\r%s\r' % (' ' * (self.width - 1)))
439
498
        self._have_output = False
440
 
        #self.to_file.flush()        
441
 
 
442
 
 
443
 
_progress_bar_types['tty'] = TTYProgressBar
444
 
 
445
 
 
 
499
        #self.to_file.flush()
 
500
 
 
501
 
 
502
 
 
503
# DEPRECATED
446
504
class ChildProgress(_BaseProgressBar):
447
505
    """A progress indicator that pushes its data to the parent"""
448
506
 
 
507
    @deprecated_function(deprecated_in((1, 16, 0)))
449
508
    def __init__(self, _stack, **kwargs):
450
509
        _BaseProgressBar.__init__(self, _stack=_stack, **kwargs)
451
510
        self.parent = _stack.top()
456
515
 
457
516
    def update(self, msg, current_cnt=None, total_cnt=None):
458
517
        self.current = current_cnt
459
 
        self.total = total_cnt
 
518
        if total_cnt is not None:
 
519
            self.total = total_cnt
460
520
        self.message = msg
461
521
        self.child_fraction = 0
462
522
        self.tick()
485
545
    def note(self, *args, **kwargs):
486
546
        self.parent.note(*args, **kwargs)
487
547
 
488
 
 
 
548
 
489
549
def str_tdelta(delt):
490
550
    if delt is None:
491
551
        return "-:--:--"
508
568
    if current > total:
509
569
        return None                     # wtf?
510
570
 
511
 
    elapsed = time.clock() - start_time
 
571
    elapsed = time.time() - start_time
512
572
 
513
573
    if elapsed < 2.0:                   # not enough time to estimate
514
574
        return None
515
 
    
 
575
 
516
576
    total_duration = float(elapsed) * float(total) / float(current)
517
577
 
518
 
    assert total_duration >= elapsed
519
 
 
520
578
    if last_updates and len(last_updates) >= n_recent:
521
579
        avg = sum(last_updates) / float(len(last_updates))
522
580
        time_left = avg * (total - current)
543
601
            self.cur_phase = 0
544
602
        else:
545
603
            self.cur_phase += 1
546
 
        assert self.cur_phase < self.total 
547
604
        self.pb.update(self.message, self.cur_phase, self.total)
548
605
 
549
606
 
550
 
def run_tests():
551
 
    import doctest
552
 
    result = doctest.testmod()
553
 
    if result[1] > 0:
554
 
        if result[0] == 0:
555
 
            print "All tests passed"
556
 
    else:
557
 
        print "No tests to run"
558
 
 
559
 
 
560
 
def demo():
561
 
    sleep = time.sleep
562
 
    
563
 
    print 'dumb-terminal test:'
564
 
    pb = DotsProgressBar()
565
 
    for i in range(100):
566
 
        pb.update('Leoparden', i, 99)
567
 
        sleep(0.1)
568
 
    sleep(1.5)
569
 
    pb.clear()
570
 
    sleep(1.5)
571
 
    
572
 
    print 'smart-terminal test:'
573
 
    pb = ProgressBar(show_pct=True, show_bar=True, show_spinner=False)
574
 
    for i in range(100):
575
 
        pb.update('Elephanten', i, 99)
576
 
        sleep(0.1)
577
 
    sleep(2)
578
 
    pb.clear()
579
 
    sleep(1)
580
 
 
581
 
    print 'done!'
582
 
 
583
 
if __name__ == "__main__":
584
 
    demo()
 
607
_progress_bar_types = {}
 
608
_progress_bar_types['dummy'] = DummyProgress
 
609
_progress_bar_types['none'] = DummyProgress
 
610
_progress_bar_types['tty'] = TTYProgressBar
 
611
_progress_bar_types['dots'] = DotsProgressBar