/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

Fix formatting, remove catch-all for exceptions when opening local repositories.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/progress.py
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.
22
 
"""
23
 
 
24
 
 
25
 
import sys
26
 
import time
27
 
import os
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_function,
40
 
    deprecated_in,
41
 
    deprecated_method,
42
 
    )
43
 
 
44
 
 
45
 
# XXX: deprecated; can be removed when the ProgressBar factory is removed
46
 
def _supports_progress(f):
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:
54
 
        return False
55
 
    if not isatty():
56
 
        return False
57
 
    if os.environ.get('TERM') == 'dumb':
58
 
        # e.g. emacs compile window
59
 
        return False
60
 
    return True
61
 
 
62
 
 
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
 
        """Construct a new progress task.
76
 
 
77
 
        Normally you should not call this directly but rather through
78
 
        `ui_factory.nested_progress_bar`.
79
 
        """
80
 
        self._parent_task = parent_task
81
 
        self._last_update = 0
82
 
        self.total_cnt = None
83
 
        self.current_cnt = None
84
 
        self.msg = ''
85
 
        self.ui_factory = ui_factory
86
 
        self.show_pct = False
87
 
        self.show_spinner = True
88
 
        self.show_eta = False,
89
 
        self.show_count = True
90
 
        self.show_bar = True
91
 
 
92
 
    def __repr__(self):
93
 
        return '%s(%r/%r, msg=%r)' % (
94
 
            self.__class__.__name__,
95
 
            self.current_cnt,
96
 
            self.total_cnt,
97
 
            self.msg)
98
 
 
99
 
    def update(self, msg, current_cnt=None, total_cnt=None):
100
 
        self.msg = msg
101
 
        self.current_cnt = current_cnt
102
 
        if total_cnt:
103
 
            self.total_cnt = total_cnt
104
 
        self.ui_factory._progress_updated(self)
105
 
 
106
 
    def tick(self):
107
 
        self.update(self.msg)
108
 
 
109
 
    def finished(self):
110
 
        self.ui_factory._progress_finished(self)
111
 
 
112
 
    def make_sub_task(self):
113
 
        return ProgressTask(self, self.ui_factory)
114
 
 
115
 
    def _overall_completion_fraction(self, child_fraction=0.0):
116
 
        """Return fractional completion of this task and its parents
117
 
 
118
 
        Returns None if no completion can be computed."""
119
 
        if self.current_cnt is not None and self.total_cnt:
120
 
            own_fraction = (float(self.current_cnt) + child_fraction) / self.total_cnt
121
 
        else:
122
 
            # if this task has no estimation, it just passes on directly
123
 
            # whatever the child has measured...
124
 
            own_fraction = child_fraction
125
 
        if self._parent_task is None:
126
 
            return own_fraction
127
 
        else:
128
 
            if own_fraction is None:
129
 
                own_fraction = 0.0
130
 
            return self._parent_task._overall_completion_fraction(own_fraction)
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
 
 
140
 
    def clear(self):
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)
155
 
        else:
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):
221
 
    """Progress-bar standin that does nothing.
222
 
 
223
 
    This can be used as the default argument for methods that
224
 
    take an optional progress indicator."""
225
 
 
226
 
    def tick(self):
227
 
        pass
228
 
 
229
 
    def update(self, msg=None, current=None, total=None):
230
 
        pass
231
 
 
232
 
    def child_update(self, message, current, total):
233
 
        pass
234
 
 
235
 
    def clear(self):
236
 
        pass
237
 
 
238
 
    def note(self, fmt_string, *args, **kwargs):
239
 
        """See _BaseProgressBar.note()."""
240
 
 
241
 
    def child_progress(self, **kwargs):
242
 
        return DummyProgress(**kwargs)
243
 
 
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
 
 
501
 
def str_tdelta(delt):
502
 
    if delt is None:
503
 
        return "-:--:--"
504
 
    delt = int(round(delt))
505
 
    return '%d:%02d:%02d' % (delt/3600,
506
 
                             (delt/60) % 60,
507
 
                             delt % 60)
508
 
 
509
 
 
510
 
def get_eta(start_time, current, total, enough_samples=3, last_updates=None, n_recent=10):
511
 
    if start_time is None:
512
 
        return None
513
 
 
514
 
    if not total:
515
 
        return None
516
 
 
517
 
    if current < enough_samples:
518
 
        return None
519
 
 
520
 
    if current > total:
521
 
        return None                     # wtf?
522
 
 
523
 
    elapsed = time.time() - start_time
524
 
 
525
 
    if elapsed < 2.0:                   # not enough time to estimate
526
 
        return None
527
 
 
528
 
    total_duration = float(elapsed) * float(total) / float(current)
529
 
 
530
 
    if last_updates and len(last_updates) >= n_recent:
531
 
        avg = sum(last_updates) / float(len(last_updates))
532
 
        time_left = avg * (total - current)
533
 
 
534
 
        old_time_left = total_duration - elapsed
535
 
 
536
 
        # We could return the average, or some other value here
537
 
        return (time_left + old_time_left) / 2
538
 
 
539
 
    return total_duration - elapsed
540
 
 
541
 
 
542
 
class ProgressPhase(object):
543
 
    """Update progress object with the current phase"""
544
 
    def __init__(self, message, total, pb):
545
 
        object.__init__(self)
546
 
        self.pb = pb
547
 
        self.message = message
548
 
        self.total = total
549
 
        self.cur_phase = None
550
 
 
551
 
    def next_phase(self):
552
 
        if self.cur_phase is None:
553
 
            self.cur_phase = 0
554
 
        else:
555
 
            self.cur_phase += 1
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