← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/progress.py

  • Committer: John Arbash Meinel
  • Date: 2009-03-27 22:29:55 UTC
  • mto: (3735.39.2 clean)
  • mto: This revision was merged to the branch mainline in revision 4280.
  • Revision ID: john@arbash-meinel.com-20090327222955-utifmfm888zerixt
Implement apply_delta_to_source which doesn't have to malloc another string.

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 (
31
39
    deprecated_in,
32
40
    deprecated_method,
34
42
 
35
43
 
36
44
def _supports_progress(f):
37
 
    """Detect if we can use pretty progress bars on file F.
 
45
    """Detect if we can use pretty progress bars on the output stream f.
38
46
 
39
47
    If this returns true we expect that a human may be looking at that
40
48
    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
49
    """
44
50
    isatty = getattr(f, 'isatty', None)
45
51
    if isatty is None:
46
52
        return False
47
53
    if not isatty():
48
54
        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
55
    if os.environ.get('TERM') == 'dumb':
54
56
        # e.g. emacs compile window
55
57
        return False
65
67
    Code updating the task may also set fields as hints about how to display
66
68
    it: show_pct, show_spinner, show_eta, show_count, show_bar.  UIs
67
69
    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
70
    """
78
71
 
79
 
    def __init__(self, parent_task=None, ui_factory=None, progress_view=None):
 
72
    def __init__(self, parent_task=None, ui_factory=None):
80
73
        """Construct a new progress task.
81
74
 
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
75
        Normally you should not call this directly but rather through
90
76
        `ui_factory.nested_progress_bar`.
91
77
        """
94
80
        self.total_cnt = None
95
81
        self.current_cnt = None
96
82
        self.msg = ''
97
 
        # TODO: deprecate passing ui_factory
98
83
        self.ui_factory = ui_factory
99
 
        self.progress_view = progress_view
100
84
        self.show_pct = False
101
85
        self.show_spinner = True
102
86
        self.show_eta = False,
103
87
        self.show_count = True
104
88
        self.show_bar = True
105
 
        self.update_latency = 0.1
106
 
        self.show_transport_activity = True
107
89
 
108
90
    def __repr__(self):
109
91
        return '%s(%r/%r, msg=%r)' % (
117
99
        self.current_cnt = current_cnt
118
100
        if total_cnt:
119
101
            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)
 
102
        self.ui_factory._progress_updated(self)
124
103
 
125
104
    def tick(self):
126
105
        self.update(self.msg)
127
106
 
128
107
    def finished(self):
129
 
        if self.progress_view:
130
 
            self.progress_view.task_finished(self)
131
 
        else:
132
 
            self.ui_factory._progress_finished(self)
 
108
        self.ui_factory._progress_finished(self)
133
109
 
134
110
    def make_sub_task(self):
135
 
        return ProgressTask(self, ui_factory=self.ui_factory,
136
 
            progress_view=self.progress_view)
 
111
        return ProgressTask(self, self.ui_factory)
137
112
 
138
113
    def _overall_completion_fraction(self, child_fraction=0.0):
139
114
        """Return fractional completion of this task and its parents
152
127
                own_fraction = 0.0
153
128
            return self._parent_task._overall_completion_fraction(own_fraction)
154
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
 
155
138
    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()
165
 
        else:
166
 
            self.ui_factory.clear_term()
167
 
 
168
 
 
169
 
# NOTE: This is also deprecated; you should provide a ProgressView instead.
 
139
        # XXX: shouldn't be here; put it in mutter or the ui instead
 
140
        self.ui_factory.clear_term()
 
141
 
 
142
 
 
143
def ProgressBar(to_file=None, **kwargs):
 
144
    """Abstract factory"""
 
145
    if to_file is None:
 
146
        to_file = sys.stderr
 
147
    requested_bar_type = os.environ.get('BZR_PROGRESS_BAR')
 
148
    # An value of '' or not set reverts to standard processing
 
149
    if requested_bar_type in (None, ''):
 
150
        if _supports_progress(to_file):
 
151
            return TTYProgressBar(to_file=to_file, **kwargs)
 
152
        else:
 
153
            return DummyProgress(to_file=to_file, **kwargs)
 
154
    else:
 
155
        # Minor sanitation to prevent spurious errors
 
156
        requested_bar_type = requested_bar_type.lower().strip()
 
157
        # TODO: jam 20060710 Arguably we shouldn't raise an exception
 
158
        #       but should instead just disable progress bars if we
 
159
        #       don't recognize the type
 
160
        if requested_bar_type not in _progress_bar_types:
 
161
            raise errors.InvalidProgressBarType(requested_bar_type,
 
162
                                                _progress_bar_types.keys())
 
163
        return _progress_bar_types[requested_bar_type](to_file=to_file, **kwargs)
 
164
 
 
165
 
 
166
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)))
 
174
    def __init__(self,
 
175
                 to_file=None,
 
176
                 show_pct=False,
 
177
                 show_spinner=True,
 
178
                 show_eta=False,
 
179
                 show_bar=True,
 
180
                 show_count=True,
 
181
                 to_messages_file=None,
 
182
                 klass=None):
 
183
        """Setup the stack with the parameters the progress bars should have."""
 
184
        if to_file is None:
 
185
            to_file = sys.stderr
 
186
        if to_messages_file is None:
 
187
            to_messages_file = sys.stdout
 
188
        self._to_file = to_file
 
189
        self._show_pct = show_pct
 
190
        self._show_spinner = show_spinner
 
191
        self._show_eta = show_eta
 
192
        self._show_bar = show_bar
 
193
        self._show_count = show_count
 
194
        self._to_messages_file = to_messages_file
 
195
        self._stack = []
 
196
        self._klass = klass or ProgressBar
 
197
 
 
198
    def top(self):
 
199
        if len(self._stack) != 0:
 
200
            return self._stack[-1]
 
201
        else:
 
202
            return None
 
203
 
 
204
    def bottom(self):
 
205
        if len(self._stack) != 0:
 
206
            return self._stack[0]
 
207
        else:
 
208
            return None
 
209
 
 
210
    def get_nested(self):
 
211
        """Return a nested progress bar."""
 
212
        if len(self._stack) == 0:
 
213
            func = self._klass
 
214
        else:
 
215
            func = self.top().child_progress
 
216
        new_bar = func(to_file=self._to_file,
 
217
                       show_pct=self._show_pct,
 
218
                       show_spinner=self._show_spinner,
 
219
                       show_eta=self._show_eta,
 
220
                       show_bar=self._show_bar,
 
221
                       show_count=self._show_count,
 
222
                       to_messages_file=self._to_messages_file,
 
223
                       _stack=self)
 
224
        self._stack.append(new_bar)
 
225
        return new_bar
 
226
 
 
227
    def return_pb(self, bar):
 
228
        """Return bar after its been used."""
 
229
        if bar is not self._stack[-1]:
 
230
            warnings.warn("%r is not currently active" % (bar,))
 
231
        else:
 
232
            self._stack.pop()
 
233
 
 
234
 
170
235
class _BaseProgressBar(object):
171
236
 
172
237
    def __init__(self,
207
272
        self.clear()
208
273
        self._stack.return_pb(self)
209
274
 
210
 
 
211
 
class DummyProgress(object):
 
275
    def note(self, fmt_string, *args, **kwargs):
 
276
        """Record a note without disrupting the progress bar."""
 
277
        self.clear()
 
278
        self.to_messages_file.write(fmt_string % args)
 
279
        self.to_messages_file.write('\n')
 
280
 
 
281
    def child_progress(self, **kwargs):
 
282
        return ChildProgress(**kwargs)
 
283
 
 
284
 
 
285
class DummyProgress(_BaseProgressBar):
212
286
    """Progress-bar standin that does nothing.
213
287
 
214
 
    This was previously often constructed by application code if no progress
215
 
    bar was explicitly passed in.  That's no longer recommended: instead, just
216
 
    create a progress task from the ui_factory.  This class can be used in
217
 
    test code that needs to fake a progress task for some reason.
218
 
    """
 
288
    This can be used as the default argument for methods that
 
289
    take an optional progress indicator."""
219
290
 
220
291
    def tick(self):
221
292
        pass
229
300
    def clear(self):
230
301
        pass
231
302
 
 
303
    def note(self, fmt_string, *args, **kwargs):
 
304
        """See _BaseProgressBar.note()."""
 
305
 
232
306
    def child_progress(self, **kwargs):
233
307
        return DummyProgress(**kwargs)
234
308
 
235
309
 
 
310
class DotsProgressBar(_BaseProgressBar):
 
311
 
 
312
    def __init__(self, **kwargs):
 
313
        _BaseProgressBar.__init__(self, **kwargs)
 
314
        self.last_msg = None
 
315
        self.need_nl = False
 
316
 
 
317
    def tick(self):
 
318
        self.update()
 
319
 
 
320
    def update(self, msg=None, current_cnt=None, total_cnt=None):
 
321
        if msg and msg != self.last_msg:
 
322
            if self.need_nl:
 
323
                self.to_file.write('\n')
 
324
            self.to_file.write(msg + ': ')
 
325
            self.last_msg = msg
 
326
        self.need_nl = True
 
327
        self.to_file.write('.')
 
328
 
 
329
    def clear(self):
 
330
        if self.need_nl:
 
331
            self.to_file.write('\n')
 
332
        self.need_nl = False
 
333
 
 
334
    def child_update(self, message, current, total):
 
335
        self.tick()
 
336
 
 
337
 
 
338
 
 
339
 
 
340
class TTYProgressBar(_BaseProgressBar):
 
341
    """Progress bar display object.
 
342
 
 
343
    Several options are available to control the display.  These can
 
344
    be passed as parameters to the constructor or assigned at any time:
 
345
 
 
346
    show_pct
 
347
        Show percentage complete.
 
348
    show_spinner
 
349
        Show rotating baton.  This ticks over on every update even
 
350
        if the values don't change.
 
351
    show_eta
 
352
        Show predicted time-to-completion.
 
353
    show_bar
 
354
        Show bar graph.
 
355
    show_count
 
356
        Show numerical counts.
 
357
 
 
358
    The output file should be in line-buffered or unbuffered mode.
 
359
    """
 
360
    SPIN_CHARS = r'/-\|'
 
361
 
 
362
 
 
363
    def __init__(self, **kwargs):
 
364
        from bzrlib.osutils import terminal_width
 
365
        _BaseProgressBar.__init__(self, **kwargs)
 
366
        self.spin_pos = 0
 
367
        self.width = terminal_width()
 
368
        self.last_updates = []
 
369
        self._max_last_updates = 10
 
370
        self.child_fraction = 0
 
371
        self._have_output = False
 
372
 
 
373
    def throttle(self, old_msg):
 
374
        """Return True if the bar was updated too recently"""
 
375
        # time.time consistently takes 40/4000 ms = 0.01 ms.
 
376
        # time.clock() is faster, but gives us CPU time, not wall-clock time
 
377
        now = time.time()
 
378
        if self.start_time is not None and (now - self.start_time) < 1:
 
379
            return True
 
380
        if old_msg != self.last_msg:
 
381
            return False
 
382
        interval = now - self.last_update
 
383
        # if interval > 0
 
384
        if interval < self.MIN_PAUSE:
 
385
            return True
 
386
 
 
387
        self.last_updates.append(now - self.last_update)
 
388
        # Don't let the queue grow without bound
 
389
        self.last_updates = self.last_updates[-self._max_last_updates:]
 
390
        self.last_update = now
 
391
        return False
 
392
 
 
393
    def tick(self):
 
394
        self.update(self.last_msg, self.last_cnt, self.last_total,
 
395
                    self.child_fraction)
 
396
 
 
397
    def child_update(self, message, current, total):
 
398
        if current is not None and total != 0:
 
399
            child_fraction = float(current) / total
 
400
            if self.last_cnt is None:
 
401
                pass
 
402
            elif self.last_cnt + child_fraction <= self.last_total:
 
403
                self.child_fraction = child_fraction
 
404
        if self.last_msg is None:
 
405
            self.last_msg = ''
 
406
        self.tick()
 
407
 
 
408
    def update(self, msg, current_cnt=None, total_cnt=None,
 
409
            child_fraction=0):
 
410
        """Update and redraw progress bar.
 
411
        """
 
412
        if msg is None:
 
413
            msg = self.last_msg
 
414
 
 
415
        if total_cnt is None:
 
416
            total_cnt = self.last_total
 
417
 
 
418
        if current_cnt < 0:
 
419
            current_cnt = 0
 
420
 
 
421
        if current_cnt > total_cnt:
 
422
            total_cnt = current_cnt
 
423
 
 
424
        ## # optional corner case optimisation
 
425
        ## # currently does not seem to fire so costs more than saved.
 
426
        ## # trivial optimal case:
 
427
        ## # NB if callers are doing a clear and restore with
 
428
        ## # the saved values, this will prevent that:
 
429
        ## # in that case add a restore method that calls
 
430
        ## # _do_update or some such
 
431
        ## if (self.last_msg == msg and
 
432
        ##     self.last_cnt == current_cnt and
 
433
        ##     self.last_total == total_cnt and
 
434
        ##     self.child_fraction == child_fraction):
 
435
        ##     return
 
436
 
 
437
        if msg is None:
 
438
            msg = ''
 
439
 
 
440
        old_msg = self.last_msg
 
441
        # save these for the tick() function
 
442
        self.last_msg = msg
 
443
        self.last_cnt = current_cnt
 
444
        self.last_total = total_cnt
 
445
        self.child_fraction = child_fraction
 
446
 
 
447
        # each function call takes 20ms/4000 = 0.005 ms,
 
448
        # but multiple that by 4000 calls -> starts to cost.
 
449
        # so anything to make this function call faster
 
450
        # will improve base 'diff' time by up to 0.1 seconds.
 
451
        if self.throttle(old_msg):
 
452
            return
 
453
 
 
454
        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,
 
456
                    self.last_total, last_updates = self.last_updates)
 
457
            eta_str = " " + str_tdelta(eta)
 
458
        else:
 
459
            eta_str = ""
 
460
 
 
461
        if self.show_spinner:
 
462
            spin_str = self.SPIN_CHARS[self.spin_pos % 4] + ' '
 
463
        else:
 
464
            spin_str = ''
 
465
 
 
466
        # always update this; it's also used for the bar
 
467
        self.spin_pos += 1
 
468
 
 
469
        if self.show_pct and self.last_total and self.last_cnt:
 
470
            pct = 100.0 * ((self.last_cnt + self.child_fraction) / self.last_total)
 
471
            pct_str = ' (%5.1f%%)' % pct
 
472
        else:
 
473
            pct_str = ''
 
474
 
 
475
        if not self.show_count:
 
476
            count_str = ''
 
477
        elif self.last_cnt is None:
 
478
            count_str = ''
 
479
        elif self.last_total is None:
 
480
            count_str = ' %i' % (self.last_cnt)
 
481
        else:
 
482
            # make both fields the same size
 
483
            t = '%i' % (self.last_total)
 
484
            c = '%*i' % (len(t), self.last_cnt)
 
485
            count_str = ' ' + c + '/' + t
 
486
 
 
487
        if self.show_bar:
 
488
            # progress bar, if present, soaks up all remaining space
 
489
            cols = self.width - 1 - len(self.last_msg) - len(spin_str) - len(pct_str) \
 
490
                   - len(eta_str) - len(count_str) - 3
 
491
 
 
492
            if self.last_total:
 
493
                # number of markers highlighted in bar
 
494
                markers = int(round(float(cols) *
 
495
                              (self.last_cnt + self.child_fraction) / self.last_total))
 
496
                bar_str = '[' + ('=' * markers).ljust(cols) + '] '
 
497
            elif False:
 
498
                # don't know total, so can't show completion.
 
499
                # so just show an expanded spinning thingy
 
500
                m = self.spin_pos % cols
 
501
                ms = (' ' * m + '*').ljust(cols)
 
502
 
 
503
                bar_str = '[' + ms + '] '
 
504
            else:
 
505
                bar_str = ''
 
506
        else:
 
507
            bar_str = ''
 
508
 
 
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))
 
512
        self._have_output = True
 
513
        #self.to_file.flush()
 
514
 
 
515
    def clear(self):
 
516
        if self._have_output:
 
517
            self.to_file.write('\r%s\r' % (' ' * (self.width - 1)))
 
518
        self._have_output = False
 
519
        #self.to_file.flush()
 
520
 
 
521
 
 
522
 
 
523
 
 
524
class ChildProgress(_BaseProgressBar):
 
525
    """A progress indicator that pushes its data to the parent"""
 
526
 
 
527
    def __init__(self, _stack, **kwargs):
 
528
        _BaseProgressBar.__init__(self, _stack=_stack, **kwargs)
 
529
        self.parent = _stack.top()
 
530
        self.current = None
 
531
        self.total = None
 
532
        self.child_fraction = 0
 
533
        self.message = None
 
534
 
 
535
    def update(self, msg, current_cnt=None, total_cnt=None):
 
536
        self.current = current_cnt
 
537
        if total_cnt is not None:
 
538
            self.total = total_cnt
 
539
        self.message = msg
 
540
        self.child_fraction = 0
 
541
        self.tick()
 
542
 
 
543
    def child_update(self, message, current, total):
 
544
        if current is None or total == 0:
 
545
            self.child_fraction = 0
 
546
        else:
 
547
            self.child_fraction = float(current) / total
 
548
        self.tick()
 
549
 
 
550
    def tick(self):
 
551
        if self.current is None:
 
552
            count = None
 
553
        else:
 
554
            count = self.current+self.child_fraction
 
555
            if count > self.total:
 
556
                if __debug__:
 
557
                    mutter('clamping count of %d to %d' % (count, self.total))
 
558
                count = self.total
 
559
        self.parent.child_update(self.message, count, self.total)
 
560
 
 
561
    def clear(self):
 
562
        pass
 
563
 
 
564
    def note(self, *args, **kwargs):
 
565
        self.parent.note(*args, **kwargs)
 
566
 
 
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
 
236
585
def str_tdelta(delt):
237
586
    if delt is None:
238
587
        return "-:--:--"
289
638
        else:
290
639
            self.cur_phase += 1
291
640
        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