/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/progress.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-05-05 14:19:49 UTC
  • mfrom: (4211.1.7 interbranch-push)
  • Revision ID: pqm@pqm.ubuntu.com-20090505141949-is3fyloox546i797
(Jelmer) Add InterBranch.push.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/progress.py
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
 
from collections import deque
43
 
 
44
 
 
45
 
import bzrlib.errors as errors
46
 
from bzrlib.trace import mutter 
 
28
import warnings
 
29
 
 
30
 
 
31
from bzrlib import (
 
32
    errors,
 
33
    osutils,
 
34
    trace,
 
35
    ui,
 
36
    )
 
37
from bzrlib.trace import mutter
 
38
from bzrlib.symbol_versioning import (
 
39
    deprecated_in,
 
40
    deprecated_method,
 
41
    )
47
42
 
48
43
 
49
44
def _supports_progress(f):
50
 
    if not hasattr(f, 'isatty'):
 
45
    """Detect if we can use pretty progress bars on the output stream f.
 
46
 
 
47
    If this returns true we expect that a human may be looking at that
 
48
    output, and that we can repaint a line to update it.
 
49
    """
 
50
    isatty = getattr(f, 'isatty', None)
 
51
    if isatty is None:
51
52
        return False
52
 
    if not f.isatty():
 
53
    if not isatty():
53
54
        return False
54
55
    if os.environ.get('TERM') == 'dumb':
55
56
        # e.g. emacs compile window
57
58
    return True
58
59
 
59
60
 
60
 
 
61
 
def ProgressBar(to_file=sys.stderr, **kwargs):
 
61
class ProgressTask(object):
 
62
    """Model component of a progress indicator.
 
63
 
 
64
    Most code that needs to indicate progress should update one of these,
 
65
    and it will in turn update the display, if one is present.
 
66
 
 
67
    Code updating the task may also set fields as hints about how to display
 
68
    it: show_pct, show_spinner, show_eta, show_count, show_bar.  UIs
 
69
    will not necessarily respect all these fields.
 
70
    """
 
71
 
 
72
    def __init__(self, parent_task=None, ui_factory=None):
 
73
        """Construct a new progress task.
 
74
 
 
75
        Normally you should not call this directly but rather through
 
76
        `ui_factory.nested_progress_bar`.
 
77
        """
 
78
        self._parent_task = parent_task
 
79
        self._last_update = 0
 
80
        self.total_cnt = None
 
81
        self.current_cnt = None
 
82
        self.msg = ''
 
83
        self.ui_factory = ui_factory
 
84
        self.show_pct = False
 
85
        self.show_spinner = True
 
86
        self.show_eta = False,
 
87
        self.show_count = True
 
88
        self.show_bar = True
 
89
 
 
90
    def __repr__(self):
 
91
        return '%s(%r/%r, msg=%r)' % (
 
92
            self.__class__.__name__,
 
93
            self.current_cnt,
 
94
            self.total_cnt,
 
95
            self.msg)
 
96
 
 
97
    def update(self, msg, current_cnt=None, total_cnt=None):
 
98
        self.msg = msg
 
99
        self.current_cnt = current_cnt
 
100
        if total_cnt:
 
101
            self.total_cnt = total_cnt
 
102
        self.ui_factory._progress_updated(self)
 
103
 
 
104
    def tick(self):
 
105
        self.update(self.msg)
 
106
 
 
107
    def finished(self):
 
108
        self.ui_factory._progress_finished(self)
 
109
 
 
110
    def make_sub_task(self):
 
111
        return ProgressTask(self, self.ui_factory)
 
112
 
 
113
    def _overall_completion_fraction(self, child_fraction=0.0):
 
114
        """Return fractional completion of this task and its parents
 
115
 
 
116
        Returns None if no completion can be computed."""
 
117
        if self.current_cnt is not None and self.total_cnt:
 
118
            own_fraction = (float(self.current_cnt) + child_fraction) / self.total_cnt
 
119
        else:
 
120
            # if this task has no estimation, it just passes on directly
 
121
            # whatever the child has measured...
 
122
            own_fraction = child_fraction
 
123
        if self._parent_task is None:
 
124
            return own_fraction
 
125
        else:
 
126
            if own_fraction is None:
 
127
                own_fraction = 0.0
 
128
            return self._parent_task._overall_completion_fraction(own_fraction)
 
129
 
 
130
    def note(self, fmt_string, *args):
 
131
        """Record a note without disrupting the progress bar."""
 
132
        # XXX: shouldn't be here; put it in mutter or the ui instead
 
133
        if args:
 
134
            self.ui_factory.note(fmt_string % args)
 
135
        else:
 
136
            self.ui_factory.note(fmt_string)
 
137
 
 
138
    def clear(self):
 
139
        # XXX: shouldn't be here; put it in mutter or the ui instead
 
140
        self.ui_factory.clear_term()
 
141
 
 
142
 
 
143
def ProgressBar(to_file=None, **kwargs):
62
144
    """Abstract factory"""
63
 
    if _supports_progress(to_file):
64
 
        return TTYProgressBar(to_file=to_file, **kwargs)
 
145
    if to_file is None:
 
146
        to_file = sys.stderr
 
147
    requested_bar_type = os.environ.get('BZR_PROGRESS_BAR')
 
148
    # An value of '' or not set reverts to standard processing
 
149
    if requested_bar_type in (None, ''):
 
150
        if _supports_progress(to_file):
 
151
            return TTYProgressBar(to_file=to_file, **kwargs)
 
152
        else:
 
153
            return DummyProgress(to_file=to_file, **kwargs)
65
154
    else:
66
 
        return DotsProgressBar(to_file=to_file, **kwargs)
67
 
    
68
 
 
 
155
        # Minor sanitation to prevent spurious errors
 
156
        requested_bar_type = requested_bar_type.lower().strip()
 
157
        # TODO: jam 20060710 Arguably we shouldn't raise an exception
 
158
        #       but should instead just disable progress bars if we
 
159
        #       don't recognize the type
 
160
        if requested_bar_type not in _progress_bar_types:
 
161
            raise errors.InvalidProgressBarType(requested_bar_type,
 
162
                                                _progress_bar_types.keys())
 
163
        return _progress_bar_types[requested_bar_type](to_file=to_file, **kwargs)
 
164
 
 
165
 
69
166
class ProgressBarStack(object):
70
 
    """A stack of progress bars."""
71
 
 
 
167
    """A stack of progress bars.
 
168
 
 
169
    This class is deprecated: instead, ask the ui factory for a new progress
 
170
    task and finish it when it's done.
 
171
    """
 
172
 
 
173
    @deprecated_method(deprecated_in((1, 12, 0)))
72
174
    def __init__(self,
73
 
                 to_file=sys.stderr,
 
175
                 to_file=None,
74
176
                 show_pct=False,
75
177
                 show_spinner=True,
76
178
                 show_eta=False,
77
179
                 show_bar=True,
78
180
                 show_count=True,
79
 
                 to_messages_file=sys.stdout,
 
181
                 to_messages_file=None,
80
182
                 klass=None):
81
183
        """Setup the stack with the parameters the progress bars should have."""
 
184
        if to_file is None:
 
185
            to_file = sys.stderr
 
186
        if to_messages_file is None:
 
187
            to_messages_file = sys.stdout
82
188
        self._to_file = to_file
83
189
        self._show_pct = show_pct
84
190
        self._show_spinner = show_spinner
87
193
        self._show_count = show_count
88
194
        self._to_messages_file = to_messages_file
89
195
        self._stack = []
90
 
        self._klass = klass or TTYProgressBar
 
196
        self._klass = klass or ProgressBar
91
197
 
92
198
    def top(self):
93
199
        if len(self._stack) != 0:
121
227
    def return_pb(self, bar):
122
228
        """Return bar after its been used."""
123
229
        if bar is not self._stack[-1]:
124
 
            raise errors.MissingProgressBarFinish()
125
 
        self._stack.pop()
126
 
 
127
 
 
 
230
            warnings.warn("%r is not currently active" % (bar,))
 
231
        else:
 
232
            self._stack.pop()
 
233
 
 
234
 
128
235
class _BaseProgressBar(object):
129
236
 
130
237
    def __init__(self,
131
 
                 to_file=sys.stderr,
 
238
                 to_file=None,
132
239
                 show_pct=False,
133
240
                 show_spinner=False,
134
 
                 show_eta=True,
 
241
                 show_eta=False,
135
242
                 show_bar=True,
136
243
                 show_count=True,
137
 
                 to_messages_file=sys.stdout,
 
244
                 to_messages_file=None,
138
245
                 _stack=None):
139
246
        object.__init__(self)
 
247
        if to_file is None:
 
248
            to_file = sys.stderr
 
249
        if to_messages_file is None:
 
250
            to_messages_file = sys.stdout
140
251
        self.to_file = to_file
141
252
        self.to_messages_file = to_messages_file
142
253
        self.last_msg = None
150
261
        self._stack = _stack
151
262
        # seed throttler
152
263
        self.MIN_PAUSE = 0.1 # seconds
153
 
        now = time.clock()
 
264
        now = time.time()
154
265
        # starting now
155
266
        self.start_time = now
156
267
        # next update should not throttle
159
270
    def finished(self):
160
271
        """Return this bar to its progress stack."""
161
272
        self.clear()
162
 
        assert self._stack is not None
163
273
        self._stack.return_pb(self)
164
274
 
165
275
    def note(self, fmt_string, *args, **kwargs):
177
287
 
178
288
    This can be used as the default argument for methods that
179
289
    take an optional progress indicator."""
 
290
 
180
291
    def tick(self):
181
292
        pass
182
293
 
188
299
 
189
300
    def clear(self):
190
301
        pass
191
 
        
 
302
 
192
303
    def note(self, fmt_string, *args, **kwargs):
193
304
        """See _BaseProgressBar.note()."""
194
305
 
195
306
    def child_progress(self, **kwargs):
196
307
        return DummyProgress(**kwargs)
197
308
 
 
309
 
198
310
class DotsProgressBar(_BaseProgressBar):
199
311
 
200
312
    def __init__(self, **kwargs):
201
313
        _BaseProgressBar.__init__(self, **kwargs)
202
314
        self.last_msg = None
203
315
        self.need_nl = False
204
 
        
 
316
 
205
317
    def tick(self):
206
318
        self.update()
207
 
        
 
319
 
208
320
    def update(self, msg=None, current_cnt=None, total_cnt=None):
209
321
        if msg and msg != self.last_msg:
210
322
            if self.need_nl:
211
323
                self.to_file.write('\n')
212
 
            
213
324
            self.to_file.write(msg + ': ')
214
325
            self.last_msg = msg
215
326
        self.need_nl = True
216
327
        self.to_file.write('.')
217
 
        
 
328
 
218
329
    def clear(self):
219
330
        if self.need_nl:
220
331
            self.to_file.write('\n')
221
 
        
 
332
        self.need_nl = False
 
333
 
222
334
    def child_update(self, message, current, total):
223
335
        self.tick()
224
 
    
 
336
 
 
337
 
 
338
 
 
339
 
225
340
class TTYProgressBar(_BaseProgressBar):
226
341
    """Progress bar display object.
227
342
 
250
365
        _BaseProgressBar.__init__(self, **kwargs)
251
366
        self.spin_pos = 0
252
367
        self.width = terminal_width()
253
 
        self.start_time = None
254
 
        self.last_updates = deque()
 
368
        self.last_updates = []
 
369
        self._max_last_updates = 10
255
370
        self.child_fraction = 0
256
 
    
 
371
        self._have_output = False
257
372
 
258
 
    def throttle(self):
 
373
    def throttle(self, old_msg):
259
374
        """Return True if the bar was updated too recently"""
260
375
        # time.time consistently takes 40/4000 ms = 0.01 ms.
261
 
        # but every single update to the pb invokes it.
262
 
        # so we use time.clock which takes 20/4000 ms = 0.005ms
263
 
        # on the downside, time.clock() appears to have approximately
264
 
        # 10ms granularity, so we treat a zero-time change as 'throttled.'
265
 
        
266
 
        now = time.clock()
 
376
        # time.clock() is faster, but gives us CPU time, not wall-clock time
 
377
        now = time.time()
 
378
        if self.start_time is not None and (now - self.start_time) < 1:
 
379
            return True
 
380
        if old_msg != self.last_msg:
 
381
            return False
267
382
        interval = now - self.last_update
268
383
        # if interval > 0
269
384
        if interval < self.MIN_PAUSE:
270
385
            return True
271
386
 
272
387
        self.last_updates.append(now - self.last_update)
 
388
        # Don't let the queue grow without bound
 
389
        self.last_updates = self.last_updates[-self._max_last_updates:]
273
390
        self.last_update = now
274
391
        return False
275
 
        
276
392
 
277
393
    def tick(self):
278
 
        self.update(self.last_msg, self.last_cnt, self.last_total, 
 
394
        self.update(self.last_msg, self.last_cnt, self.last_total,
279
395
                    self.child_fraction)
280
396
 
281
397
    def child_update(self, message, current, total):
285
401
                pass
286
402
            elif self.last_cnt + child_fraction <= self.last_total:
287
403
                self.child_fraction = child_fraction
288
 
            else:
289
 
                mutter('not updating child fraction')
290
404
        if self.last_msg is None:
291
405
            self.last_msg = ''
292
406
        self.tick()
293
407
 
 
408
    def update(self, msg, current_cnt=None, total_cnt=None,
 
409
            child_fraction=0):
 
410
        """Update and redraw progress bar.
 
411
        """
 
412
        if msg is None:
 
413
            msg = self.last_msg
294
414
 
295
 
    def update(self, msg, current_cnt=None, total_cnt=None, 
296
 
               child_fraction=0):
297
 
        """Update and redraw progress bar."""
 
415
        if total_cnt is None:
 
416
            total_cnt = self.last_total
298
417
 
299
418
        if current_cnt < 0:
300
419
            current_cnt = 0
301
 
            
 
420
 
302
421
        if current_cnt > total_cnt:
303
422
            total_cnt = current_cnt
304
 
        
305
 
        ## # optional corner case optimisation 
 
423
 
 
424
        ## # optional corner case optimisation
306
425
        ## # currently does not seem to fire so costs more than saved.
307
426
        ## # trivial optimal case:
308
427
        ## # NB if callers are doing a clear and restore with
315
434
        ##     self.child_fraction == child_fraction):
316
435
        ##     return
317
436
 
 
437
        if msg is None:
 
438
            msg = ''
 
439
 
318
440
        old_msg = self.last_msg
319
441
        # save these for the tick() function
320
442
        self.last_msg = msg
322
444
        self.last_total = total_cnt
323
445
        self.child_fraction = child_fraction
324
446
 
325
 
        # each function call takes 20ms/4000 = 0.005 ms, 
 
447
        # each function call takes 20ms/4000 = 0.005 ms,
326
448
        # but multiple that by 4000 calls -> starts to cost.
327
449
        # so anything to make this function call faster
328
450
        # will improve base 'diff' time by up to 0.1 seconds.
329
 
        if old_msg == self.last_msg and self.throttle():
 
451
        if self.throttle(old_msg):
330
452
            return
331
453
 
332
454
        if self.show_eta and self.start_time and self.last_total:
333
 
            eta = get_eta(self.start_time, self.last_cnt + self.child_fraction, 
 
455
            eta = get_eta(self.start_time, self.last_cnt + self.child_fraction,
334
456
                    self.last_total, last_updates = self.last_updates)
335
457
            eta_str = " " + str_tdelta(eta)
336
458
        else:
337
459
            eta_str = ""
338
460
 
339
461
        if self.show_spinner:
340
 
            spin_str = self.SPIN_CHARS[self.spin_pos % 4] + ' '            
 
462
            spin_str = self.SPIN_CHARS[self.spin_pos % 4] + ' '
341
463
        else:
342
464
            spin_str = ''
343
465
 
360
482
            # make both fields the same size
361
483
            t = '%i' % (self.last_total)
362
484
            c = '%*i' % (len(t), self.last_cnt)
363
 
            count_str = ' ' + c + '/' + t 
 
485
            count_str = ' ' + c + '/' + t
364
486
 
365
487
        if self.show_bar:
366
488
            # progress bar, if present, soaks up all remaining space
369
491
 
370
492
            if self.last_total:
371
493
                # number of markers highlighted in bar
372
 
                markers = int(round(float(cols) * 
 
494
                markers = int(round(float(cols) *
373
495
                              (self.last_cnt + self.child_fraction) / self.last_total))
374
496
                bar_str = '[' + ('=' * markers).ljust(cols) + '] '
375
497
            elif False:
377
499
                # so just show an expanded spinning thingy
378
500
                m = self.spin_pos % cols
379
501
                ms = (' ' * m + '*').ljust(cols)
380
 
                
 
502
 
381
503
                bar_str = '[' + ms + '] '
382
504
            else:
383
505
                bar_str = ''
384
506
        else:
385
507
            bar_str = ''
386
508
 
387
 
        m = spin_str + bar_str + self.last_msg + count_str + pct_str + eta_str
388
 
 
389
 
        assert len(m) < self.width
390
 
        self.to_file.write('\r' + m.ljust(self.width - 1))
391
 
        #self.to_file.flush()
392
 
            
393
 
    def clear(self):        
394
 
        self.to_file.write('\r%s\r' % (' ' * (self.width - 1)))
395
 
        #self.to_file.flush()        
 
509
        m = spin_str + bar_str + self.last_msg + count_str \
 
510
            + pct_str + eta_str
 
511
        self.to_file.write('\r%-*.*s' % (self.width - 1, self.width - 1, m))
 
512
        self._have_output = True
 
513
        #self.to_file.flush()
 
514
 
 
515
    def clear(self):
 
516
        if self._have_output:
 
517
            self.to_file.write('\r%s\r' % (' ' * (self.width - 1)))
 
518
        self._have_output = False
 
519
        #self.to_file.flush()
 
520
 
 
521
 
396
522
 
397
523
 
398
524
class ChildProgress(_BaseProgressBar):
399
525
    """A progress indicator that pushes its data to the parent"""
 
526
 
400
527
    def __init__(self, _stack, **kwargs):
401
528
        _BaseProgressBar.__init__(self, _stack=_stack, **kwargs)
402
529
        self.parent = _stack.top()
407
534
 
408
535
    def update(self, msg, current_cnt=None, total_cnt=None):
409
536
        self.current = current_cnt
410
 
        self.total = total_cnt
 
537
        if total_cnt is not None:
 
538
            self.total = total_cnt
411
539
        self.message = msg
412
540
        self.child_fraction = 0
413
541
        self.tick()
436
564
    def note(self, *args, **kwargs):
437
565
        self.parent.note(*args, **kwargs)
438
566
 
439
 
 
 
567
 
 
568
class InstrumentedProgress(TTYProgressBar):
 
569
    """TTYProgress variant that tracks outcomes"""
 
570
 
 
571
    def __init__(self, *args, **kwargs):
 
572
        self.always_throttled = True
 
573
        self.never_throttle = False
 
574
        TTYProgressBar.__init__(self, *args, **kwargs)
 
575
 
 
576
    def throttle(self, old_message):
 
577
        if self.never_throttle:
 
578
            result =  False
 
579
        else:
 
580
            result = TTYProgressBar.throttle(self, old_message)
 
581
        if result is False:
 
582
            self.always_throttled = False
 
583
 
 
584
 
440
585
def str_tdelta(delt):
441
586
    if delt is None:
442
587
        return "-:--:--"
459
604
    if current > total:
460
605
        return None                     # wtf?
461
606
 
462
 
    elapsed = time.clock() - start_time
 
607
    elapsed = time.time() - start_time
463
608
 
464
609
    if elapsed < 2.0:                   # not enough time to estimate
465
610
        return None
466
 
    
 
611
 
467
612
    total_duration = float(elapsed) * float(total) / float(current)
468
613
 
469
 
    assert total_duration >= elapsed
470
 
 
471
614
    if last_updates and len(last_updates) >= n_recent:
472
 
        while len(last_updates) > n_recent:
473
 
            last_updates.popleft()
474
615
        avg = sum(last_updates) / float(len(last_updates))
475
616
        time_left = avg * (total - current)
476
617
 
496
637
            self.cur_phase = 0
497
638
        else:
498
639
            self.cur_phase += 1
499
 
        assert self.cur_phase < self.total 
500
640
        self.pb.update(self.message, self.cur_phase, self.total)
501
641
 
502
642
 
503
 
def run_tests():
504
 
    import doctest
505
 
    result = doctest.testmod()
506
 
    if result[1] > 0:
507
 
        if result[0] == 0:
508
 
            print "All tests passed"
509
 
    else:
510
 
        print "No tests to run"
511
 
 
512
 
 
513
 
def demo():
514
 
    sleep = time.sleep
515
 
    
516
 
    print 'dumb-terminal test:'
517
 
    pb = DotsProgressBar()
518
 
    for i in range(100):
519
 
        pb.update('Leoparden', i, 99)
520
 
        sleep(0.1)
521
 
    sleep(1.5)
522
 
    pb.clear()
523
 
    sleep(1.5)
524
 
    
525
 
    print 'smart-terminal test:'
526
 
    pb = ProgressBar(show_pct=True, show_bar=True, show_spinner=False)
527
 
    for i in range(100):
528
 
        pb.update('Elephanten', i, 99)
529
 
        sleep(0.1)
530
 
    sleep(2)
531
 
    pb.clear()
532
 
    sleep(1)
533
 
 
534
 
    print 'done!'
535
 
 
536
 
if __name__ == "__main__":
537
 
    demo()
 
643
_progress_bar_types = {}
 
644
_progress_bar_types['dummy'] = DummyProgress
 
645
_progress_bar_types['none'] = DummyProgress
 
646
_progress_bar_types['tty'] = TTYProgressBar
 
647
_progress_bar_types['dots'] = DotsProgressBar