/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: Robert Collins
  • Date: 2009-05-12 03:50:39 UTC
  • mto: This revision was merged to the branch mainline in revision 4593.
  • Revision ID: robertc@robertcollins.net-20090512035039-6x0pahpjpkdnm9zb
Note another possible error.

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
 
 
43
 
import bzrlib.errors as errors
 
28
import warnings
 
29
 
 
30
 
 
31
from bzrlib import (
 
32
    errors,
 
33
    osutils,
 
34
    trace,
 
35
    ui,
 
36
    )
44
37
from bzrlib.trace import mutter
 
38
from bzrlib.symbol_versioning import (
 
39
    deprecated_in,
 
40
    deprecated_method,
 
41
    )
45
42
 
46
43
 
47
44
def _supports_progress(f):
 
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
    """
48
50
    isatty = getattr(f, 'isatty', None)
49
51
    if isatty is None:
50
52
        return False
56
58
    return True
57
59
 
58
60
 
59
 
_progress_bar_types = {}
 
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()
60
141
 
61
142
 
62
143
def ProgressBar(to_file=None, **kwargs):
69
150
        if _supports_progress(to_file):
70
151
            return TTYProgressBar(to_file=to_file, **kwargs)
71
152
        else:
72
 
            return DotsProgressBar(to_file=to_file, **kwargs)
 
153
            return DummyProgress(to_file=to_file, **kwargs)
73
154
    else:
74
155
        # Minor sanitation to prevent spurious errors
75
156
        requested_bar_type = requested_bar_type.lower().strip()
81
162
                                                _progress_bar_types.keys())
82
163
        return _progress_bar_types[requested_bar_type](to_file=to_file, **kwargs)
83
164
 
84
 
 
 
165
 
85
166
class ProgressBarStack(object):
86
 
    """A stack of progress bars."""
87
 
 
 
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)))
88
174
    def __init__(self,
89
175
                 to_file=None,
90
176
                 show_pct=False,
141
227
    def return_pb(self, bar):
142
228
        """Return bar after its been used."""
143
229
        if bar is not self._stack[-1]:
144
 
            raise errors.MissingProgressBarFinish()
145
 
        self._stack.pop()
146
 
 
147
 
 
 
230
            warnings.warn("%r is not currently active" % (bar,))
 
231
        else:
 
232
            self._stack.pop()
 
233
 
 
234
 
148
235
class _BaseProgressBar(object):
149
236
 
150
237
    def __init__(self,
174
261
        self._stack = _stack
175
262
        # seed throttler
176
263
        self.MIN_PAUSE = 0.1 # seconds
177
 
        now = time.clock()
 
264
        now = time.time()
178
265
        # starting now
179
266
        self.start_time = now
180
267
        # next update should not throttle
183
270
    def finished(self):
184
271
        """Return this bar to its progress stack."""
185
272
        self.clear()
186
 
        assert self._stack is not None
187
273
        self._stack.return_pb(self)
188
274
 
189
275
    def note(self, fmt_string, *args, **kwargs):
201
287
 
202
288
    This can be used as the default argument for methods that
203
289
    take an optional progress indicator."""
 
290
 
204
291
    def tick(self):
205
292
        pass
206
293
 
212
299
 
213
300
    def clear(self):
214
301
        pass
215
 
        
 
302
 
216
303
    def note(self, fmt_string, *args, **kwargs):
217
304
        """See _BaseProgressBar.note()."""
218
305
 
220
307
        return DummyProgress(**kwargs)
221
308
 
222
309
 
223
 
_progress_bar_types['dummy'] = DummyProgress
224
 
_progress_bar_types['none'] = DummyProgress
225
 
 
226
 
 
227
310
class DotsProgressBar(_BaseProgressBar):
228
311
 
229
312
    def __init__(self, **kwargs):
230
313
        _BaseProgressBar.__init__(self, **kwargs)
231
314
        self.last_msg = None
232
315
        self.need_nl = False
233
 
        
 
316
 
234
317
    def tick(self):
235
318
        self.update()
236
 
        
 
319
 
237
320
    def update(self, msg=None, current_cnt=None, total_cnt=None):
238
321
        if msg and msg != self.last_msg:
239
322
            if self.need_nl:
242
325
            self.last_msg = msg
243
326
        self.need_nl = True
244
327
        self.to_file.write('.')
245
 
        
 
328
 
246
329
    def clear(self):
247
330
        if self.need_nl:
248
331
            self.to_file.write('\n')
249
332
        self.need_nl = False
250
 
        
 
333
 
251
334
    def child_update(self, message, current, total):
252
335
        self.tick()
253
336
 
254
337
 
255
 
_progress_bar_types['dots'] = DotsProgressBar
256
 
 
257
 
    
 
338
 
 
339
 
258
340
class TTYProgressBar(_BaseProgressBar):
259
341
    """Progress bar display object.
260
342
 
287
369
        self._max_last_updates = 10
288
370
        self.child_fraction = 0
289
371
        self._have_output = False
290
 
    
291
372
 
292
373
    def throttle(self, old_msg):
293
374
        """Return True if the bar was updated too recently"""
294
375
        # 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()
 
376
        # time.clock() is faster, but gives us CPU time, not wall-clock time
 
377
        now = time.time()
300
378
        if self.start_time is not None and (now - self.start_time) < 1:
301
379
            return True
302
380
        if old_msg != self.last_msg:
311
389
        self.last_updates = self.last_updates[-self._max_last_updates:]
312
390
        self.last_update = now
313
391
        return False
314
 
        
 
392
 
315
393
    def tick(self):
316
 
        self.update(self.last_msg, self.last_cnt, self.last_total, 
 
394
        self.update(self.last_msg, self.last_cnt, self.last_total,
317
395
                    self.child_fraction)
318
396
 
319
397
    def child_update(self, message, current, total):
323
401
                pass
324
402
            elif self.last_cnt + child_fraction <= self.last_total:
325
403
                self.child_fraction = child_fraction
326
 
            else:
327
 
                mutter('not updating child fraction')
328
404
        if self.last_msg is None:
329
405
            self.last_msg = ''
330
406
        self.tick()
331
407
 
332
 
    def update(self, msg, current_cnt=None, total_cnt=None, 
333
 
               child_fraction=0):
334
 
        """Update and redraw progress bar."""
 
408
    def update(self, msg, current_cnt=None, total_cnt=None,
 
409
            child_fraction=0):
 
410
        """Update and redraw progress bar.
 
411
        """
335
412
        if msg is None:
336
413
            msg = self.last_msg
337
414
 
340
417
 
341
418
        if current_cnt < 0:
342
419
            current_cnt = 0
343
 
            
 
420
 
344
421
        if current_cnt > total_cnt:
345
422
            total_cnt = current_cnt
346
 
        
347
 
        ## # optional corner case optimisation 
 
423
 
 
424
        ## # optional corner case optimisation
348
425
        ## # currently does not seem to fire so costs more than saved.
349
426
        ## # trivial optimal case:
350
427
        ## # NB if callers are doing a clear and restore with
357
434
        ##     self.child_fraction == child_fraction):
358
435
        ##     return
359
436
 
 
437
        if msg is None:
 
438
            msg = ''
 
439
 
360
440
        old_msg = self.last_msg
361
441
        # save these for the tick() function
362
442
        self.last_msg = msg
364
444
        self.last_total = total_cnt
365
445
        self.child_fraction = child_fraction
366
446
 
367
 
        # each function call takes 20ms/4000 = 0.005 ms, 
 
447
        # each function call takes 20ms/4000 = 0.005 ms,
368
448
        # but multiple that by 4000 calls -> starts to cost.
369
449
        # so anything to make this function call faster
370
450
        # will improve base 'diff' time by up to 0.1 seconds.
372
452
            return
373
453
 
374
454
        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, 
 
455
            eta = get_eta(self.start_time, self.last_cnt + self.child_fraction,
376
456
                    self.last_total, last_updates = self.last_updates)
377
457
            eta_str = " " + str_tdelta(eta)
378
458
        else:
379
459
            eta_str = ""
380
460
 
381
461
        if self.show_spinner:
382
 
            spin_str = self.SPIN_CHARS[self.spin_pos % 4] + ' '            
 
462
            spin_str = self.SPIN_CHARS[self.spin_pos % 4] + ' '
383
463
        else:
384
464
            spin_str = ''
385
465
 
402
482
            # make both fields the same size
403
483
            t = '%i' % (self.last_total)
404
484
            c = '%*i' % (len(t), self.last_cnt)
405
 
            count_str = ' ' + c + '/' + t 
 
485
            count_str = ' ' + c + '/' + t
406
486
 
407
487
        if self.show_bar:
408
488
            # progress bar, if present, soaks up all remaining space
411
491
 
412
492
            if self.last_total:
413
493
                # number of markers highlighted in bar
414
 
                markers = int(round(float(cols) * 
 
494
                markers = int(round(float(cols) *
415
495
                              (self.last_cnt + self.child_fraction) / self.last_total))
416
496
                bar_str = '[' + ('=' * markers).ljust(cols) + '] '
417
497
            elif False:
419
499
                # so just show an expanded spinning thingy
420
500
                m = self.spin_pos % cols
421
501
                ms = (' ' * m + '*').ljust(cols)
422
 
                
 
502
 
423
503
                bar_str = '[' + ms + '] '
424
504
            else:
425
505
                bar_str = ''
426
506
        else:
427
507
            bar_str = ''
428
508
 
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))
 
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))
433
512
        self._have_output = True
434
513
        #self.to_file.flush()
435
 
            
436
 
    def clear(self):        
 
514
 
 
515
    def clear(self):
437
516
        if self._have_output:
438
517
            self.to_file.write('\r%s\r' % (' ' * (self.width - 1)))
439
518
        self._have_output = False
440
 
        #self.to_file.flush()        
441
 
 
442
 
 
443
 
_progress_bar_types['tty'] = TTYProgressBar
 
519
        #self.to_file.flush()
 
520
 
 
521
 
444
522
 
445
523
 
446
524
class ChildProgress(_BaseProgressBar):
456
534
 
457
535
    def update(self, msg, current_cnt=None, total_cnt=None):
458
536
        self.current = current_cnt
459
 
        self.total = total_cnt
 
537
        if total_cnt is not None:
 
538
            self.total = total_cnt
460
539
        self.message = msg
461
540
        self.child_fraction = 0
462
541
        self.tick()
485
564
    def note(self, *args, **kwargs):
486
565
        self.parent.note(*args, **kwargs)
487
566
 
488
 
 
 
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
 
489
585
def str_tdelta(delt):
490
586
    if delt is None:
491
587
        return "-:--:--"
508
604
    if current > total:
509
605
        return None                     # wtf?
510
606
 
511
 
    elapsed = time.clock() - start_time
 
607
    elapsed = time.time() - start_time
512
608
 
513
609
    if elapsed < 2.0:                   # not enough time to estimate
514
610
        return None
515
 
    
 
611
 
516
612
    total_duration = float(elapsed) * float(total) / float(current)
517
613
 
518
 
    assert total_duration >= elapsed
519
 
 
520
614
    if last_updates and len(last_updates) >= n_recent:
521
615
        avg = sum(last_updates) / float(len(last_updates))
522
616
        time_left = avg * (total - current)
543
637
            self.cur_phase = 0
544
638
        else:
545
639
            self.cur_phase += 1
546
 
        assert self.cur_phase < self.total 
547
640
        self.pb.update(self.message, self.cur_phase, self.total)
548
641
 
549
642
 
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()
 
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