/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: v.ladeuil+lp at free
  • Date: 2006-10-12 14:29:32 UTC
  • mto: (2145.1.1 keepalive)
  • mto: This revision was merged to the branch mainline in revision 2146.
  • Revision ID: v.ladeuil+lp@free.fr-20061012142932-7221fe16d2b48fa3
Shuffle http related test code. Hopefully it ends up at the right place :)

* bzrlib/tests/HttpServer.py: 
New file. bzrlib.tests.ChrootedTestCase use HttpServer. So the
class can't be defined in bzrlib.tests.HTTPUtils because it
creates a circular dependency (bzrlib.tests.HTTPUtils needs to
import bzrlib.tests).

* bzrlib/transport/http/_urllib.py: 
Transfer test server definition to bzrlib.tests.HttpServer. Clean
up imports.

* bzrlib/transport/http/_pycurl.py: 
Transfer test server definition to bzrlib.tests.HttpServer. Clean
up imports.

* bzrlib/transport/http/__init__.py: 
Transfer all test related code to either bzrlib.tests.HttpServer
and bzrlib.tests.HTTPUtils.
Fix all use of TransportNotPossible and InvalidURL by prefixing it
by 'errors.' (this seems to be the preferred way in the rest of
bzr).
Get rid of unused imports.

* bzrlib/tests/test_transport.py:
(ReadonlyDecoratorTransportTest.test_local_parameters,
FakeNFSDecoratorTests.test_http_parameters): Use HttpServer from
bzrlib.tests.HttpServer instead of bzrlib.transport.http.

* bzrlib/tests/test_sftp_transport.py:
(set_test_transport_to_sftp): Use HttpServer from
bzrlib.tests.HttpServer instead of bzrlib.transport.http.

* bzrlib/tests/test_selftest.py:
(TestTestCaseWithTransport.test_get_readonly_url_http): Use
HttpServer from bzrlib.tests.HttpServer instead of
bzrlib.transport.http.

* bzrlib/tests/test_repository.py: 
Does *not* use HttpServer.

* bzrlib/tests/test_http.py: 
Build on top of bzrlib.tests.HttpServer and bzrlib.tests.HTTPUtils
instead of bzrlib.transport.http.

* bzrlib/tests/test_bzrdir.py:
(ChrootedTests.setUp): Use HttpServer from bzrlib.tests.HttpServer
instead of bzrlib.transport.http.

* bzrlib/tests/branch_implementations/test_http.py:
(HTTPBranchTests.setUp): Use HttpServer from bzrlib.tests.HttpServer
instead of bzrlib.transport.http.

* bzrlib/tests/branch_implementations/test_branch.py:
(ChrootedTests.setUp): Use HttpServer from bzrlib.tests.HttpServer
instead of bzrlib.transport.http.

* bzrlib/tests/__init__.py:
(ChrootedTestCase.setUp): Use HttpServer from
bzrlib.tests.HttpServer instead of bzrlib.transport.http.

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 Canonical <canonical.com>
 
2
# Copyright (C) 2005, 2006 Canonical <canonical.com>
3
3
#
4
4
#    This program is free software; you can redistribute it and/or modify
5
5
#    it under the terms of the GNU General Public License as published by
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
41
 
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
 
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
56
50
 
57
51
 
58
52
def _supports_progress(f):
59
 
    if not hasattr(f, 'isatty'):
 
53
    isatty = getattr(f, 'isatty', None)
 
54
    if isatty is None:
60
55
        return False
61
 
    if not f.isatty():
 
56
    if not isatty():
62
57
        return False
63
58
    if os.environ.get('TERM') == 'dumb':
64
59
        # e.g. emacs compile window
66
61
    return True
67
62
 
68
63
 
69
 
 
70
 
def ProgressBar(to_file=sys.stderr, **kwargs):
 
64
_progress_bar_types = {}
 
65
 
 
66
 
 
67
def ProgressBar(to_file=None, **kwargs):
71
68
    """Abstract factory"""
72
 
    if _supports_progress(to_file):
73
 
        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)
74
78
    else:
75
 
        return DotsProgressBar(to_file=to_file, **kwargs)
76
 
    
77
 
    
 
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
 
 
89
 
 
90
class ProgressBarStack(object):
 
91
    """A stack of progress bars."""
 
92
 
 
93
    def __init__(self,
 
94
                 to_file=None,
 
95
                 show_pct=False,
 
96
                 show_spinner=True,
 
97
                 show_eta=False,
 
98
                 show_bar=True,
 
99
                 show_count=True,
 
100
                 to_messages_file=None,
 
101
                 klass=None):
 
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
 
107
        self._to_file = to_file
 
108
        self._show_pct = show_pct
 
109
        self._show_spinner = show_spinner
 
110
        self._show_eta = show_eta
 
111
        self._show_bar = show_bar
 
112
        self._show_count = show_count
 
113
        self._to_messages_file = to_messages_file
 
114
        self._stack = []
 
115
        self._klass = klass or ProgressBar
 
116
 
 
117
    def top(self):
 
118
        if len(self._stack) != 0:
 
119
            return self._stack[-1]
 
120
        else:
 
121
            return None
 
122
 
 
123
    def bottom(self):
 
124
        if len(self._stack) != 0:
 
125
            return self._stack[0]
 
126
        else:
 
127
            return None
 
128
 
 
129
    def get_nested(self):
 
130
        """Return a nested progress bar."""
 
131
        if len(self._stack) == 0:
 
132
            func = self._klass
 
133
        else:
 
134
            func = self.top().child_progress
 
135
        new_bar = func(to_file=self._to_file,
 
136
                       show_pct=self._show_pct,
 
137
                       show_spinner=self._show_spinner,
 
138
                       show_eta=self._show_eta,
 
139
                       show_bar=self._show_bar,
 
140
                       show_count=self._show_count,
 
141
                       to_messages_file=self._to_messages_file,
 
142
                       _stack=self)
 
143
        self._stack.append(new_bar)
 
144
        return new_bar
 
145
 
 
146
    def return_pb(self, bar):
 
147
        """Return bar after its been used."""
 
148
        if bar is not self._stack[-1]:
 
149
            raise errors.MissingProgressBarFinish()
 
150
        self._stack.pop()
 
151
 
 
152
 
78
153
class _BaseProgressBar(object):
 
154
 
79
155
    def __init__(self,
80
 
                 to_file=sys.stderr,
 
156
                 to_file=None,
81
157
                 show_pct=False,
82
158
                 show_spinner=False,
83
 
                 show_eta=True,
 
159
                 show_eta=False,
84
160
                 show_bar=True,
85
 
                 show_count=True):
 
161
                 show_count=True,
 
162
                 to_messages_file=None,
 
163
                 _stack=None):
86
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
87
169
        self.to_file = to_file
88
 
 
 
170
        self.to_messages_file = to_messages_file
89
171
        self.last_msg = None
90
172
        self.last_cnt = None
91
173
        self.last_total = None
94
176
        self.show_eta = show_eta
95
177
        self.show_bar = show_bar
96
178
        self.show_count = show_count
97
 
        
98
 
        
99
 
    
 
179
        self._stack = _stack
 
180
        # seed throttler
 
181
        self.MIN_PAUSE = 0.1 # seconds
 
182
        now = time.clock()
 
183
        # starting now
 
184
        self.start_time = now
 
185
        # next update should not throttle
 
186
        self.last_update = now - self.MIN_PAUSE - 1
 
187
 
 
188
    def finished(self):
 
189
        """Return this bar to its progress stack."""
 
190
        self.clear()
 
191
        assert self._stack is not None
 
192
        self._stack.return_pb(self)
 
193
 
 
194
    def note(self, fmt_string, *args, **kwargs):
 
195
        """Record a note without disrupting the progress bar."""
 
196
        self.clear()
 
197
        self.to_messages_file.write(fmt_string % args)
 
198
        self.to_messages_file.write('\n')
 
199
 
 
200
    def child_progress(self, **kwargs):
 
201
        return ChildProgress(**kwargs)
 
202
 
 
203
 
 
204
class DummyProgress(_BaseProgressBar):
 
205
    """Progress-bar standin that does nothing.
 
206
 
 
207
    This can be used as the default argument for methods that
 
208
    take an optional progress indicator."""
 
209
    def tick(self):
 
210
        pass
 
211
 
 
212
    def update(self, msg=None, current=None, total=None):
 
213
        pass
 
214
 
 
215
    def child_update(self, message, current, total):
 
216
        pass
 
217
 
 
218
    def clear(self):
 
219
        pass
 
220
        
 
221
    def note(self, fmt_string, *args, **kwargs):
 
222
        """See _BaseProgressBar.note()."""
 
223
 
 
224
    def child_progress(self, **kwargs):
 
225
        return DummyProgress(**kwargs)
 
226
 
 
227
 
 
228
_progress_bar_types['dummy'] = DummyProgress
 
229
_progress_bar_types['none'] = DummyProgress
 
230
 
 
231
 
100
232
class DotsProgressBar(_BaseProgressBar):
 
233
 
101
234
    def __init__(self, **kwargs):
102
235
        _BaseProgressBar.__init__(self, **kwargs)
103
236
        self.last_msg = None
110
243
        if msg and msg != self.last_msg:
111
244
            if self.need_nl:
112
245
                self.to_file.write('\n')
113
 
            
114
246
            self.to_file.write(msg + ': ')
115
247
            self.last_msg = msg
116
248
        self.need_nl = True
119
251
    def clear(self):
120
252
        if self.need_nl:
121
253
            self.to_file.write('\n')
 
254
        self.need_nl = False
122
255
        
 
256
    def child_update(self, message, current, total):
 
257
        self.tick()
 
258
 
 
259
 
 
260
_progress_bar_types['dots'] = DotsProgressBar
 
261
 
123
262
    
124
263
class TTYProgressBar(_BaseProgressBar):
125
264
    """Progress bar display object.
142
281
    The output file should be in line-buffered or unbuffered mode.
143
282
    """
144
283
    SPIN_CHARS = r'/-\|'
145
 
    MIN_PAUSE = 0.1 # seconds
146
284
 
147
285
 
148
286
    def __init__(self, **kwargs):
 
287
        from bzrlib.osutils import terminal_width
149
288
        _BaseProgressBar.__init__(self, **kwargs)
150
289
        self.spin_pos = 0
151
 
        self.width = _width()
152
 
        self.start_time = None
153
 
        self.last_update = None
 
290
        self.width = terminal_width()
 
291
        self.last_updates = []
 
292
        self._max_last_updates = 10
 
293
        self.child_fraction = 0
 
294
        self._have_output = False
154
295
    
155
296
 
156
 
    def throttle(self):
 
297
    def throttle(self, old_msg):
157
298
        """Return True if the bar was updated too recently"""
158
 
        now = time.time()
159
 
        if self.start_time is None:
160
 
            self.start_time = self.last_update = now
 
299
        # time.time consistently takes 40/4000 ms = 0.01 ms.
 
300
        # but every single update to the pb invokes it.
 
301
        # so we use time.clock which takes 20/4000 ms = 0.005ms
 
302
        # on the downside, time.clock() appears to have approximately
 
303
        # 10ms granularity, so we treat a zero-time change as 'throttled.'
 
304
        now = time.clock()
 
305
        if self.start_time is not None and (now - self.start_time) < 1:
 
306
            return True
 
307
        if old_msg != self.last_msg:
161
308
            return False
162
 
        else:
163
 
            interval = now - self.last_update
164
 
            if interval > 0 and interval < self.MIN_PAUSE:
165
 
                return True
 
309
        interval = now - self.last_update
 
310
        # if interval > 0
 
311
        if interval < self.MIN_PAUSE:
 
312
            return True
166
313
 
 
314
        self.last_updates.append(now - self.last_update)
 
315
        # Don't let the queue grow without bound
 
316
        self.last_updates = self.last_updates[-self._max_last_updates:]
167
317
        self.last_update = now
168
318
        return False
169
319
        
170
 
 
171
320
    def tick(self):
172
 
        self.update(self.last_msg, self.last_cnt, self.last_total)
173
 
                 
174
 
 
175
 
 
176
 
    def update(self, msg, current_cnt=None, total_cnt=None):
 
321
        self.update(self.last_msg, self.last_cnt, self.last_total, 
 
322
                    self.child_fraction)
 
323
 
 
324
    def child_update(self, message, current, total):
 
325
        if current is not None and total != 0:
 
326
            child_fraction = float(current) / total
 
327
            if self.last_cnt is None:
 
328
                pass
 
329
            elif self.last_cnt + child_fraction <= self.last_total:
 
330
                self.child_fraction = child_fraction
 
331
            else:
 
332
                mutter('not updating child fraction')
 
333
        if self.last_msg is None:
 
334
            self.last_msg = ''
 
335
        self.tick()
 
336
 
 
337
    def update(self, msg, current_cnt=None, total_cnt=None, 
 
338
               child_fraction=0):
177
339
        """Update and redraw progress bar."""
178
 
 
 
340
        if msg is None:
 
341
            msg = self.last_msg
 
342
 
 
343
        if total_cnt is None:
 
344
            total_cnt = self.last_total
 
345
 
 
346
        if current_cnt < 0:
 
347
            current_cnt = 0
 
348
            
 
349
        if current_cnt > total_cnt:
 
350
            total_cnt = current_cnt
 
351
        
 
352
        ## # optional corner case optimisation 
 
353
        ## # currently does not seem to fire so costs more than saved.
 
354
        ## # trivial optimal case:
 
355
        ## # NB if callers are doing a clear and restore with
 
356
        ## # the saved values, this will prevent that:
 
357
        ## # in that case add a restore method that calls
 
358
        ## # _do_update or some such
 
359
        ## if (self.last_msg == msg and
 
360
        ##     self.last_cnt == current_cnt and
 
361
        ##     self.last_total == total_cnt and
 
362
        ##     self.child_fraction == child_fraction):
 
363
        ##     return
 
364
 
 
365
        old_msg = self.last_msg
179
366
        # save these for the tick() function
180
367
        self.last_msg = msg
181
368
        self.last_cnt = current_cnt
182
369
        self.last_total = total_cnt
183
 
            
184
 
        if self.throttle():
185
 
            return 
186
 
        
187
 
        if total_cnt:
188
 
            assert current_cnt <= total_cnt
189
 
        if current_cnt:
190
 
            assert current_cnt >= 0
191
 
        
192
 
        if self.show_eta and self.start_time and total_cnt:
193
 
            eta = get_eta(self.start_time, current_cnt, total_cnt)
 
370
        self.child_fraction = child_fraction
 
371
 
 
372
        # each function call takes 20ms/4000 = 0.005 ms, 
 
373
        # but multiple that by 4000 calls -> starts to cost.
 
374
        # so anything to make this function call faster
 
375
        # will improve base 'diff' time by up to 0.1 seconds.
 
376
        if self.throttle(old_msg):
 
377
            return
 
378
 
 
379
        if self.show_eta and self.start_time and self.last_total:
 
380
            eta = get_eta(self.start_time, self.last_cnt + self.child_fraction, 
 
381
                    self.last_total, last_updates = self.last_updates)
194
382
            eta_str = " " + str_tdelta(eta)
195
383
        else:
196
384
            eta_str = ""
203
391
        # always update this; it's also used for the bar
204
392
        self.spin_pos += 1
205
393
 
206
 
        if self.show_pct and total_cnt and current_cnt:
207
 
            pct = 100.0 * current_cnt / total_cnt
 
394
        if self.show_pct and self.last_total and self.last_cnt:
 
395
            pct = 100.0 * ((self.last_cnt + self.child_fraction) / self.last_total)
208
396
            pct_str = ' (%5.1f%%)' % pct
209
397
        else:
210
398
            pct_str = ''
211
399
 
212
400
        if not self.show_count:
213
401
            count_str = ''
214
 
        elif current_cnt is None:
 
402
        elif self.last_cnt is None:
215
403
            count_str = ''
216
 
        elif total_cnt is None:
217
 
            count_str = ' %i' % (current_cnt)
 
404
        elif self.last_total is None:
 
405
            count_str = ' %i' % (self.last_cnt)
218
406
        else:
219
407
            # make both fields the same size
220
 
            t = '%i' % (total_cnt)
221
 
            c = '%*i' % (len(t), current_cnt)
 
408
            t = '%i' % (self.last_total)
 
409
            c = '%*i' % (len(t), self.last_cnt)
222
410
            count_str = ' ' + c + '/' + t 
223
411
 
224
412
        if self.show_bar:
225
413
            # progress bar, if present, soaks up all remaining space
226
 
            cols = self.width - 1 - len(msg) - len(spin_str) - len(pct_str) \
 
414
            cols = self.width - 1 - len(self.last_msg) - len(spin_str) - len(pct_str) \
227
415
                   - len(eta_str) - len(count_str) - 3
228
416
 
229
 
            if total_cnt:
 
417
            if self.last_total:
230
418
                # number of markers highlighted in bar
231
 
                markers = int(round(float(cols) * current_cnt / total_cnt))
 
419
                markers = int(round(float(cols) * 
 
420
                              (self.last_cnt + self.child_fraction) / self.last_total))
232
421
                bar_str = '[' + ('=' * markers).ljust(cols) + '] '
233
422
            elif False:
234
423
                # don't know total, so can't show completion.
242
431
        else:
243
432
            bar_str = ''
244
433
 
245
 
        m = spin_str + bar_str + msg + count_str + pct_str + eta_str
 
434
        m = spin_str + bar_str + self.last_msg + count_str + pct_str + eta_str
246
435
 
247
436
        assert len(m) < self.width
248
437
        self.to_file.write('\r' + m.ljust(self.width - 1))
 
438
        self._have_output = True
249
439
        #self.to_file.flush()
250
440
            
251
 
 
252
441
    def clear(self):        
253
 
        self.to_file.write('\r%s\r' % (' ' * (self.width - 1)))
 
442
        if self._have_output:
 
443
            self.to_file.write('\r%s\r' % (' ' * (self.width - 1)))
 
444
        self._have_output = False
254
445
        #self.to_file.flush()        
255
 
    
256
 
 
257
 
        
 
446
 
 
447
 
 
448
_progress_bar_types['tty'] = TTYProgressBar
 
449
 
 
450
 
 
451
class ChildProgress(_BaseProgressBar):
 
452
    """A progress indicator that pushes its data to the parent"""
 
453
 
 
454
    def __init__(self, _stack, **kwargs):
 
455
        _BaseProgressBar.__init__(self, _stack=_stack, **kwargs)
 
456
        self.parent = _stack.top()
 
457
        self.current = None
 
458
        self.total = None
 
459
        self.child_fraction = 0
 
460
        self.message = None
 
461
 
 
462
    def update(self, msg, current_cnt=None, total_cnt=None):
 
463
        self.current = current_cnt
 
464
        self.total = total_cnt
 
465
        self.message = msg
 
466
        self.child_fraction = 0
 
467
        self.tick()
 
468
 
 
469
    def child_update(self, message, current, total):
 
470
        if current is None or total == 0:
 
471
            self.child_fraction = 0
 
472
        else:
 
473
            self.child_fraction = float(current) / total
 
474
        self.tick()
 
475
 
 
476
    def tick(self):
 
477
        if self.current is None:
 
478
            count = None
 
479
        else:
 
480
            count = self.current+self.child_fraction
 
481
            if count > self.total:
 
482
                if __debug__:
 
483
                    mutter('clamping count of %d to %d' % (count, self.total))
 
484
                count = self.total
 
485
        self.parent.child_update(self.message, count, self.total)
 
486
 
 
487
    def clear(self):
 
488
        pass
 
489
 
 
490
    def note(self, *args, **kwargs):
 
491
        self.parent.note(*args, **kwargs)
 
492
 
 
493
 
258
494
def str_tdelta(delt):
259
495
    if delt is None:
260
496
        return "-:--:--"
264
500
                             delt % 60)
265
501
 
266
502
 
267
 
def get_eta(start_time, current, total, enough_samples=3):
 
503
def get_eta(start_time, current, total, enough_samples=3, last_updates=None, n_recent=10):
268
504
    if start_time is None:
269
505
        return None
270
506
 
277
513
    if current > total:
278
514
        return None                     # wtf?
279
515
 
280
 
    elapsed = time.time() - start_time
 
516
    elapsed = time.clock() - start_time
281
517
 
282
518
    if elapsed < 2.0:                   # not enough time to estimate
283
519
        return None
286
522
 
287
523
    assert total_duration >= elapsed
288
524
 
 
525
    if last_updates and len(last_updates) >= n_recent:
 
526
        avg = sum(last_updates) / float(len(last_updates))
 
527
        time_left = avg * (total - current)
 
528
 
 
529
        old_time_left = total_duration - elapsed
 
530
 
 
531
        # We could return the average, or some other value here
 
532
        return (time_left + old_time_left) / 2
 
533
 
289
534
    return total_duration - elapsed
290
535
 
291
536
 
 
537
class ProgressPhase(object):
 
538
    """Update progress object with the current phase"""
 
539
    def __init__(self, message, total, pb):
 
540
        object.__init__(self)
 
541
        self.pb = pb
 
542
        self.message = message
 
543
        self.total = total
 
544
        self.cur_phase = None
 
545
 
 
546
    def next_phase(self):
 
547
        if self.cur_phase is None:
 
548
            self.cur_phase = 0
 
549
        else:
 
550
            self.cur_phase += 1
 
551
        assert self.cur_phase < self.total 
 
552
        self.pb.update(self.message, self.cur_phase, self.total)
 
553
 
 
554
 
292
555
def run_tests():
293
556
    import doctest
294
557
    result = doctest.testmod()