← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/progress.py

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