/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: Canonical.com Patch Queue Manager
  • Date: 2009-03-05 03:30:30 UTC
  • mfrom: (4063.2.1 more-trace)
  • Revision ID: pqm@pqm.ubuntu.com-20090305033030-065loicjpjmivxq1
(robertc) Add put_bytes_non_atomic and rmdir to the trace+ transport
        decorator. (Robert Collins)

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., 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 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
 
import bzrlib.errors as errors
46
 
from bzrlib.trace import mutter 
 
28
import warnings
 
29
 
 
30
 
 
31
from bzrlib import (
 
32
    errors,
 
33
    osutils,
 
34
    trace,
 
35
    ui,
 
36
    )
 
37
from bzrlib.trace import mutter
 
38
from bzrlib.symbol_versioning import (
 
39
    deprecated_in,
 
40
    deprecated_method,
 
41
    )
47
42
 
48
43
 
49
44
def _supports_progress(f):
50
 
    if not hasattr(f, 'isatty'):
 
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
    """
 
50
    isatty = getattr(f, 'isatty', None)
 
51
    if isatty is None:
51
52
        return False
52
 
    if not f.isatty():
 
53
    if not isatty():
53
54
        return False
54
55
    if os.environ.get('TERM') == 'dumb':
55
56
        # e.g. emacs compile window
57
58
    return True
58
59
 
59
60
 
60
 
 
61
 
def ProgressBar(to_file=sys.stderr, **kwargs):
 
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
        self._parent_task = parent_task
 
74
        self._last_update = 0
 
75
        self.total_cnt = None
 
76
        self.current_cnt = None
 
77
        self.msg = ''
 
78
        self.ui_factory = ui_factory
 
79
        self.show_pct = False
 
80
        self.show_spinner = True
 
81
        self.show_eta = False,
 
82
        self.show_count = True
 
83
        self.show_bar = True
 
84
 
 
85
    def __repr__(self):
 
86
        return '%s(%r/%r, msg=%r)' % (
 
87
            self.__class__.__name__,
 
88
            self.current_cnt,
 
89
            self.total_cnt,
 
90
            self.msg)
 
91
 
 
92
    def update(self, msg, current_cnt=None, total_cnt=None):
 
93
        self.msg = msg
 
94
        self.current_cnt = current_cnt
 
95
        if total_cnt:
 
96
            self.total_cnt = total_cnt
 
97
        self.ui_factory._progress_updated(self)
 
98
 
 
99
    def tick(self):
 
100
        self.update(self.msg)
 
101
 
 
102
    def finished(self):
 
103
        self.ui_factory._progress_finished(self)
 
104
 
 
105
    def make_sub_task(self):
 
106
        return ProgressTask(self, self.ui_factory)
 
107
 
 
108
    def _overall_completion_fraction(self, child_fraction=0.0):
 
109
        """Return fractional completion of this task and its parents
 
110
 
 
111
        Returns None if no completion can be computed."""
 
112
        if self.current_cnt is not None and self.total_cnt:
 
113
            own_fraction = (float(self.current_cnt) + child_fraction) / self.total_cnt
 
114
        else:
 
115
            own_fraction = None
 
116
        if self._parent_task is None:
 
117
            return own_fraction
 
118
        else:
 
119
            if own_fraction is None:
 
120
                own_fraction = 0.0
 
121
            return self._parent_task._overall_completion_fraction(own_fraction)
 
122
 
 
123
    def note(self, fmt_string, *args):
 
124
        """Record a note without disrupting the progress bar."""
 
125
        # XXX: shouldn't be here; put it in mutter or the ui instead
 
126
        if args:
 
127
            self.ui_factory.note(fmt_string % args)
 
128
        else:
 
129
            self.ui_factory.note(fmt_string)
 
130
 
 
131
    def clear(self):
 
132
        # XXX: shouldn't be here; put it in mutter or the ui instead
 
133
        self.ui_factory.clear_term()
 
134
 
 
135
 
 
136
def ProgressBar(to_file=None, **kwargs):
62
137
    """Abstract factory"""
63
 
    if _supports_progress(to_file):
64
 
        return TTYProgressBar(to_file=to_file, **kwargs)
 
138
    if to_file is None:
 
139
        to_file = sys.stderr
 
140
    requested_bar_type = os.environ.get('BZR_PROGRESS_BAR')
 
141
    # An value of '' or not set reverts to standard processing
 
142
    if requested_bar_type in (None, ''):
 
143
        if _supports_progress(to_file):
 
144
            return TTYProgressBar(to_file=to_file, **kwargs)
 
145
        else:
 
146
            return DummyProgress(to_file=to_file, **kwargs)
65
147
    else:
66
 
        return DotsProgressBar(to_file=to_file, **kwargs)
67
 
    
68
 
 
 
148
        # Minor sanitation to prevent spurious errors
 
149
        requested_bar_type = requested_bar_type.lower().strip()
 
150
        # TODO: jam 20060710 Arguably we shouldn't raise an exception
 
151
        #       but should instead just disable progress bars if we
 
152
        #       don't recognize the type
 
153
        if requested_bar_type not in _progress_bar_types:
 
154
            raise errors.InvalidProgressBarType(requested_bar_type,
 
155
                                                _progress_bar_types.keys())
 
156
        return _progress_bar_types[requested_bar_type](to_file=to_file, **kwargs)
 
157
 
 
158
 
69
159
class ProgressBarStack(object):
70
 
    """A stack of progress bars."""
71
 
 
 
160
    """A stack of progress bars.
 
161
 
 
162
    This class is deprecated: instead, ask the ui factory for a new progress
 
163
    task and finish it when it's done.
 
164
    """
 
165
 
 
166
    @deprecated_method(deprecated_in((1, 12, 0)))
72
167
    def __init__(self,
73
 
                 to_file=sys.stderr,
 
168
                 to_file=None,
74
169
                 show_pct=False,
75
170
                 show_spinner=True,
76
171
                 show_eta=False,
77
172
                 show_bar=True,
78
173
                 show_count=True,
79
 
                 to_messages_file=sys.stdout,
 
174
                 to_messages_file=None,
80
175
                 klass=None):
81
176
        """Setup the stack with the parameters the progress bars should have."""
 
177
        if to_file is None:
 
178
            to_file = sys.stderr
 
179
        if to_messages_file is None:
 
180
            to_messages_file = sys.stdout
82
181
        self._to_file = to_file
83
182
        self._show_pct = show_pct
84
183
        self._show_spinner = show_spinner
87
186
        self._show_count = show_count
88
187
        self._to_messages_file = to_messages_file
89
188
        self._stack = []
90
 
        self._klass = klass or TTYProgressBar
 
189
        self._klass = klass or ProgressBar
91
190
 
92
191
    def top(self):
93
192
        if len(self._stack) != 0:
121
220
    def return_pb(self, bar):
122
221
        """Return bar after its been used."""
123
222
        if bar is not self._stack[-1]:
124
 
            raise errors.MissingProgressBarFinish()
125
 
        self._stack.pop()
126
 
 
127
 
 
 
223
            warnings.warn("%r is not currently active" % (bar,))
 
224
        else:
 
225
            self._stack.pop()
 
226
 
 
227
 
128
228
class _BaseProgressBar(object):
129
229
 
130
230
    def __init__(self,
131
 
                 to_file=sys.stderr,
 
231
                 to_file=None,
132
232
                 show_pct=False,
133
233
                 show_spinner=False,
134
 
                 show_eta=True,
 
234
                 show_eta=False,
135
235
                 show_bar=True,
136
236
                 show_count=True,
137
 
                 to_messages_file=sys.stdout,
 
237
                 to_messages_file=None,
138
238
                 _stack=None):
139
239
        object.__init__(self)
 
240
        if to_file is None:
 
241
            to_file = sys.stderr
 
242
        if to_messages_file is None:
 
243
            to_messages_file = sys.stdout
140
244
        self.to_file = to_file
141
245
        self.to_messages_file = to_messages_file
142
246
        self.last_msg = None
150
254
        self._stack = _stack
151
255
        # seed throttler
152
256
        self.MIN_PAUSE = 0.1 # seconds
153
 
        now = time.clock()
 
257
        now = time.time()
154
258
        # starting now
155
259
        self.start_time = now
156
260
        # next update should not throttle
159
263
    def finished(self):
160
264
        """Return this bar to its progress stack."""
161
265
        self.clear()
162
 
        assert self._stack is not None
163
266
        self._stack.return_pb(self)
164
267
 
165
268
    def note(self, fmt_string, *args, **kwargs):
177
280
 
178
281
    This can be used as the default argument for methods that
179
282
    take an optional progress indicator."""
 
283
 
180
284
    def tick(self):
181
285
        pass
182
286
 
188
292
 
189
293
    def clear(self):
190
294
        pass
191
 
        
 
295
 
192
296
    def note(self, fmt_string, *args, **kwargs):
193
297
        """See _BaseProgressBar.note()."""
194
298
 
195
299
    def child_progress(self, **kwargs):
196
300
        return DummyProgress(**kwargs)
197
301
 
 
302
 
198
303
class DotsProgressBar(_BaseProgressBar):
199
304
 
200
305
    def __init__(self, **kwargs):
201
306
        _BaseProgressBar.__init__(self, **kwargs)
202
307
        self.last_msg = None
203
308
        self.need_nl = False
204
 
        
 
309
 
205
310
    def tick(self):
206
311
        self.update()
207
 
        
 
312
 
208
313
    def update(self, msg=None, current_cnt=None, total_cnt=None):
209
314
        if msg and msg != self.last_msg:
210
315
            if self.need_nl:
211
316
                self.to_file.write('\n')
212
 
            
213
317
            self.to_file.write(msg + ': ')
214
318
            self.last_msg = msg
215
319
        self.need_nl = True
216
320
        self.to_file.write('.')
217
 
        
 
321
 
218
322
    def clear(self):
219
323
        if self.need_nl:
220
324
            self.to_file.write('\n')
221
 
        
 
325
        self.need_nl = False
 
326
 
222
327
    def child_update(self, message, current, total):
223
328
        self.tick()
224
 
    
 
329
 
 
330
 
 
331
 
 
332
 
225
333
class TTYProgressBar(_BaseProgressBar):
226
334
    """Progress bar display object.
227
335
 
250
358
        _BaseProgressBar.__init__(self, **kwargs)
251
359
        self.spin_pos = 0
252
360
        self.width = terminal_width()
253
 
        self.start_time = None
254
 
        self.last_updates = deque()
 
361
        self.last_updates = []
 
362
        self._max_last_updates = 10
255
363
        self.child_fraction = 0
256
 
    
 
364
        self._have_output = False
257
365
 
258
 
    def throttle(self):
 
366
    def throttle(self, old_msg):
259
367
        """Return True if the bar was updated too recently"""
260
368
        # 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()
 
369
        # time.clock() is faster, but gives us CPU time, not wall-clock time
 
370
        now = time.time()
 
371
        if self.start_time is not None and (now - self.start_time) < 1:
 
372
            return True
 
373
        if old_msg != self.last_msg:
 
374
            return False
267
375
        interval = now - self.last_update
268
376
        # if interval > 0
269
377
        if interval < self.MIN_PAUSE:
270
378
            return True
271
379
 
272
380
        self.last_updates.append(now - self.last_update)
 
381
        # Don't let the queue grow without bound
 
382
        self.last_updates = self.last_updates[-self._max_last_updates:]
273
383
        self.last_update = now
274
384
        return False
275
 
        
276
385
 
277
386
    def tick(self):
278
 
        self.update(self.last_msg, self.last_cnt, self.last_total, 
 
387
        self.update(self.last_msg, self.last_cnt, self.last_total,
279
388
                    self.child_fraction)
280
389
 
281
390
    def child_update(self, message, current, total):
285
394
                pass
286
395
            elif self.last_cnt + child_fraction <= self.last_total:
287
396
                self.child_fraction = child_fraction
288
 
            else:
289
 
                mutter('not updating child fraction')
290
397
        if self.last_msg is None:
291
398
            self.last_msg = ''
292
399
        self.tick()
293
400
 
 
401
    def update(self, msg, current_cnt=None, total_cnt=None,
 
402
            child_fraction=0):
 
403
        """Update and redraw progress bar.
 
404
        """
 
405
        if msg is None:
 
406
            msg = self.last_msg
294
407
 
295
 
    def update(self, msg, current_cnt=None, total_cnt=None, 
296
 
               child_fraction=0):
297
 
        """Update and redraw progress bar."""
 
408
        if total_cnt is None:
 
409
            total_cnt = self.last_total
298
410
 
299
411
        if current_cnt < 0:
300
412
            current_cnt = 0
301
 
            
 
413
 
302
414
        if current_cnt > total_cnt:
303
415
            total_cnt = current_cnt
304
 
        
305
 
        ## # optional corner case optimisation 
 
416
 
 
417
        ## # optional corner case optimisation
306
418
        ## # currently does not seem to fire so costs more than saved.
307
419
        ## # trivial optimal case:
308
420
        ## # NB if callers are doing a clear and restore with
315
427
        ##     self.child_fraction == child_fraction):
316
428
        ##     return
317
429
 
 
430
        if msg is None:
 
431
            msg = ''
 
432
 
318
433
        old_msg = self.last_msg
319
434
        # save these for the tick() function
320
435
        self.last_msg = msg
322
437
        self.last_total = total_cnt
323
438
        self.child_fraction = child_fraction
324
439
 
325
 
        # each function call takes 20ms/4000 = 0.005 ms, 
 
440
        # each function call takes 20ms/4000 = 0.005 ms,
326
441
        # but multiple that by 4000 calls -> starts to cost.
327
442
        # so anything to make this function call faster
328
443
        # will improve base 'diff' time by up to 0.1 seconds.
329
 
        if old_msg == self.last_msg and self.throttle():
 
444
        if self.throttle(old_msg):
330
445
            return
331
446
 
332
447
        if self.show_eta and self.start_time and self.last_total:
333
 
            eta = get_eta(self.start_time, self.last_cnt + self.child_fraction, 
 
448
            eta = get_eta(self.start_time, self.last_cnt + self.child_fraction,
334
449
                    self.last_total, last_updates = self.last_updates)
335
450
            eta_str = " " + str_tdelta(eta)
336
451
        else:
337
452
            eta_str = ""
338
453
 
339
454
        if self.show_spinner:
340
 
            spin_str = self.SPIN_CHARS[self.spin_pos % 4] + ' '            
 
455
            spin_str = self.SPIN_CHARS[self.spin_pos % 4] + ' '
341
456
        else:
342
457
            spin_str = ''
343
458
 
360
475
            # make both fields the same size
361
476
            t = '%i' % (self.last_total)
362
477
            c = '%*i' % (len(t), self.last_cnt)
363
 
            count_str = ' ' + c + '/' + t 
 
478
            count_str = ' ' + c + '/' + t
364
479
 
365
480
        if self.show_bar:
366
481
            # progress bar, if present, soaks up all remaining space
369
484
 
370
485
            if self.last_total:
371
486
                # number of markers highlighted in bar
372
 
                markers = int(round(float(cols) * 
 
487
                markers = int(round(float(cols) *
373
488
                              (self.last_cnt + self.child_fraction) / self.last_total))
374
489
                bar_str = '[' + ('=' * markers).ljust(cols) + '] '
375
490
            elif False:
377
492
                # so just show an expanded spinning thingy
378
493
                m = self.spin_pos % cols
379
494
                ms = (' ' * m + '*').ljust(cols)
380
 
                
 
495
 
381
496
                bar_str = '[' + ms + '] '
382
497
            else:
383
498
                bar_str = ''
384
499
        else:
385
500
            bar_str = ''
386
501
 
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))
391
 
        #self.to_file.flush()
392
 
            
393
 
    def clear(self):        
394
 
        self.to_file.write('\r%s\r' % (' ' * (self.width - 1)))
395
 
        #self.to_file.flush()        
 
502
        m = spin_str + bar_str + self.last_msg + count_str \
 
503
            + pct_str + eta_str
 
504
        self.to_file.write('\r%-*.*s' % (self.width - 1, self.width - 1, m))
 
505
        self._have_output = True
 
506
        #self.to_file.flush()
 
507
 
 
508
    def clear(self):
 
509
        if self._have_output:
 
510
            self.to_file.write('\r%s\r' % (' ' * (self.width - 1)))
 
511
        self._have_output = False
 
512
        #self.to_file.flush()
 
513
 
 
514
 
396
515
 
397
516
 
398
517
class ChildProgress(_BaseProgressBar):
399
518
    """A progress indicator that pushes its data to the parent"""
 
519
 
400
520
    def __init__(self, _stack, **kwargs):
401
521
        _BaseProgressBar.__init__(self, _stack=_stack, **kwargs)
402
522
        self.parent = _stack.top()
407
527
 
408
528
    def update(self, msg, current_cnt=None, total_cnt=None):
409
529
        self.current = current_cnt
410
 
        self.total = total_cnt
 
530
        if total_cnt is not None:
 
531
            self.total = total_cnt
411
532
        self.message = msg
412
533
        self.child_fraction = 0
413
534
        self.tick()
436
557
    def note(self, *args, **kwargs):
437
558
        self.parent.note(*args, **kwargs)
438
559
 
439
 
 
 
560
 
 
561
class InstrumentedProgress(TTYProgressBar):
 
562
    """TTYProgress variant that tracks outcomes"""
 
563
 
 
564
    def __init__(self, *args, **kwargs):
 
565
        self.always_throttled = True
 
566
        self.never_throttle = False
 
567
        TTYProgressBar.__init__(self, *args, **kwargs)
 
568
 
 
569
    def throttle(self, old_message):
 
570
        if self.never_throttle:
 
571
            result =  False
 
572
        else:
 
573
            result = TTYProgressBar.throttle(self, old_message)
 
574
        if result is False:
 
575
            self.always_throttled = False
 
576
 
 
577
 
440
578
def str_tdelta(delt):
441
579
    if delt is None:
442
580
        return "-:--:--"
459
597
    if current > total:
460
598
        return None                     # wtf?
461
599
 
462
 
    elapsed = time.clock() - start_time
 
600
    elapsed = time.time() - start_time
463
601
 
464
602
    if elapsed < 2.0:                   # not enough time to estimate
465
603
        return None
466
 
    
 
604
 
467
605
    total_duration = float(elapsed) * float(total) / float(current)
468
606
 
469
 
    assert total_duration >= elapsed
470
 
 
471
607
    if last_updates and len(last_updates) >= n_recent:
472
 
        while len(last_updates) > n_recent:
473
 
            last_updates.popleft()
474
608
        avg = sum(last_updates) / float(len(last_updates))
475
609
        time_left = avg * (total - current)
476
610
 
496
630
            self.cur_phase = 0
497
631
        else:
498
632
            self.cur_phase += 1
499
 
        assert self.cur_phase < self.total 
500
633
        self.pb.update(self.message, self.cur_phase, self.total)
501
634
 
502
635
 
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()
 
636
_progress_bar_types = {}
 
637
_progress_bar_types['dummy'] = DummyProgress
 
638
_progress_bar_types['none'] = DummyProgress
 
639
_progress_bar_types['tty'] = TTYProgressBar
 
640
_progress_bar_types['dots'] = DotsProgressBar