← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/progress.py

  • Committer: Martin Pool
  • Date: 2005-08-04 22:30:50 UTC
  • Revision ID: mbp@sourcefrog.net-20050804223050-01256e5e26a90b1d
- merge patch to take ranges to diff -r option

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/progress.py
39
39
import sys
40
40
import time
41
41
import os
42
 
from collections import deque
 
42
 
 
43
 
 
44
def _width():
 
45
    """Return estimated terminal width.
 
46
 
 
47
    TODO: Do something smart on Windows?
 
48
 
 
49
    TODO: Is there anything that gets a better update when the window
 
50
          is resized while the program is running?
 
51
    """
 
52
    try:
 
53
        return int(os.environ['COLUMNS'])
 
54
    except (IndexError, KeyError, ValueError):
 
55
        return 80
43
56
 
44
57
 
45
58
def _supports_progress(f):
81
94
        self.show_eta = show_eta
82
95
        self.show_bar = show_bar
83
96
        self.show_count = show_count
84
 
 
85
 
 
86
 
 
87
 
class DummyProgress(_BaseProgressBar):
88
 
    """Progress-bar standin that does nothing.
89
 
 
90
 
    This can be used as the default argument for methods that
91
 
    take an optional progress indicator."""
92
 
    def tick(self):
93
 
        pass
94
 
 
95
 
    def update(self, msg=None, current=None, total=None):
96
 
        pass
97
 
 
98
 
    def clear(self):
99
 
        pass
 
97
        
100
98
        
101
99
    
102
100
class DotsProgressBar(_BaseProgressBar):
148
146
 
149
147
 
150
148
    def __init__(self, **kwargs):
151
 
        from bzrlib.osutils import terminal_width
152
149
        _BaseProgressBar.__init__(self, **kwargs)
153
150
        self.spin_pos = 0
154
 
        self.width = terminal_width()
 
151
        self.width = _width()
155
152
        self.start_time = None
156
153
        self.last_update = None
157
 
        self.last_updates = deque()
158
154
    
159
155
 
160
156
    def throttle(self):
168
164
            if interval > 0 and interval < self.MIN_PAUSE:
169
165
                return True
170
166
 
171
 
        self.last_updates.append(now - self.last_update)
172
167
        self.last_update = now
173
168
        return False
174
169
        
181
176
    def update(self, msg, current_cnt=None, total_cnt=None):
182
177
        """Update and redraw progress bar."""
183
178
 
184
 
        if current_cnt < 0:
185
 
            current_cnt = 0
186
 
            
187
 
        if current_cnt > total_cnt:
188
 
            total_cnt = current_cnt
189
 
 
190
179
        # save these for the tick() function
191
180
        self.last_msg = msg
192
181
        self.last_cnt = current_cnt
195
184
        if self.throttle():
196
185
            return 
197
186
        
 
187
        if total_cnt:
 
188
            assert current_cnt <= total_cnt
 
189
        if current_cnt:
 
190
            assert current_cnt >= 0
 
191
        
198
192
        if self.show_eta and self.start_time and total_cnt:
199
 
            eta = get_eta(self.start_time, current_cnt, total_cnt,
200
 
                    last_updates = self.last_updates)
 
193
            eta = get_eta(self.start_time, current_cnt, total_cnt)
201
194
            eta_str = " " + str_tdelta(eta)
202
195
        else:
203
196
            eta_str = ""
271
264
                             delt % 60)
272
265
 
273
266
 
274
 
def get_eta(start_time, current, total, enough_samples=3, last_updates=None, n_recent=10):
 
267
def get_eta(start_time, current, total, enough_samples=3):
275
268
    if start_time is None:
276
269
        return None
277
270
 
293
286
 
294
287
    assert total_duration >= elapsed
295
288
 
296
 
    if last_updates and len(last_updates) >= n_recent:
297
 
        while len(last_updates) > n_recent:
298
 
            last_updates.popleft()
299
 
        avg = sum(last_updates) / float(len(last_updates))
300
 
        time_left = avg * (total - current)
301
 
 
302
 
        old_time_left = total_duration - elapsed
303
 
 
304
 
        # We could return the average, or some other value here
305
 
        return (time_left + old_time_left) / 2
306
 
 
307
289
    return total_duration - elapsed
308
290
 
309
291