/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: 2007-03-09 21:27:15 UTC
  • mfrom: (2328.1.1 jam-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20070309212715-07aacbc78b3e2dc0
(Dmitry Vasiliev) Improvements to osutils functions.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/progress.py
1
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
 
2
# Copyright (C) 2005, 2006 Canonical Ltd
 
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
17
 
18
18
 
19
19
"""Simple text-mode progress indicator.
35
35
# TODO: Optionally show elapsed time instead/as well as ETA; nicer
36
36
# when the rate is unpredictable
37
37
 
38
 
 
39
38
import sys
40
39
import time
41
40
import os
42
 
from collections import deque
43
 
 
44
 
 
45
 
import bzrlib.errors as errors
46
 
from bzrlib.trace import mutter 
 
41
 
 
42
from bzrlib.lazy_import import lazy_import
 
43
lazy_import(globals(), """
 
44
from bzrlib import (
 
45
    errors,
 
46
    )
 
47
""")
 
48
 
 
49
from bzrlib.trace import mutter
47
50
 
48
51
 
49
52
def _supports_progress(f):
50
 
    if not hasattr(f, 'isatty'):
 
53
    isatty = getattr(f, 'isatty', None)
 
54
    if isatty is None:
51
55
        return False
52
 
    if not f.isatty():
 
56
    if not isatty():
53
57
        return False
54
58
    if os.environ.get('TERM') == 'dumb':
55
59
        # e.g. emacs compile window
57
61
    return True
58
62
 
59
63
 
60
 
 
61
 
def ProgressBar(to_file=sys.stderr, **kwargs):
 
64
_progress_bar_types = {}
 
65
 
 
66
 
 
67
def ProgressBar(to_file=None, **kwargs):
62
68
    """Abstract factory"""
63
 
    if _supports_progress(to_file):
64
 
        return TTYProgressBar(to_file=to_file, **kwargs)
 
69
    if to_file is None:
 
70
        to_file = sys.stderr
 
71
    requested_bar_type = os.environ.get('BZR_PROGRESS_BAR')
 
72
    # An value of '' or not set reverts to standard processing
 
73
    if requested_bar_type in (None, ''):
 
74
        if _supports_progress(to_file):
 
75
            return TTYProgressBar(to_file=to_file, **kwargs)
 
76
        else:
 
77
            return DotsProgressBar(to_file=to_file, **kwargs)
65
78
    else:
66
 
        return DotsProgressBar(to_file=to_file, **kwargs)
67
 
    
 
79
        # Minor sanitation to prevent spurious errors
 
80
        requested_bar_type = requested_bar_type.lower().strip()
 
81
        # TODO: jam 20060710 Arguably we shouldn't raise an exception
 
82
        #       but should instead just disable progress bars if we
 
83
        #       don't recognize the type
 
84
        if requested_bar_type not in _progress_bar_types:
 
85
            raise errors.InvalidProgressBarType(requested_bar_type,
 
86
                                                _progress_bar_types.keys())
 
87
        return _progress_bar_types[requested_bar_type](to_file=to_file, **kwargs)
 
88
 
68
89
 
69
90
class ProgressBarStack(object):
70
91
    """A stack of progress bars."""
71
92
 
72
93
    def __init__(self,
73
 
                 to_file=sys.stderr,
 
94
                 to_file=None,
74
95
                 show_pct=False,
75
96
                 show_spinner=True,
76
97
                 show_eta=False,
77
98
                 show_bar=True,
78
99
                 show_count=True,
79
 
                 to_messages_file=sys.stdout,
 
100
                 to_messages_file=None,
80
101
                 klass=None):
81
102
        """Setup the stack with the parameters the progress bars should have."""
 
103
        if to_file is None:
 
104
            to_file = sys.stderr
 
105
        if to_messages_file is None:
 
106
            to_messages_file = sys.stdout
82
107
        self._to_file = to_file
83
108
        self._show_pct = show_pct
84
109
        self._show_spinner = show_spinner
87
112
        self._show_count = show_count
88
113
        self._to_messages_file = to_messages_file
89
114
        self._stack = []
90
 
        self._klass = klass or TTYProgressBar
 
115
        self._klass = klass or ProgressBar
91
116
 
92
117
    def top(self):
93
118
        if len(self._stack) != 0:
128
153
class _BaseProgressBar(object):
129
154
 
130
155
    def __init__(self,
131
 
                 to_file=sys.stderr,
 
156
                 to_file=None,
132
157
                 show_pct=False,
133
158
                 show_spinner=False,
134
 
                 show_eta=True,
 
159
                 show_eta=False,
135
160
                 show_bar=True,
136
161
                 show_count=True,
137
 
                 to_messages_file=sys.stdout,
 
162
                 to_messages_file=None,
138
163
                 _stack=None):
139
164
        object.__init__(self)
 
165
        if to_file is None:
 
166
            to_file = sys.stderr
 
167
        if to_messages_file is None:
 
168
            to_messages_file = sys.stdout
140
169
        self.to_file = to_file
141
170
        self.to_messages_file = to_messages_file
142
171
        self.last_msg = None
150
179
        self._stack = _stack
151
180
        # seed throttler
152
181
        self.MIN_PAUSE = 0.1 # seconds
153
 
        now = time.clock()
 
182
        now = time.time()
154
183
        # starting now
155
184
        self.start_time = now
156
185
        # next update should not throttle
195
224
    def child_progress(self, **kwargs):
196
225
        return DummyProgress(**kwargs)
197
226
 
 
227
 
 
228
_progress_bar_types['dummy'] = DummyProgress
 
229
_progress_bar_types['none'] = DummyProgress
 
230
 
 
231
 
198
232
class DotsProgressBar(_BaseProgressBar):
199
233
 
200
234
    def __init__(self, **kwargs):
209
243
        if msg and msg != self.last_msg:
210
244
            if self.need_nl:
211
245
                self.to_file.write('\n')
212
 
            
213
246
            self.to_file.write(msg + ': ')
214
247
            self.last_msg = msg
215
248
        self.need_nl = True
218
251
    def clear(self):
219
252
        if self.need_nl:
220
253
            self.to_file.write('\n')
 
254
        self.need_nl = False
221
255
        
222
256
    def child_update(self, message, current, total):
223
257
        self.tick()
 
258
 
 
259
 
 
260
_progress_bar_types['dots'] = DotsProgressBar
 
261
 
224
262
    
225
263
class TTYProgressBar(_BaseProgressBar):
226
264
    """Progress bar display object.
250
288
        _BaseProgressBar.__init__(self, **kwargs)
251
289
        self.spin_pos = 0
252
290
        self.width = terminal_width()
253
 
        self.start_time = None
254
 
        self.last_updates = deque()
 
291
        self.last_updates = []
 
292
        self._max_last_updates = 10
255
293
        self.child_fraction = 0
 
294
        self._have_output = False
256
295
    
257
296
 
258
 
    def throttle(self):
 
297
    def throttle(self, old_msg):
259
298
        """Return True if the bar was updated too recently"""
260
299
        # 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()
 
300
        # time.clock() is faster, but gives us CPU time, not wall-clock time
 
301
        now = time.time()
 
302
        if self.start_time is not None and (now - self.start_time) < 1:
 
303
            return True
 
304
        if old_msg != self.last_msg:
 
305
            return False
267
306
        interval = now - self.last_update
268
307
        # if interval > 0
269
308
        if interval < self.MIN_PAUSE:
270
309
            return True
271
310
 
272
311
        self.last_updates.append(now - self.last_update)
 
312
        # Don't let the queue grow without bound
 
313
        self.last_updates = self.last_updates[-self._max_last_updates:]
273
314
        self.last_update = now
274
315
        return False
275
316
        
276
 
 
277
317
    def tick(self):
278
318
        self.update(self.last_msg, self.last_cnt, self.last_total, 
279
319
                    self.child_fraction)
291
331
            self.last_msg = ''
292
332
        self.tick()
293
333
 
294
 
 
295
334
    def update(self, msg, current_cnt=None, total_cnt=None, 
296
335
               child_fraction=0):
297
336
        """Update and redraw progress bar."""
 
337
        if msg is None:
 
338
            msg = self.last_msg
 
339
 
 
340
        if total_cnt is None:
 
341
            total_cnt = self.last_total
298
342
 
299
343
        if current_cnt < 0:
300
344
            current_cnt = 0
326
370
        # but multiple that by 4000 calls -> starts to cost.
327
371
        # so anything to make this function call faster
328
372
        # will improve base 'diff' time by up to 0.1 seconds.
329
 
        if old_msg == self.last_msg and self.throttle():
 
373
        if self.throttle(old_msg):
330
374
            return
331
375
 
332
376
        if self.show_eta and self.start_time and self.last_total:
385
429
            bar_str = ''
386
430
 
387
431
        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))
 
432
        self.to_file.write('\r%-*.*s' % (self.width - 1, self.width - 1, m))
 
433
        self._have_output = True
391
434
        #self.to_file.flush()
392
435
            
393
436
    def clear(self):        
394
 
        self.to_file.write('\r%s\r' % (' ' * (self.width - 1)))
 
437
        if self._have_output:
 
438
            self.to_file.write('\r%s\r' % (' ' * (self.width - 1)))
 
439
        self._have_output = False
395
440
        #self.to_file.flush()        
396
441
 
397
442
 
 
443
_progress_bar_types['tty'] = TTYProgressBar
 
444
 
 
445
 
398
446
class ChildProgress(_BaseProgressBar):
399
447
    """A progress indicator that pushes its data to the parent"""
 
448
 
400
449
    def __init__(self, _stack, **kwargs):
401
450
        _BaseProgressBar.__init__(self, _stack=_stack, **kwargs)
402
451
        self.parent = _stack.top()
459
508
    if current > total:
460
509
        return None                     # wtf?
461
510
 
462
 
    elapsed = time.clock() - start_time
 
511
    elapsed = time.time() - start_time
463
512
 
464
513
    if elapsed < 2.0:                   # not enough time to estimate
465
514
        return None
469
518
    assert total_duration >= elapsed
470
519
 
471
520
    if last_updates and len(last_updates) >= n_recent:
472
 
        while len(last_updates) > n_recent:
473
 
            last_updates.popleft()
474
521
        avg = sum(last_updates) / float(len(last_updates))
475
522
        time_left = avg * (total - current)
476
523