← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/progress.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2008-03-16 14:01:20 UTC
  • mfrom: (3280.2.5 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20080316140120-i3yq8yr1l66m11h7
Start 1.4 development

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/progress.py
1
 
# Copyright (C) 2005, 2006, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2005 Aaron Bentley <aaron.bentley@utoronto.ca>
 
2
# Copyright (C) 2005, 2006 Canonical Ltd
2
3
#
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
12
13
#
13
14
# You should have received a copy of the GNU General Public License
14
15
# 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
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
17
 
17
18
 
18
19
"""Progress indicators.
19
20
 
20
21
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.
 
22
will maintain a ProgressBarStack for you.
 
23
 
 
24
For direct use, the factory ProgressBar will return an auto-detected progress
 
25
bar that should match your terminal type. You can manually create a
 
26
ProgressBarStack too if you need multiple levels of cooperating progress bars.
 
27
Note that bzrlib's internal functions use the ui module, so if you are using
 
28
bzrlib it really is best to use bzrlib.ui.ui_factory.
22
29
"""
23
30
 
 
31
# TODO: Optionally show elapsed time instead/as well as ETA; nicer
 
32
# when the rate is unpredictable
24
33
 
25
34
import sys
26
35
import time
27
36
import os
28
 
import warnings
29
 
 
30
 
 
 
37
 
 
38
from bzrlib.lazy_import import lazy_import
 
39
lazy_import(globals(), """
31
40
from bzrlib import (
32
41
    errors,
33
 
    osutils,
34
 
    trace,
35
 
    ui,
36
42
    )
 
43
""")
 
44
 
37
45
from bzrlib.trace import mutter
38
 
from bzrlib.symbol_versioning import (
39
 
    deprecated_in,
40
 
    deprecated_method,
41
 
    )
42
46
 
43
47
 
44
48
def _supports_progress(f):
45
49
    """Detect if we can use pretty progress bars on the output stream f.
46
50
 
47
 
    If this returns true we expect that a human may be looking at that
 
51
    If this returns true we expect that a human may be looking at that 
48
52
    output, and that we can repaint a line to update it.
49
53
    """
50
54
    isatty = getattr(f, 'isatty', None)
58
62
    return True
59
63
 
60
64
 
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()
 
65
_progress_bar_types = {}
141
66
 
142
67
 
143
68
def ProgressBar(to_file=None, **kwargs):
162
87
                                                _progress_bar_types.keys())
163
88
        return _progress_bar_types[requested_bar_type](to_file=to_file, **kwargs)
164
89
 
165
 
 
 
90
 
166
91
class ProgressBarStack(object):
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)))
 
92
    """A stack of progress bars."""
 
93
 
174
94
    def __init__(self,
175
95
                 to_file=None,
176
96
                 show_pct=False,
227
147
    def return_pb(self, bar):
228
148
        """Return bar after its been used."""
229
149
        if bar is not self._stack[-1]:
230
 
            warnings.warn("%r is not currently active" % (bar,))
231
 
        else:
232
 
            self._stack.pop()
233
 
 
234
 
 
 
150
            raise errors.MissingProgressBarFinish()
 
151
        self._stack.pop()
 
152
 
 
153
 
235
154
class _BaseProgressBar(object):
236
155
 
237
156
    def __init__(self,
270
189
    def finished(self):
271
190
        """Return this bar to its progress stack."""
272
191
        self.clear()
 
192
        assert self._stack is not None
273
193
        self._stack.return_pb(self)
274
194
 
275
195
    def note(self, fmt_string, *args, **kwargs):
287
207
 
288
208
    This can be used as the default argument for methods that
289
209
    take an optional progress indicator."""
290
 
 
291
210
    def tick(self):
292
211
        pass
293
212
 
299
218
 
300
219
    def clear(self):
301
220
        pass
302
 
 
 
221
        
303
222
    def note(self, fmt_string, *args, **kwargs):
304
223
        """See _BaseProgressBar.note()."""
305
224
 
307
226
        return DummyProgress(**kwargs)
308
227
 
309
228
 
 
229
_progress_bar_types['dummy'] = DummyProgress
 
230
_progress_bar_types['none'] = DummyProgress
 
231
 
 
232
 
310
233
class DotsProgressBar(_BaseProgressBar):
311
234
 
312
235
    def __init__(self, **kwargs):
313
236
        _BaseProgressBar.__init__(self, **kwargs)
314
237
        self.last_msg = None
315
238
        self.need_nl = False
316
 
 
 
239
        
317
240
    def tick(self):
318
241
        self.update()
319
 
 
 
242
        
320
243
    def update(self, msg=None, current_cnt=None, total_cnt=None):
321
244
        if msg and msg != self.last_msg:
322
245
            if self.need_nl:
325
248
            self.last_msg = msg
326
249
        self.need_nl = True
327
250
        self.to_file.write('.')
328
 
 
 
251
        
329
252
    def clear(self):
330
253
        if self.need_nl:
331
254
            self.to_file.write('\n')
332
255
        self.need_nl = False
333
 
 
 
256
        
334
257
    def child_update(self, message, current, total):
335
258
        self.tick()
336
259
 
337
260
 
338
 
 
339
 
 
 
261
_progress_bar_types['dots'] = DotsProgressBar
 
262
 
 
263
    
340
264
class TTYProgressBar(_BaseProgressBar):
341
265
    """Progress bar display object.
342
266
 
369
293
        self._max_last_updates = 10
370
294
        self.child_fraction = 0
371
295
        self._have_output = False
372
 
 
 
296
    
373
297
    def throttle(self, old_msg):
374
298
        """Return True if the bar was updated too recently"""
375
299
        # time.time consistently takes 40/4000 ms = 0.01 ms.
389
313
        self.last_updates = self.last_updates[-self._max_last_updates:]
390
314
        self.last_update = now
391
315
        return False
392
 
 
 
316
        
393
317
    def tick(self):
394
318
        self.update(self.last_msg, self.last_cnt, self.last_total,
395
319
                    self.child_fraction)
401
325
                pass
402
326
            elif self.last_cnt + child_fraction <= self.last_total:
403
327
                self.child_fraction = child_fraction
 
328
            else:
 
329
                mutter('not updating child fraction')
404
330
        if self.last_msg is None:
405
331
            self.last_msg = ''
406
332
        self.tick()
407
333
 
408
334
    def update(self, msg, current_cnt=None, total_cnt=None,
409
 
            child_fraction=0):
410
 
        """Update and redraw progress bar.
411
 
        """
 
335
               child_fraction=0):
 
336
        """Update and redraw progress bar."""
412
337
        if msg is None:
413
338
            msg = self.last_msg
414
339
 
417
342
 
418
343
        if current_cnt < 0:
419
344
            current_cnt = 0
420
 
 
 
345
            
421
346
        if current_cnt > total_cnt:
422
347
            total_cnt = current_cnt
423
 
 
424
 
        ## # optional corner case optimisation
 
348
        
 
349
        ## # optional corner case optimisation 
425
350
        ## # currently does not seem to fire so costs more than saved.
426
351
        ## # trivial optimal case:
427
352
        ## # NB if callers are doing a clear and restore with
434
359
        ##     self.child_fraction == child_fraction):
435
360
        ##     return
436
361
 
437
 
        if msg is None:
438
 
            msg = ''
439
 
 
440
362
        old_msg = self.last_msg
441
363
        # save these for the tick() function
442
364
        self.last_msg = msg
444
366
        self.last_total = total_cnt
445
367
        self.child_fraction = child_fraction
446
368
 
447
 
        # each function call takes 20ms/4000 = 0.005 ms,
 
369
        # each function call takes 20ms/4000 = 0.005 ms, 
448
370
        # but multiple that by 4000 calls -> starts to cost.
449
371
        # so anything to make this function call faster
450
372
        # will improve base 'diff' time by up to 0.1 seconds.
452
374
            return
453
375
 
454
376
        if self.show_eta and self.start_time and self.last_total:
455
 
            eta = get_eta(self.start_time, self.last_cnt + self.child_fraction,
 
377
            eta = get_eta(self.start_time, self.last_cnt + self.child_fraction, 
456
378
                    self.last_total, last_updates = self.last_updates)
457
379
            eta_str = " " + str_tdelta(eta)
458
380
        else:
459
381
            eta_str = ""
460
382
 
461
383
        if self.show_spinner:
462
 
            spin_str = self.SPIN_CHARS[self.spin_pos % 4] + ' '
 
384
            spin_str = self.SPIN_CHARS[self.spin_pos % 4] + ' '            
463
385
        else:
464
386
            spin_str = ''
465
387
 
482
404
            # make both fields the same size
483
405
            t = '%i' % (self.last_total)
484
406
            c = '%*i' % (len(t), self.last_cnt)
485
 
            count_str = ' ' + c + '/' + t
 
407
            count_str = ' ' + c + '/' + t 
486
408
 
487
409
        if self.show_bar:
488
410
            # progress bar, if present, soaks up all remaining space
491
413
 
492
414
            if self.last_total:
493
415
                # number of markers highlighted in bar
494
 
                markers = int(round(float(cols) *
 
416
                markers = int(round(float(cols) * 
495
417
                              (self.last_cnt + self.child_fraction) / self.last_total))
496
418
                bar_str = '[' + ('=' * markers).ljust(cols) + '] '
497
419
            elif False:
499
421
                # so just show an expanded spinning thingy
500
422
                m = self.spin_pos % cols
501
423
                ms = (' ' * m + '*').ljust(cols)
502
 
 
 
424
                
503
425
                bar_str = '[' + ms + '] '
504
426
            else:
505
427
                bar_str = ''
506
428
        else:
507
429
            bar_str = ''
508
430
 
509
 
        m = spin_str + bar_str + self.last_msg + count_str \
510
 
            + pct_str + eta_str
 
431
        m = spin_str + bar_str + self.last_msg + count_str + pct_str + eta_str
511
432
        self.to_file.write('\r%-*.*s' % (self.width - 1, self.width - 1, m))
512
433
        self._have_output = True
513
434
        #self.to_file.flush()
514
 
 
 
435
            
515
436
    def clear(self):
516
437
        if self._have_output:
517
438
            self.to_file.write('\r%s\r' % (' ' * (self.width - 1)))
518
439
        self._have_output = False
519
 
        #self.to_file.flush()
520
 
 
521
 
 
 
440
        #self.to_file.flush()        
 
441
 
 
442
 
 
443
_progress_bar_types['tty'] = TTYProgressBar
522
444
 
523
445
 
524
446
class ChildProgress(_BaseProgressBar):
608
530
 
609
531
    if elapsed < 2.0:                   # not enough time to estimate
610
532
        return None
611
 
 
 
533
    
612
534
    total_duration = float(elapsed) * float(total) / float(current)
613
535
 
 
536
    assert total_duration >= elapsed
 
537
 
614
538
    if last_updates and len(last_updates) >= n_recent:
615
539
        avg = sum(last_updates) / float(len(last_updates))
616
540
        time_left = avg * (total - current)
637
561
            self.cur_phase = 0
638
562
        else:
639
563
            self.cur_phase += 1
 
564
        assert self.cur_phase < self.total
640
565
        self.pb.update(self.message, self.cur_phase, self.total)
641
 
 
642
 
 
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