← 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: 2009-06-22 17:11:20 UTC
  • mfrom: (4398.8.10 1.16-commit-fulltext)
  • Revision ID: pqm@pqm.ubuntu.com-20090622171120-fuxez9ylfqpxynqn
(jam) Add VF._add_text and reduce memory overhead during commit (see
        bug #109114)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/progress.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2008, 2009 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
25
25
import sys
26
26
import time
27
27
import os
28
 
 
29
 
 
 
28
import warnings
 
29
 
 
30
 
 
31
from bzrlib import (
 
32
    errors,
 
33
    osutils,
 
34
    trace,
 
35
    ui,
 
36
    )
 
37
from bzrlib.trace import mutter
30
38
from bzrlib.symbol_versioning import (
 
39
    deprecated_function,
31
40
    deprecated_in,
32
41
    deprecated_method,
33
42
    )
34
43
 
35
44
 
 
45
# XXX: deprecated; can be removed when the ProgressBar factory is removed
36
46
def _supports_progress(f):
37
 
    """Detect if we can use pretty progress bars on file F.
 
47
    """Detect if we can use pretty progress bars on the output stream f.
38
48
 
39
49
    If this returns true we expect that a human may be looking at that
40
50
    output, and that we can repaint a line to update it.
41
 
 
42
 
    This doesn't check the policy for whether we *should* use them.
43
51
    """
44
52
    isatty = getattr(f, 'isatty', None)
45
53
    if isatty is None:
46
54
        return False
47
55
    if not isatty():
48
56
        return False
49
 
    # The following case also handles Win32 - on that platform $TERM is
50
 
    # typically never set, so the case None is treated as a smart terminal,
51
 
    # not dumb.  <https://bugs.launchpad.net/bugs/334808>  win32 files do have
52
 
    # isatty methods that return true.
53
57
    if os.environ.get('TERM') == 'dumb':
54
58
        # e.g. emacs compile window
55
59
        return False
65
69
    Code updating the task may also set fields as hints about how to display
66
70
    it: show_pct, show_spinner, show_eta, show_count, show_bar.  UIs
67
71
    will not necessarily respect all these fields.
68
 
    
69
 
    :ivar update_latency: The interval (in seconds) at which the PB should be
70
 
        updated.  Setting this to zero suggests every update should be shown
71
 
        synchronously.
72
 
 
73
 
    :ivar show_transport_activity: If true (default), transport activity
74
 
        will be shown when this task is drawn.  Disable it if you're sure 
75
 
        that only irrelevant or uninteresting transport activity can occur
76
 
        during this task.
77
72
    """
78
73
 
79
 
    def __init__(self, parent_task=None, ui_factory=None, progress_view=None):
 
74
    def __init__(self, parent_task=None, ui_factory=None):
80
75
        """Construct a new progress task.
81
76
 
82
 
        :param parent_task: Enclosing ProgressTask or None.
83
 
 
84
 
        :param progress_view: ProgressView to display this ProgressTask.
85
 
 
86
 
        :param ui_factory: The UI factory that will display updates; 
87
 
            deprecated in favor of passing progress_view directly.
88
 
 
89
77
        Normally you should not call this directly but rather through
90
78
        `ui_factory.nested_progress_bar`.
91
79
        """
94
82
        self.total_cnt = None
95
83
        self.current_cnt = None
96
84
        self.msg = ''
97
 
        # TODO: deprecate passing ui_factory
98
85
        self.ui_factory = ui_factory
99
 
        self.progress_view = progress_view
100
86
        self.show_pct = False
101
87
        self.show_spinner = True
102
88
        self.show_eta = False,
103
89
        self.show_count = True
104
90
        self.show_bar = True
105
 
        self.update_latency = 0.1
106
 
        self.show_transport_activity = True
107
91
 
108
92
    def __repr__(self):
109
93
        return '%s(%r/%r, msg=%r)' % (
117
101
        self.current_cnt = current_cnt
118
102
        if total_cnt:
119
103
            self.total_cnt = total_cnt
120
 
        if self.progress_view:
121
 
            self.progress_view.show_progress(self)
122
 
        else:
123
 
            self.ui_factory._progress_updated(self)
 
104
        self.ui_factory._progress_updated(self)
124
105
 
125
106
    def tick(self):
126
107
        self.update(self.msg)
127
108
 
128
109
    def finished(self):
129
 
        if self.progress_view:
130
 
            self.progress_view.task_finished(self)
131
 
        else:
132
 
            self.ui_factory._progress_finished(self)
 
110
        self.ui_factory._progress_finished(self)
133
111
 
134
112
    def make_sub_task(self):
135
 
        return ProgressTask(self, ui_factory=self.ui_factory,
136
 
            progress_view=self.progress_view)
 
113
        return ProgressTask(self, self.ui_factory)
137
114
 
138
115
    def _overall_completion_fraction(self, child_fraction=0.0):
139
116
        """Return fractional completion of this task and its parents
152
129
                own_fraction = 0.0
153
130
            return self._parent_task._overall_completion_fraction(own_fraction)
154
131
 
 
132
    def note(self, fmt_string, *args):
 
133
        """Record a note without disrupting the progress bar."""
 
134
        # XXX: shouldn't be here; put it in mutter or the ui instead
 
135
        if args:
 
136
            self.ui_factory.note(fmt_string % args)
 
137
        else:
 
138
            self.ui_factory.note(fmt_string)
 
139
 
155
140
    def clear(self):
156
 
        # TODO: deprecate this method; the model object shouldn't be concerned
157
 
        # with whether it's shown or not.  Most callers use this because they
158
 
        # want to write some different non-progress output to the screen, but
159
 
        # they should probably instead use a stream that's synchronized with
160
 
        # the progress output.  It may be there is a model-level use for
161
 
        # saying "this task's not active at the moment" but I don't see it. --
162
 
        # mbp 20090623
163
 
        if self.progress_view:
164
 
            self.progress_view.clear()
 
141
        # XXX: shouldn't be here; put it in mutter or the ui instead
 
142
        self.ui_factory.clear_term()
 
143
 
 
144
 
 
145
@deprecated_function(deprecated_in((1, 16, 0)))
 
146
def ProgressBar(to_file=None, **kwargs):
 
147
    """Abstract factory"""
 
148
    if to_file is None:
 
149
        to_file = sys.stderr
 
150
    requested_bar_type = os.environ.get('BZR_PROGRESS_BAR')
 
151
    # An value of '' or not set reverts to standard processing
 
152
    if requested_bar_type in (None, ''):
 
153
        if _supports_progress(to_file):
 
154
            return TTYProgressBar(to_file=to_file, **kwargs)
165
155
        else:
166
 
            self.ui_factory.clear_term()
167
 
 
168
 
 
169
 
class DummyProgress(object):
 
156
            return DummyProgress(to_file=to_file, **kwargs)
 
157
    else:
 
158
        # Minor sanitation to prevent spurious errors
 
159
        requested_bar_type = requested_bar_type.lower().strip()
 
160
        # TODO: jam 20060710 Arguably we shouldn't raise an exception
 
161
        #       but should instead just disable progress bars if we
 
162
        #       don't recognize the type
 
163
        if requested_bar_type not in _progress_bar_types:
 
164
            raise errors.InvalidProgressBarType(requested_bar_type,
 
165
                                                _progress_bar_types.keys())
 
166
        return _progress_bar_types[requested_bar_type](to_file=to_file, **kwargs)
 
167
 
 
168
 
 
169
class _BaseProgressBar(object):
 
170
 
 
171
    def __init__(self,
 
172
                 to_file=None,
 
173
                 show_pct=False,
 
174
                 show_spinner=False,
 
175
                 show_eta=False,
 
176
                 show_bar=True,
 
177
                 show_count=True,
 
178
                 to_messages_file=None,
 
179
                 _stack=None):
 
180
        object.__init__(self)
 
181
        if to_file is None:
 
182
            to_file = sys.stderr
 
183
        if to_messages_file is None:
 
184
            to_messages_file = sys.stdout
 
185
        self.to_file = to_file
 
186
        self.to_messages_file = to_messages_file
 
187
        self.last_msg = None
 
188
        self.last_cnt = None
 
189
        self.last_total = None
 
190
        self.show_pct = show_pct
 
191
        self.show_spinner = show_spinner
 
192
        self.show_eta = show_eta
 
193
        self.show_bar = show_bar
 
194
        self.show_count = show_count
 
195
        self._stack = _stack
 
196
        # seed throttler
 
197
        self.MIN_PAUSE = 0.1 # seconds
 
198
        now = time.time()
 
199
        # starting now
 
200
        self.start_time = now
 
201
        # next update should not throttle
 
202
        self.last_update = now - self.MIN_PAUSE - 1
 
203
 
 
204
    def finished(self):
 
205
        """Return this bar to its progress stack."""
 
206
        self.clear()
 
207
        self._stack.return_pb(self)
 
208
 
 
209
    def note(self, fmt_string, *args, **kwargs):
 
210
        """Record a note without disrupting the progress bar."""
 
211
        self.clear()
 
212
        self.to_messages_file.write(fmt_string % args)
 
213
        self.to_messages_file.write('\n')
 
214
 
 
215
    @deprecated_function(deprecated_in((1, 16, 0)))
 
216
    def child_progress(self, **kwargs):
 
217
        return ChildProgress(**kwargs)
 
218
 
 
219
 
 
220
class DummyProgress(_BaseProgressBar):
170
221
    """Progress-bar standin that does nothing.
171
222
 
172
 
    This was previously often constructed by application code if no progress
173
 
    bar was explicitly passed in.  That's no longer recommended: instead, just
174
 
    create a progress task from the ui_factory.  This class can be used in
175
 
    test code that needs to fake a progress task for some reason.
176
 
    """
 
223
    This can be used as the default argument for methods that
 
224
    take an optional progress indicator."""
177
225
 
178
226
    def tick(self):
179
227
        pass
187
235
    def clear(self):
188
236
        pass
189
237
 
 
238
    def note(self, fmt_string, *args, **kwargs):
 
239
        """See _BaseProgressBar.note()."""
 
240
 
190
241
    def child_progress(self, **kwargs):
191
242
        return DummyProgress(**kwargs)
192
243
 
193
244
 
 
245
class DotsProgressBar(_BaseProgressBar):
 
246
 
 
247
    @deprecated_function(deprecated_in((1, 16, 0)))
 
248
    def __init__(self, **kwargs):
 
249
        _BaseProgressBar.__init__(self, **kwargs)
 
250
        self.last_msg = None
 
251
        self.need_nl = False
 
252
 
 
253
    def tick(self):
 
254
        self.update()
 
255
 
 
256
    def update(self, msg=None, current_cnt=None, total_cnt=None):
 
257
        if msg and msg != self.last_msg:
 
258
            if self.need_nl:
 
259
                self.to_file.write('\n')
 
260
            self.to_file.write(msg + ': ')
 
261
            self.last_msg = msg
 
262
        self.need_nl = True
 
263
        self.to_file.write('.')
 
264
 
 
265
    def clear(self):
 
266
        if self.need_nl:
 
267
            self.to_file.write('\n')
 
268
        self.need_nl = False
 
269
 
 
270
    def child_update(self, message, current, total):
 
271
        self.tick()
 
272
 
 
273
 
 
274
class TTYProgressBar(_BaseProgressBar):
 
275
    """Progress bar display object.
 
276
 
 
277
    Several options are available to control the display.  These can
 
278
    be passed as parameters to the constructor or assigned at any time:
 
279
 
 
280
    show_pct
 
281
        Show percentage complete.
 
282
    show_spinner
 
283
        Show rotating baton.  This ticks over on every update even
 
284
        if the values don't change.
 
285
    show_eta
 
286
        Show predicted time-to-completion.
 
287
    show_bar
 
288
        Show bar graph.
 
289
    show_count
 
290
        Show numerical counts.
 
291
 
 
292
    The output file should be in line-buffered or unbuffered mode.
 
293
    """
 
294
    SPIN_CHARS = r'/-\|'
 
295
 
 
296
    @deprecated_function(deprecated_in((1, 16, 0)))
 
297
    def __init__(self, **kwargs):
 
298
        from bzrlib.osutils import terminal_width
 
299
        _BaseProgressBar.__init__(self, **kwargs)
 
300
        self.spin_pos = 0
 
301
        self.width = terminal_width()
 
302
        self.last_updates = []
 
303
        self._max_last_updates = 10
 
304
        self.child_fraction = 0
 
305
        self._have_output = False
 
306
 
 
307
    def throttle(self, old_msg):
 
308
        """Return True if the bar was updated too recently"""
 
309
        # time.time consistently takes 40/4000 ms = 0.01 ms.
 
310
        # time.clock() is faster, but gives us CPU time, not wall-clock time
 
311
        now = time.time()
 
312
        if self.start_time is not None and (now - self.start_time) < 1:
 
313
            return True
 
314
        if old_msg != self.last_msg:
 
315
            return False
 
316
        interval = now - self.last_update
 
317
        # if interval > 0
 
318
        if interval < self.MIN_PAUSE:
 
319
            return True
 
320
 
 
321
        self.last_updates.append(now - self.last_update)
 
322
        # Don't let the queue grow without bound
 
323
        self.last_updates = self.last_updates[-self._max_last_updates:]
 
324
        self.last_update = now
 
325
        return False
 
326
 
 
327
    def tick(self):
 
328
        self.update(self.last_msg, self.last_cnt, self.last_total,
 
329
                    self.child_fraction)
 
330
 
 
331
    def child_update(self, message, current, total):
 
332
        if current is not None and total != 0:
 
333
            child_fraction = float(current) / total
 
334
            if self.last_cnt is None:
 
335
                pass
 
336
            elif self.last_cnt + child_fraction <= self.last_total:
 
337
                self.child_fraction = child_fraction
 
338
        if self.last_msg is None:
 
339
            self.last_msg = ''
 
340
        self.tick()
 
341
 
 
342
    def update(self, msg, current_cnt=None, total_cnt=None,
 
343
            child_fraction=0):
 
344
        """Update and redraw progress bar.
 
345
        """
 
346
        if msg is None:
 
347
            msg = self.last_msg
 
348
 
 
349
        if total_cnt is None:
 
350
            total_cnt = self.last_total
 
351
 
 
352
        if current_cnt < 0:
 
353
            current_cnt = 0
 
354
 
 
355
        if current_cnt > total_cnt:
 
356
            total_cnt = current_cnt
 
357
 
 
358
        ## # optional corner case optimisation
 
359
        ## # currently does not seem to fire so costs more than saved.
 
360
        ## # trivial optimal case:
 
361
        ## # NB if callers are doing a clear and restore with
 
362
        ## # the saved values, this will prevent that:
 
363
        ## # in that case add a restore method that calls
 
364
        ## # _do_update or some such
 
365
        ## if (self.last_msg == msg and
 
366
        ##     self.last_cnt == current_cnt and
 
367
        ##     self.last_total == total_cnt and
 
368
        ##     self.child_fraction == child_fraction):
 
369
        ##     return
 
370
 
 
371
        if msg is None:
 
372
            msg = ''
 
373
 
 
374
        old_msg = self.last_msg
 
375
        # save these for the tick() function
 
376
        self.last_msg = msg
 
377
        self.last_cnt = current_cnt
 
378
        self.last_total = total_cnt
 
379
        self.child_fraction = child_fraction
 
380
 
 
381
        # each function call takes 20ms/4000 = 0.005 ms,
 
382
        # but multiple that by 4000 calls -> starts to cost.
 
383
        # so anything to make this function call faster
 
384
        # will improve base 'diff' time by up to 0.1 seconds.
 
385
        if self.throttle(old_msg):
 
386
            return
 
387
 
 
388
        if self.show_eta and self.start_time and self.last_total:
 
389
            eta = get_eta(self.start_time, self.last_cnt + self.child_fraction,
 
390
                    self.last_total, last_updates = self.last_updates)
 
391
            eta_str = " " + str_tdelta(eta)
 
392
        else:
 
393
            eta_str = ""
 
394
 
 
395
        if self.show_spinner:
 
396
            spin_str = self.SPIN_CHARS[self.spin_pos % 4] + ' '
 
397
        else:
 
398
            spin_str = ''
 
399
 
 
400
        # always update this; it's also used for the bar
 
401
        self.spin_pos += 1
 
402
 
 
403
        if self.show_pct and self.last_total and self.last_cnt:
 
404
            pct = 100.0 * ((self.last_cnt + self.child_fraction) / self.last_total)
 
405
            pct_str = ' (%5.1f%%)' % pct
 
406
        else:
 
407
            pct_str = ''
 
408
 
 
409
        if not self.show_count:
 
410
            count_str = ''
 
411
        elif self.last_cnt is None:
 
412
            count_str = ''
 
413
        elif self.last_total is None:
 
414
            count_str = ' %i' % (self.last_cnt)
 
415
        else:
 
416
            # make both fields the same size
 
417
            t = '%i' % (self.last_total)
 
418
            c = '%*i' % (len(t), self.last_cnt)
 
419
            count_str = ' ' + c + '/' + t
 
420
 
 
421
        if self.show_bar:
 
422
            # progress bar, if present, soaks up all remaining space
 
423
            cols = self.width - 1 - len(self.last_msg) - len(spin_str) - len(pct_str) \
 
424
                   - len(eta_str) - len(count_str) - 3
 
425
 
 
426
            if self.last_total:
 
427
                # number of markers highlighted in bar
 
428
                markers = int(round(float(cols) *
 
429
                              (self.last_cnt + self.child_fraction) / self.last_total))
 
430
                bar_str = '[' + ('=' * markers).ljust(cols) + '] '
 
431
            elif False:
 
432
                # don't know total, so can't show completion.
 
433
                # so just show an expanded spinning thingy
 
434
                m = self.spin_pos % cols
 
435
                ms = (' ' * m + '*').ljust(cols)
 
436
 
 
437
                bar_str = '[' + ms + '] '
 
438
            else:
 
439
                bar_str = ''
 
440
        else:
 
441
            bar_str = ''
 
442
 
 
443
        m = spin_str + bar_str + self.last_msg + count_str \
 
444
            + pct_str + eta_str
 
445
        self.to_file.write('\r%-*.*s' % (self.width - 1, self.width - 1, m))
 
446
        self._have_output = True
 
447
        #self.to_file.flush()
 
448
 
 
449
    def clear(self):
 
450
        if self._have_output:
 
451
            self.to_file.write('\r%s\r' % (' ' * (self.width - 1)))
 
452
        self._have_output = False
 
453
        #self.to_file.flush()
 
454
 
 
455
 
 
456
class ChildProgress(_BaseProgressBar):
 
457
    """A progress indicator that pushes its data to the parent"""
 
458
 
 
459
    @deprecated_function(deprecated_in((1, 16, 0)))
 
460
    def __init__(self, _stack, **kwargs):
 
461
        _BaseProgressBar.__init__(self, _stack=_stack, **kwargs)
 
462
        self.parent = _stack.top()
 
463
        self.current = None
 
464
        self.total = None
 
465
        self.child_fraction = 0
 
466
        self.message = None
 
467
 
 
468
    def update(self, msg, current_cnt=None, total_cnt=None):
 
469
        self.current = current_cnt
 
470
        if total_cnt is not None:
 
471
            self.total = total_cnt
 
472
        self.message = msg
 
473
        self.child_fraction = 0
 
474
        self.tick()
 
475
 
 
476
    def child_update(self, message, current, total):
 
477
        if current is None or total == 0:
 
478
            self.child_fraction = 0
 
479
        else:
 
480
            self.child_fraction = float(current) / total
 
481
        self.tick()
 
482
 
 
483
    def tick(self):
 
484
        if self.current is None:
 
485
            count = None
 
486
        else:
 
487
            count = self.current+self.child_fraction
 
488
            if count > self.total:
 
489
                if __debug__:
 
490
                    mutter('clamping count of %d to %d' % (count, self.total))
 
491
                count = self.total
 
492
        self.parent.child_update(self.message, count, self.total)
 
493
 
 
494
    def clear(self):
 
495
        pass
 
496
 
 
497
    def note(self, *args, **kwargs):
 
498
        self.parent.note(*args, **kwargs)
 
499
 
 
500
 
194
501
def str_tdelta(delt):
195
502
    if delt is None:
196
503
        return "-:--:--"
247
554
        else:
248
555
            self.cur_phase += 1
249
556
        self.pb.update(self.message, self.cur_phase, self.total)
 
557
 
 
558
 
 
559
_progress_bar_types = {}
 
560
_progress_bar_types['dummy'] = DummyProgress
 
561
_progress_bar_types['none'] = DummyProgress
 
562
_progress_bar_types['tty'] = TTYProgressBar
 
563
_progress_bar_types['dots'] = DotsProgressBar