/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: Jelmer Vernooij
  • Date: 2009-01-22 21:32:15 UTC
  • mto: This revision was merged to the branch mainline in revision 3953.
  • Revision ID: jelmer@samba.org-20090122213215-60hjko1v79a8o2pw
Remove matching test, fix handling of parentless indexes.

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 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 maintain a ProgressBarStack for you.
 
22
 
 
23
For direct use, the factory ProgressBar will return an auto-detected progress
 
24
bar that should match your terminal type. You can manually create a
 
25
ProgressBarStack too if you need multiple levels of cooperating progress bars.
 
26
Note that bzrlib's internal functions use the ui module, so if you are using
 
27
bzrlib it really is best to use bzrlib.ui.ui_factory.
27
28
"""
28
29
 
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
30
 
39
31
import sys
40
32
import time
41
33
import os
42
 
from collections import deque
43
 
 
44
 
 
45
 
import bzrlib.errors as errors
46
 
from bzrlib.trace import mutter 
 
34
import warnings
 
35
 
 
36
 
 
37
from bzrlib import (
 
38
    errors,
 
39
    osutils,
 
40
    trace,
 
41
    ui,
 
42
    )
 
43
from bzrlib.trace import mutter
47
44
 
48
45
 
49
46
def _supports_progress(f):
50
 
    if not hasattr(f, 'isatty'):
 
47
    """Detect if we can use pretty progress bars on the output stream f.
 
48
 
 
49
    If this returns true we expect that a human may be looking at that 
 
50
    output, and that we can repaint a line to update it.
 
51
    """
 
52
    isatty = getattr(f, 'isatty', None)
 
53
    if isatty is None:
51
54
        return False
52
 
    if not f.isatty():
 
55
    if not isatty():
53
56
        return False
54
57
    if os.environ.get('TERM') == 'dumb':
55
58
        # e.g. emacs compile window
57
60
    return True
58
61
 
59
62
 
60
 
 
61
 
def ProgressBar(to_file=sys.stderr, **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
 
 
74
    def __init__(self, parent_task=None, ui_factory=None):
 
75
        self._parent_task = parent_task
 
76
        self._last_update = 0
 
77
        self.total_cnt = None
 
78
        self.current_cnt = None
 
79
        self.msg = ''
 
80
        self.ui_factory = ui_factory
 
81
        self.show_pct = False
 
82
        self.show_spinner = True
 
83
        self.show_eta = False,
 
84
        self.show_count = True
 
85
        self.show_bar = True
 
86
 
 
87
    def update(self, msg, current_cnt=None, total_cnt=None):
 
88
        self.msg = msg
 
89
        self.current_cnt = current_cnt
 
90
        if total_cnt:
 
91
            self.total_cnt = total_cnt
 
92
        self.ui_factory.show_progress(self)
 
93
 
 
94
    def tick(self):
 
95
        self.update(self.msg)
 
96
 
 
97
    def finished(self):
 
98
        self.ui_factory.progress_finished(self)
 
99
 
 
100
    def make_sub_task(self):
 
101
        return ProgressTask(self, self.ui_factory)
 
102
 
 
103
    def _overall_completion_fraction(self, child_fraction=0.0):
 
104
        """Return fractional completion of this task and its parents
 
105
        
 
106
        Returns None if no completion can be computed."""
 
107
        if self.total_cnt:
 
108
            own_fraction = (float(self.current_cnt) + child_fraction) / self.total_cnt
 
109
        else:
 
110
            own_fraction = None
 
111
        if self._parent_task is None:
 
112
            return own_fraction
 
113
        else:
 
114
            if own_fraction is None:
 
115
                own_fraction = 0.0
 
116
            return self._parent_task._overall_completion_fraction(own_fraction)
 
117
 
 
118
    def note(self, fmt_string, *args):
 
119
        """Record a note without disrupting the progress bar."""
 
120
        # XXX: shouldn't be here; put it in mutter or the ui instead
 
121
        if args:
 
122
            self.ui_factory.note(fmt_string % args)
 
123
        else:
 
124
            self.ui_factory.note(fmt_string)
 
125
 
 
126
    def clear(self):
 
127
        # XXX: shouldn't be here; put it in mutter or the ui instead
 
128
        self.ui_factory.clear_term()
 
129
 
 
130
 
 
131
def ProgressBar(to_file=None, **kwargs):
62
132
    """Abstract factory"""
63
 
    if _supports_progress(to_file):
64
 
        return TTYProgressBar(to_file=to_file, **kwargs)
 
133
    if to_file is None:
 
134
        to_file = sys.stderr
 
135
    requested_bar_type = os.environ.get('BZR_PROGRESS_BAR')
 
136
    # An value of '' or not set reverts to standard processing
 
137
    if requested_bar_type in (None, ''):
 
138
        if _supports_progress(to_file):
 
139
            return TTYProgressBar(to_file=to_file, **kwargs)
 
140
        else:
 
141
            return DummyProgress(to_file=to_file, **kwargs)
65
142
    else:
66
 
        return DotsProgressBar(to_file=to_file, **kwargs)
67
 
    
68
 
 
 
143
        # Minor sanitation to prevent spurious errors
 
144
        requested_bar_type = requested_bar_type.lower().strip()
 
145
        # TODO: jam 20060710 Arguably we shouldn't raise an exception
 
146
        #       but should instead just disable progress bars if we
 
147
        #       don't recognize the type
 
148
        if requested_bar_type not in _progress_bar_types:
 
149
            raise errors.InvalidProgressBarType(requested_bar_type,
 
150
                                                _progress_bar_types.keys())
 
151
        return _progress_bar_types[requested_bar_type](to_file=to_file, **kwargs)
 
152
 
 
153
 
69
154
class ProgressBarStack(object):
70
155
    """A stack of progress bars."""
71
156
 
72
157
    def __init__(self,
73
 
                 to_file=sys.stderr,
 
158
                 to_file=None,
74
159
                 show_pct=False,
75
160
                 show_spinner=True,
76
161
                 show_eta=False,
77
162
                 show_bar=True,
78
163
                 show_count=True,
79
 
                 to_messages_file=sys.stdout,
 
164
                 to_messages_file=None,
80
165
                 klass=None):
81
166
        """Setup the stack with the parameters the progress bars should have."""
 
167
        if to_file is None:
 
168
            to_file = sys.stderr
 
169
        if to_messages_file is None:
 
170
            to_messages_file = sys.stdout
82
171
        self._to_file = to_file
83
172
        self._show_pct = show_pct
84
173
        self._show_spinner = show_spinner
87
176
        self._show_count = show_count
88
177
        self._to_messages_file = to_messages_file
89
178
        self._stack = []
90
 
        self._klass = klass or TTYProgressBar
 
179
        self._klass = klass or ProgressBar
91
180
 
92
181
    def top(self):
93
182
        if len(self._stack) != 0:
121
210
    def return_pb(self, bar):
122
211
        """Return bar after its been used."""
123
212
        if bar is not self._stack[-1]:
124
 
            raise errors.MissingProgressBarFinish()
125
 
        self._stack.pop()
 
213
            warnings.warn("%r is not currently active" % (bar,))
 
214
        else:
 
215
            self._stack.pop()
126
216
 
127
217
 
128
218
class _BaseProgressBar(object):
129
219
 
130
220
    def __init__(self,
131
 
                 to_file=sys.stderr,
 
221
                 to_file=None,
132
222
                 show_pct=False,
133
223
                 show_spinner=False,
134
 
                 show_eta=True,
 
224
                 show_eta=False,
135
225
                 show_bar=True,
136
226
                 show_count=True,
137
 
                 to_messages_file=sys.stdout,
 
227
                 to_messages_file=None,
138
228
                 _stack=None):
139
229
        object.__init__(self)
 
230
        if to_file is None:
 
231
            to_file = sys.stderr
 
232
        if to_messages_file is None:
 
233
            to_messages_file = sys.stdout
140
234
        self.to_file = to_file
141
235
        self.to_messages_file = to_messages_file
142
236
        self.last_msg = None
150
244
        self._stack = _stack
151
245
        # seed throttler
152
246
        self.MIN_PAUSE = 0.1 # seconds
153
 
        now = time.clock()
 
247
        now = time.time()
154
248
        # starting now
155
249
        self.start_time = now
156
250
        # next update should not throttle
159
253
    def finished(self):
160
254
        """Return this bar to its progress stack."""
161
255
        self.clear()
162
 
        assert self._stack is not None
163
256
        self._stack.return_pb(self)
164
257
 
165
258
    def note(self, fmt_string, *args, **kwargs):
177
270
 
178
271
    This can be used as the default argument for methods that
179
272
    take an optional progress indicator."""
 
273
 
180
274
    def tick(self):
181
275
        pass
182
276
 
195
289
    def child_progress(self, **kwargs):
196
290
        return DummyProgress(**kwargs)
197
291
 
 
292
 
198
293
class DotsProgressBar(_BaseProgressBar):
199
294
 
200
295
    def __init__(self, **kwargs):
209
304
        if msg and msg != self.last_msg:
210
305
            if self.need_nl:
211
306
                self.to_file.write('\n')
212
 
            
213
307
            self.to_file.write(msg + ': ')
214
308
            self.last_msg = msg
215
309
        self.need_nl = True
218
312
    def clear(self):
219
313
        if self.need_nl:
220
314
            self.to_file.write('\n')
 
315
        self.need_nl = False
221
316
        
222
317
    def child_update(self, message, current, total):
223
318
        self.tick()
 
319
 
 
320
 
 
321
 
224
322
    
225
323
class TTYProgressBar(_BaseProgressBar):
226
324
    """Progress bar display object.
250
348
        _BaseProgressBar.__init__(self, **kwargs)
251
349
        self.spin_pos = 0
252
350
        self.width = terminal_width()
253
 
        self.start_time = None
254
 
        self.last_updates = deque()
 
351
        self.last_updates = []
 
352
        self._max_last_updates = 10
255
353
        self.child_fraction = 0
 
354
        self._have_output = False
256
355
    
257
 
 
258
 
    def throttle(self):
 
356
    def throttle(self, old_msg):
259
357
        """Return True if the bar was updated too recently"""
260
358
        # 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()
 
359
        # time.clock() is faster, but gives us CPU time, not wall-clock time
 
360
        now = time.time()
 
361
        if self.start_time is not None and (now - self.start_time) < 1:
 
362
            return True
 
363
        if old_msg != self.last_msg:
 
364
            return False
267
365
        interval = now - self.last_update
268
366
        # if interval > 0
269
367
        if interval < self.MIN_PAUSE:
270
368
            return True
271
369
 
272
370
        self.last_updates.append(now - self.last_update)
 
371
        # Don't let the queue grow without bound
 
372
        self.last_updates = self.last_updates[-self._max_last_updates:]
273
373
        self.last_update = now
274
374
        return False
275
375
        
276
 
 
277
376
    def tick(self):
278
 
        self.update(self.last_msg, self.last_cnt, self.last_total, 
 
377
        self.update(self.last_msg, self.last_cnt, self.last_total,
279
378
                    self.child_fraction)
280
379
 
281
380
    def child_update(self, message, current, total):
285
384
                pass
286
385
            elif self.last_cnt + child_fraction <= self.last_total:
287
386
                self.child_fraction = child_fraction
288
 
            else:
289
 
                mutter('not updating child fraction')
290
387
        if self.last_msg is None:
291
388
            self.last_msg = ''
292
389
        self.tick()
293
390
 
 
391
    def update(self, msg, current_cnt=None, total_cnt=None,
 
392
            child_fraction=0):
 
393
        """Update and redraw progress bar.
 
394
        """
 
395
        if msg is None:
 
396
            msg = self.last_msg
294
397
 
295
 
    def update(self, msg, current_cnt=None, total_cnt=None, 
296
 
               child_fraction=0):
297
 
        """Update and redraw progress bar."""
 
398
        if total_cnt is None:
 
399
            total_cnt = self.last_total
298
400
 
299
401
        if current_cnt < 0:
300
402
            current_cnt = 0
315
417
        ##     self.child_fraction == child_fraction):
316
418
        ##     return
317
419
 
 
420
        if msg is None:
 
421
            msg = ''
 
422
 
318
423
        old_msg = self.last_msg
319
424
        # save these for the tick() function
320
425
        self.last_msg = msg
326
431
        # but multiple that by 4000 calls -> starts to cost.
327
432
        # so anything to make this function call faster
328
433
        # will improve base 'diff' time by up to 0.1 seconds.
329
 
        if old_msg == self.last_msg and self.throttle():
 
434
        if self.throttle(old_msg):
330
435
            return
331
436
 
332
437
        if self.show_eta and self.start_time and self.last_total:
360
465
            # make both fields the same size
361
466
            t = '%i' % (self.last_total)
362
467
            c = '%*i' % (len(t), self.last_cnt)
363
 
            count_str = ' ' + c + '/' + t 
 
468
            count_str = ' ' + c + '/' + t
364
469
 
365
470
        if self.show_bar:
366
471
            # progress bar, if present, soaks up all remaining space
384
489
        else:
385
490
            bar_str = ''
386
491
 
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))
 
492
        m = spin_str + bar_str + self.last_msg + count_str \
 
493
            + pct_str + eta_str
 
494
        self.to_file.write('\r%-*.*s' % (self.width - 1, self.width - 1, m))
 
495
        self._have_output = True
391
496
        #self.to_file.flush()
392
497
            
393
 
    def clear(self):        
394
 
        self.to_file.write('\r%s\r' % (' ' * (self.width - 1)))
 
498
    def clear(self):
 
499
        if self._have_output:
 
500
            self.to_file.write('\r%s\r' % (' ' * (self.width - 1)))
 
501
        self._have_output = False
395
502
        #self.to_file.flush()        
396
503
 
397
504
 
 
505
 
 
506
 
398
507
class ChildProgress(_BaseProgressBar):
399
508
    """A progress indicator that pushes its data to the parent"""
 
509
 
400
510
    def __init__(self, _stack, **kwargs):
401
511
        _BaseProgressBar.__init__(self, _stack=_stack, **kwargs)
402
512
        self.parent = _stack.top()
407
517
 
408
518
    def update(self, msg, current_cnt=None, total_cnt=None):
409
519
        self.current = current_cnt
410
 
        self.total = total_cnt
 
520
        if total_cnt is not None:
 
521
            self.total = total_cnt
411
522
        self.message = msg
412
523
        self.child_fraction = 0
413
524
        self.tick()
436
547
    def note(self, *args, **kwargs):
437
548
        self.parent.note(*args, **kwargs)
438
549
 
439
 
 
 
550
 
 
551
class InstrumentedProgress(TTYProgressBar):
 
552
    """TTYProgress variant that tracks outcomes"""
 
553
 
 
554
    def __init__(self, *args, **kwargs):
 
555
        self.always_throttled = True
 
556
        self.never_throttle = False
 
557
        TTYProgressBar.__init__(self, *args, **kwargs)
 
558
 
 
559
    def throttle(self, old_message):
 
560
        if self.never_throttle:
 
561
            result =  False
 
562
        else:
 
563
            result = TTYProgressBar.throttle(self, old_message)
 
564
        if result is False:
 
565
            self.always_throttled = False
 
566
 
 
567
 
440
568
def str_tdelta(delt):
441
569
    if delt is None:
442
570
        return "-:--:--"
459
587
    if current > total:
460
588
        return None                     # wtf?
461
589
 
462
 
    elapsed = time.clock() - start_time
 
590
    elapsed = time.time() - start_time
463
591
 
464
592
    if elapsed < 2.0:                   # not enough time to estimate
465
593
        return None
466
594
    
467
595
    total_duration = float(elapsed) * float(total) / float(current)
468
596
 
469
 
    assert total_duration >= elapsed
470
 
 
471
597
    if last_updates and len(last_updates) >= n_recent:
472
 
        while len(last_updates) > n_recent:
473
 
            last_updates.popleft()
474
598
        avg = sum(last_updates) / float(len(last_updates))
475
599
        time_left = avg * (total - current)
476
600
 
496
620
            self.cur_phase = 0
497
621
        else:
498
622
            self.cur_phase += 1
499
 
        assert self.cur_phase < self.total 
500
623
        self.pb.update(self.message, self.cur_phase, self.total)
501
624
 
502
625
 
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()
 
626
_progress_bar_types = {}
 
627
_progress_bar_types['dummy'] = DummyProgress
 
628
_progress_bar_types['none'] = DummyProgress
 
629
_progress_bar_types['tty'] = TTYProgressBar
 
630
_progress_bar_types['dots'] = DotsProgressBar