~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/progress.py

Don't encode unicode messages to UTF-8 in mutter() (the stream writer does it).

Use a codec wrapped log file in tests to match the real environment.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
# Copyright (C) 2005 Aaron Bentley <aaron.bentley@utoronto.ca>
2
 
# Copyright (C) 2005, 2006 Canonical Ltd
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
 
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
17
 
18
18
 
19
19
"""Simple text-mode progress indicator.
35
35
# TODO: Optionally show elapsed time instead/as well as ETA; nicer
36
36
# when the rate is unpredictable
37
37
 
 
38
 
38
39
import sys
39
40
import time
40
41
import os
41
 
 
42
 
from bzrlib.lazy_import import lazy_import
43
 
lazy_import(globals(), """
44
 
from bzrlib import (
45
 
    errors,
46
 
    )
47
 
""")
48
 
 
49
 
from bzrlib.trace import mutter
 
42
from collections import deque
50
43
 
51
44
 
52
45
def _supports_progress(f):
53
 
    isatty = getattr(f, 'isatty', None)
54
 
    if isatty is None:
 
46
    if not hasattr(f, 'isatty'):
55
47
        return False
56
 
    if not isatty():
 
48
    if not f.isatty():
57
49
        return False
58
50
    if os.environ.get('TERM') == 'dumb':
59
51
        # e.g. emacs compile window
61
53
    return True
62
54
 
63
55
 
64
 
_progress_bar_types = {}
65
 
 
66
 
 
67
 
def ProgressBar(to_file=None, **kwargs):
 
56
 
 
57
def ProgressBar(to_file=sys.stderr, **kwargs):
68
58
    """Abstract factory"""
69
 
    if to_file is None:
70
 
        to_file = sys.stderr
71
 
    requested_bar_type = os.environ.get('BZR_PROGRESS_BAR')
72
 
    # An value of '' or not set reverts to standard processing
73
 
    if requested_bar_type in (None, ''):
74
 
        if _supports_progress(to_file):
75
 
            return TTYProgressBar(to_file=to_file, **kwargs)
76
 
        else:
77
 
            return DotsProgressBar(to_file=to_file, **kwargs)
 
59
    if _supports_progress(to_file):
 
60
        return TTYProgressBar(to_file=to_file, **kwargs)
78
61
    else:
79
 
        # Minor sanitation to prevent spurious errors
80
 
        requested_bar_type = requested_bar_type.lower().strip()
81
 
        # TODO: jam 20060710 Arguably we shouldn't raise an exception
82
 
        #       but should instead just disable progress bars if we
83
 
        #       don't recognize the type
84
 
        if requested_bar_type not in _progress_bar_types:
85
 
            raise errors.InvalidProgressBarType(requested_bar_type,
86
 
                                                _progress_bar_types.keys())
87
 
        return _progress_bar_types[requested_bar_type](to_file=to_file, **kwargs)
88
 
 
89
 
 
90
 
class ProgressBarStack(object):
91
 
    """A stack of progress bars."""
92
 
 
93
 
    def __init__(self,
94
 
                 to_file=None,
95
 
                 show_pct=False,
96
 
                 show_spinner=True,
97
 
                 show_eta=False,
98
 
                 show_bar=True,
99
 
                 show_count=True,
100
 
                 to_messages_file=None,
101
 
                 klass=None):
102
 
        """Setup the stack with the parameters the progress bars should have."""
103
 
        if to_file is None:
104
 
            to_file = sys.stderr
105
 
        if to_messages_file is None:
106
 
            to_messages_file = sys.stdout
107
 
        self._to_file = to_file
108
 
        self._show_pct = show_pct
109
 
        self._show_spinner = show_spinner
110
 
        self._show_eta = show_eta
111
 
        self._show_bar = show_bar
112
 
        self._show_count = show_count
113
 
        self._to_messages_file = to_messages_file
114
 
        self._stack = []
115
 
        self._klass = klass or ProgressBar
116
 
 
117
 
    def top(self):
118
 
        if len(self._stack) != 0:
119
 
            return self._stack[-1]
120
 
        else:
121
 
            return None
122
 
 
123
 
    def bottom(self):
124
 
        if len(self._stack) != 0:
125
 
            return self._stack[0]
126
 
        else:
127
 
            return None
128
 
 
129
 
    def get_nested(self):
130
 
        """Return a nested progress bar."""
131
 
        if len(self._stack) == 0:
132
 
            func = self._klass
133
 
        else:
134
 
            func = self.top().child_progress
135
 
        new_bar = func(to_file=self._to_file,
136
 
                       show_pct=self._show_pct,
137
 
                       show_spinner=self._show_spinner,
138
 
                       show_eta=self._show_eta,
139
 
                       show_bar=self._show_bar,
140
 
                       show_count=self._show_count,
141
 
                       to_messages_file=self._to_messages_file,
142
 
                       _stack=self)
143
 
        self._stack.append(new_bar)
144
 
        return new_bar
145
 
 
146
 
    def return_pb(self, bar):
147
 
        """Return bar after its been used."""
148
 
        if bar is not self._stack[-1]:
149
 
            raise errors.MissingProgressBarFinish()
150
 
        self._stack.pop()
151
 
 
152
 
 
 
62
        return DotsProgressBar(to_file=to_file, **kwargs)
 
63
    
 
64
    
153
65
class _BaseProgressBar(object):
154
 
 
155
66
    def __init__(self,
156
 
                 to_file=None,
 
67
                 to_file=sys.stderr,
157
68
                 show_pct=False,
158
69
                 show_spinner=False,
159
 
                 show_eta=False,
 
70
                 show_eta=True,
160
71
                 show_bar=True,
161
 
                 show_count=True,
162
 
                 to_messages_file=None,
163
 
                 _stack=None):
 
72
                 show_count=True):
164
73
        object.__init__(self)
165
 
        if to_file is None:
166
 
            to_file = sys.stderr
167
 
        if to_messages_file is None:
168
 
            to_messages_file = sys.stdout
169
74
        self.to_file = to_file
170
 
        self.to_messages_file = to_messages_file
 
75
 
171
76
        self.last_msg = None
172
77
        self.last_cnt = None
173
78
        self.last_total = None
176
81
        self.show_eta = show_eta
177
82
        self.show_bar = show_bar
178
83
        self.show_count = show_count
179
 
        self._stack = _stack
180
 
        # seed throttler
181
 
        self.MIN_PAUSE = 0.1 # seconds
182
 
        now = time.time()
183
 
        # starting now
184
 
        self.start_time = now
185
 
        # next update should not throttle
186
 
        self.last_update = now - self.MIN_PAUSE - 1
187
 
 
188
 
    def finished(self):
189
 
        """Return this bar to its progress stack."""
190
 
        self.clear()
191
 
        assert self._stack is not None
192
 
        self._stack.return_pb(self)
193
 
 
194
 
    def note(self, fmt_string, *args, **kwargs):
195
 
        """Record a note without disrupting the progress bar."""
196
 
        self.clear()
197
 
        self.to_messages_file.write(fmt_string % args)
198
 
        self.to_messages_file.write('\n')
199
 
 
200
 
    def child_progress(self, **kwargs):
201
 
        return ChildProgress(**kwargs)
 
84
 
202
85
 
203
86
 
204
87
class DummyProgress(_BaseProgressBar):
212
95
    def update(self, msg=None, current=None, total=None):
213
96
        pass
214
97
 
215
 
    def child_update(self, message, current, total):
216
 
        pass
217
 
 
218
98
    def clear(self):
219
99
        pass
220
100
        
221
 
    def note(self, fmt_string, *args, **kwargs):
222
 
        """See _BaseProgressBar.note()."""
223
 
 
224
 
    def child_progress(self, **kwargs):
225
 
        return DummyProgress(**kwargs)
226
 
 
227
 
 
228
 
_progress_bar_types['dummy'] = DummyProgress
229
 
_progress_bar_types['none'] = DummyProgress
230
 
 
231
 
 
 
101
    
232
102
class DotsProgressBar(_BaseProgressBar):
233
 
 
234
103
    def __init__(self, **kwargs):
235
104
        _BaseProgressBar.__init__(self, **kwargs)
236
105
        self.last_msg = None
243
112
        if msg and msg != self.last_msg:
244
113
            if self.need_nl:
245
114
                self.to_file.write('\n')
 
115
            
246
116
            self.to_file.write(msg + ': ')
247
117
            self.last_msg = msg
248
118
        self.need_nl = True
251
121
    def clear(self):
252
122
        if self.need_nl:
253
123
            self.to_file.write('\n')
254
 
        self.need_nl = False
255
124
        
256
 
    def child_update(self, message, current, total):
257
 
        self.tick()
258
 
 
259
 
 
260
 
_progress_bar_types['dots'] = DotsProgressBar
261
 
 
262
125
    
263
126
class TTYProgressBar(_BaseProgressBar):
264
127
    """Progress bar display object.
281
144
    The output file should be in line-buffered or unbuffered mode.
282
145
    """
283
146
    SPIN_CHARS = r'/-\|'
 
147
    MIN_PAUSE = 0.1 # seconds
284
148
 
285
149
 
286
150
    def __init__(self, **kwargs):
288
152
        _BaseProgressBar.__init__(self, **kwargs)
289
153
        self.spin_pos = 0
290
154
        self.width = terminal_width()
291
 
        self.last_updates = []
292
 
        self._max_last_updates = 10
293
 
        self.child_fraction = 0
294
 
        self._have_output = False
 
155
        self.start_time = None
 
156
        self.last_update = None
 
157
        self.last_updates = deque()
295
158
    
296
159
 
297
 
    def throttle(self, old_msg):
 
160
    def throttle(self):
298
161
        """Return True if the bar was updated too recently"""
299
 
        # time.time consistently takes 40/4000 ms = 0.01 ms.
300
 
        # time.clock() is faster, but gives us CPU time, not wall-clock time
301
162
        now = time.time()
302
 
        if self.start_time is not None and (now - self.start_time) < 1:
303
 
            return True
304
 
        if old_msg != self.last_msg:
 
163
        if self.start_time is None:
 
164
            self.start_time = self.last_update = now
305
165
            return False
306
 
        interval = now - self.last_update
307
 
        # if interval > 0
308
 
        if interval < self.MIN_PAUSE:
309
 
            return True
 
166
        else:
 
167
            interval = now - self.last_update
 
168
            if interval > 0 and interval < self.MIN_PAUSE:
 
169
                return True
310
170
 
311
171
        self.last_updates.append(now - self.last_update)
312
 
        # Don't let the queue grow without bound
313
 
        self.last_updates = self.last_updates[-self._max_last_updates:]
314
172
        self.last_update = now
315
173
        return False
316
174
        
 
175
 
317
176
    def tick(self):
318
 
        self.update(self.last_msg, self.last_cnt, self.last_total, 
319
 
                    self.child_fraction)
320
 
 
321
 
    def child_update(self, message, current, total):
322
 
        if current is not None and total != 0:
323
 
            child_fraction = float(current) / total
324
 
            if self.last_cnt is None:
325
 
                pass
326
 
            elif self.last_cnt + child_fraction <= self.last_total:
327
 
                self.child_fraction = child_fraction
328
 
            else:
329
 
                mutter('not updating child fraction')
330
 
        if self.last_msg is None:
331
 
            self.last_msg = ''
332
 
        self.tick()
333
 
 
334
 
    def update(self, msg, current_cnt=None, total_cnt=None, 
335
 
               child_fraction=0):
 
177
        self.update(self.last_msg, self.last_cnt, self.last_total)
 
178
                 
 
179
 
 
180
 
 
181
    def update(self, msg, current_cnt=None, total_cnt=None):
336
182
        """Update and redraw progress bar."""
337
 
        if msg is None:
338
 
            msg = self.last_msg
339
 
 
340
 
        if total_cnt is None:
341
 
            total_cnt = self.last_total
342
183
 
343
184
        if current_cnt < 0:
344
185
            current_cnt = 0
345
186
            
346
187
        if current_cnt > total_cnt:
347
188
            total_cnt = current_cnt
348
 
        
349
 
        ## # optional corner case optimisation 
350
 
        ## # currently does not seem to fire so costs more than saved.
351
 
        ## # trivial optimal case:
352
 
        ## # NB if callers are doing a clear and restore with
353
 
        ## # the saved values, this will prevent that:
354
 
        ## # in that case add a restore method that calls
355
 
        ## # _do_update or some such
356
 
        ## if (self.last_msg == msg and
357
 
        ##     self.last_cnt == current_cnt and
358
 
        ##     self.last_total == total_cnt and
359
 
        ##     self.child_fraction == child_fraction):
360
 
        ##     return
361
189
 
362
 
        old_msg = self.last_msg
363
190
        # save these for the tick() function
364
191
        self.last_msg = msg
365
192
        self.last_cnt = current_cnt
366
193
        self.last_total = total_cnt
367
 
        self.child_fraction = child_fraction
368
 
 
369
 
        # each function call takes 20ms/4000 = 0.005 ms, 
370
 
        # but multiple that by 4000 calls -> starts to cost.
371
 
        # so anything to make this function call faster
372
 
        # will improve base 'diff' time by up to 0.1 seconds.
373
 
        if self.throttle(old_msg):
374
 
            return
375
 
 
376
 
        if self.show_eta and self.start_time and self.last_total:
377
 
            eta = get_eta(self.start_time, self.last_cnt + self.child_fraction, 
378
 
                    self.last_total, last_updates = self.last_updates)
 
194
            
 
195
        if self.throttle():
 
196
            return 
 
197
        
 
198
        if self.show_eta and self.start_time and total_cnt:
 
199
            eta = get_eta(self.start_time, current_cnt, total_cnt,
 
200
                    last_updates = self.last_updates)
379
201
            eta_str = " " + str_tdelta(eta)
380
202
        else:
381
203
            eta_str = ""
388
210
        # always update this; it's also used for the bar
389
211
        self.spin_pos += 1
390
212
 
391
 
        if self.show_pct and self.last_total and self.last_cnt:
392
 
            pct = 100.0 * ((self.last_cnt + self.child_fraction) / self.last_total)
 
213
        if self.show_pct and total_cnt and current_cnt:
 
214
            pct = 100.0 * current_cnt / total_cnt
393
215
            pct_str = ' (%5.1f%%)' % pct
394
216
        else:
395
217
            pct_str = ''
396
218
 
397
219
        if not self.show_count:
398
220
            count_str = ''
399
 
        elif self.last_cnt is None:
 
221
        elif current_cnt is None:
400
222
            count_str = ''
401
 
        elif self.last_total is None:
402
 
            count_str = ' %i' % (self.last_cnt)
 
223
        elif total_cnt is None:
 
224
            count_str = ' %i' % (current_cnt)
403
225
        else:
404
226
            # make both fields the same size
405
 
            t = '%i' % (self.last_total)
406
 
            c = '%*i' % (len(t), self.last_cnt)
 
227
            t = '%i' % (total_cnt)
 
228
            c = '%*i' % (len(t), current_cnt)
407
229
            count_str = ' ' + c + '/' + t 
408
230
 
409
231
        if self.show_bar:
410
232
            # progress bar, if present, soaks up all remaining space
411
 
            cols = self.width - 1 - len(self.last_msg) - len(spin_str) - len(pct_str) \
 
233
            cols = self.width - 1 - len(msg) - len(spin_str) - len(pct_str) \
412
234
                   - len(eta_str) - len(count_str) - 3
413
235
 
414
 
            if self.last_total:
 
236
            if total_cnt:
415
237
                # number of markers highlighted in bar
416
 
                markers = int(round(float(cols) * 
417
 
                              (self.last_cnt + self.child_fraction) / self.last_total))
 
238
                markers = int(round(float(cols) * current_cnt / total_cnt))
418
239
                bar_str = '[' + ('=' * markers).ljust(cols) + '] '
419
240
            elif False:
420
241
                # don't know total, so can't show completion.
428
249
        else:
429
250
            bar_str = ''
430
251
 
431
 
        m = spin_str + bar_str + self.last_msg + count_str + pct_str + eta_str
432
 
        self.to_file.write('\r%-*.*s' % (self.width - 1, self.width - 1, m))
433
 
        self._have_output = True
 
252
        m = spin_str + bar_str + msg + count_str + pct_str + eta_str
 
253
 
 
254
        assert len(m) < self.width
 
255
        self.to_file.write('\r' + m.ljust(self.width - 1))
434
256
        #self.to_file.flush()
435
257
            
 
258
 
436
259
    def clear(self):        
437
 
        if self._have_output:
438
 
            self.to_file.write('\r%s\r' % (' ' * (self.width - 1)))
439
 
        self._have_output = False
 
260
        self.to_file.write('\r%s\r' % (' ' * (self.width - 1)))
440
261
        #self.to_file.flush()        
441
 
 
442
 
 
443
 
_progress_bar_types['tty'] = TTYProgressBar
444
 
 
445
 
 
446
 
class ChildProgress(_BaseProgressBar):
447
 
    """A progress indicator that pushes its data to the parent"""
448
 
 
449
 
    def __init__(self, _stack, **kwargs):
450
 
        _BaseProgressBar.__init__(self, _stack=_stack, **kwargs)
451
 
        self.parent = _stack.top()
452
 
        self.current = None
453
 
        self.total = None
454
 
        self.child_fraction = 0
455
 
        self.message = None
456
 
 
457
 
    def update(self, msg, current_cnt=None, total_cnt=None):
458
 
        self.current = current_cnt
459
 
        self.total = total_cnt
460
 
        self.message = msg
461
 
        self.child_fraction = 0
462
 
        self.tick()
463
 
 
464
 
    def child_update(self, message, current, total):
465
 
        if current is None or total == 0:
466
 
            self.child_fraction = 0
467
 
        else:
468
 
            self.child_fraction = float(current) / total
469
 
        self.tick()
470
 
 
471
 
    def tick(self):
472
 
        if self.current is None:
473
 
            count = None
474
 
        else:
475
 
            count = self.current+self.child_fraction
476
 
            if count > self.total:
477
 
                if __debug__:
478
 
                    mutter('clamping count of %d to %d' % (count, self.total))
479
 
                count = self.total
480
 
        self.parent.child_update(self.message, count, self.total)
481
 
 
482
 
    def clear(self):
483
 
        pass
484
 
 
485
 
    def note(self, *args, **kwargs):
486
 
        self.parent.note(*args, **kwargs)
487
 
 
488
 
 
 
262
    
 
263
 
 
264
        
489
265
def str_tdelta(delt):
490
266
    if delt is None:
491
267
        return "-:--:--"
518
294
    assert total_duration >= elapsed
519
295
 
520
296
    if last_updates and len(last_updates) >= n_recent:
 
297
        while len(last_updates) > n_recent:
 
298
            last_updates.popleft()
521
299
        avg = sum(last_updates) / float(len(last_updates))
522
300
        time_left = avg * (total - current)
523
301
 
529
307
    return total_duration - elapsed
530
308
 
531
309
 
532
 
class ProgressPhase(object):
533
 
    """Update progress object with the current phase"""
534
 
    def __init__(self, message, total, pb):
535
 
        object.__init__(self)
536
 
        self.pb = pb
537
 
        self.message = message
538
 
        self.total = total
539
 
        self.cur_phase = None
540
 
 
541
 
    def next_phase(self):
542
 
        if self.cur_phase is None:
543
 
            self.cur_phase = 0
544
 
        else:
545
 
            self.cur_phase += 1
546
 
        assert self.cur_phase < self.total 
547
 
        self.pb.update(self.message, self.cur_phase, self.total)
548
 
 
549
 
 
550
310
def run_tests():
551
311
    import doctest
552
312
    result = doctest.testmod()