/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: Aaron Bentley
  • Date: 2006-04-05 20:58:41 UTC
  • mto: (2027.1.2 revert-subpath-56549)
  • mto: This revision was merged to the branch mainline in revision 1647.
  • Revision ID: abentley@panoramicfeedback.com-20060405205841-44fc6af28076b671
Move select_conflicts into ConflictList

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/progress.py
 
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
 
17
 
 
18
 
 
19
"""Simple text-mode progress indicator.
 
20
 
 
21
To display an indicator, create a ProgressBar object.  Call it,
 
22
passing Progress objects indicating the current state.  When done,
 
23
call clear().
 
24
 
 
25
Progress is suppressed when output is not sent to a terminal, so as
 
26
not to clutter log files.
 
27
"""
 
28
 
 
29
# TODO: should be a global option e.g. --silent that disables progress
 
30
# indicators, preferably without needing to adjust all code that
 
31
# potentially calls them.
 
32
 
 
33
# TODO: If not on a tty perhaps just print '......' for the benefit of IDEs, etc
 
34
 
 
35
# TODO: Optionally show elapsed time instead/as well as ETA; nicer
 
36
# when the rate is unpredictable
 
37
 
 
38
 
 
39
import sys
 
40
import time
 
41
import os
 
42
from collections import deque
 
43
 
 
44
 
 
45
import bzrlib.errors as errors
 
46
from bzrlib.trace import mutter 
 
47
import bzrlib.ui
 
48
 
 
49
 
 
50
def _supports_progress(f):
 
51
    if not hasattr(f, 'isatty'):
 
52
        return False
 
53
    if not f.isatty():
 
54
        return False
 
55
    if os.environ.get('TERM') == 'dumb':
 
56
        # e.g. emacs compile window
 
57
        return False
 
58
    return True
 
59
 
 
60
 
 
61
 
 
62
def ProgressBar(to_file=sys.stderr, **kwargs):
 
63
    """Abstract factory"""
 
64
    if _supports_progress(to_file):
 
65
        return TTYProgressBar(to_file=to_file, **kwargs)
 
66
    else:
 
67
        return DotsProgressBar(to_file=to_file, **kwargs)
 
68
    
 
69
 
 
70
class ProgressBarStack(object):
 
71
    """A stack of progress bars."""
 
72
 
 
73
    def __init__(self,
 
74
                 to_file=sys.stderr,
 
75
                 show_pct=False,
 
76
                 show_spinner=True,
 
77
                 show_eta=False,
 
78
                 show_bar=True,
 
79
                 show_count=True,
 
80
                 to_messages_file=sys.stdout,
 
81
                 klass=None):
 
82
        """Setup the stack with the parameters the progress bars should have."""
 
83
        self._to_file = to_file
 
84
        self._show_pct = show_pct
 
85
        self._show_spinner = show_spinner
 
86
        self._show_eta = show_eta
 
87
        self._show_bar = show_bar
 
88
        self._show_count = show_count
 
89
        self._to_messages_file = to_messages_file
 
90
        self._stack = []
 
91
        self._klass = klass or TTYProgressBar
 
92
 
 
93
    def top(self):
 
94
        if len(self._stack) != 0:
 
95
            return self._stack[-1]
 
96
        else:
 
97
            return None
 
98
 
 
99
    def bottom(self):
 
100
        if len(self._stack) != 0:
 
101
            return self._stack[0]
 
102
        else:
 
103
            return None
 
104
 
 
105
    def get_nested(self):
 
106
        """Return a nested progress bar."""
 
107
        if len(self._stack) == 0:
 
108
            func = self._klass
 
109
        else:
 
110
            func = self.top().child_progress
 
111
        new_bar = func(to_file=self._to_file,
 
112
                       show_pct=self._show_pct,
 
113
                       show_spinner=self._show_spinner,
 
114
                       show_eta=self._show_eta,
 
115
                       show_bar=self._show_bar,
 
116
                       show_count=self._show_count,
 
117
                       to_messages_file=self._to_messages_file,
 
118
                       _stack=self)
 
119
        self._stack.append(new_bar)
 
120
        return new_bar
 
121
 
 
122
    def return_pb(self, bar):
 
123
        """Return bar after its been used."""
 
124
        if bar is not self._stack[-1]:
 
125
            raise errors.MissingProgressBarFinish()
 
126
        self._stack.pop()
 
127
 
 
128
 
 
129
class _BaseProgressBar(object):
 
130
 
 
131
    def __init__(self,
 
132
                 to_file=sys.stderr,
 
133
                 show_pct=False,
 
134
                 show_spinner=False,
 
135
                 show_eta=True,
 
136
                 show_bar=True,
 
137
                 show_count=True,
 
138
                 to_messages_file=sys.stdout,
 
139
                 _stack=None):
 
140
        object.__init__(self)
 
141
        self.to_file = to_file
 
142
        self.to_messages_file = to_messages_file
 
143
        self.last_msg = None
 
144
        self.last_cnt = None
 
145
        self.last_total = None
 
146
        self.show_pct = show_pct
 
147
        self.show_spinner = show_spinner
 
148
        self.show_eta = show_eta
 
149
        self.show_bar = show_bar
 
150
        self.show_count = show_count
 
151
        self._stack = _stack
 
152
        # seed throttler
 
153
        self.MIN_PAUSE = 0.1 # seconds
 
154
        now = time.clock()
 
155
        # starting now
 
156
        self.start_time = now
 
157
        # next update should not throttle
 
158
        self.last_update = now - self.MIN_PAUSE - 1
 
159
 
 
160
    def finished(self):
 
161
        """Return this bar to its progress stack."""
 
162
        self.clear()
 
163
        assert self._stack is not None
 
164
        self._stack.return_pb(self)
 
165
 
 
166
    def note(self, fmt_string, *args, **kwargs):
 
167
        """Record a note without disrupting the progress bar."""
 
168
        bzrlib.ui.ui_factory.clear_term()
 
169
        self.to_messages_file.write(fmt_string % args)
 
170
        self.to_messages_file.write('\n')
 
171
 
 
172
    def child_progress(self, **kwargs):
 
173
        return ChildProgress(**kwargs)
 
174
 
 
175
 
 
176
class DummyProgress(_BaseProgressBar):
 
177
    """Progress-bar standin that does nothing.
 
178
 
 
179
    This can be used as the default argument for methods that
 
180
    take an optional progress indicator."""
 
181
    def tick(self):
 
182
        pass
 
183
 
 
184
    def update(self, msg=None, current=None, total=None):
 
185
        pass
 
186
 
 
187
    def child_update(self, message, current, total):
 
188
        pass
 
189
 
 
190
    def clear(self):
 
191
        pass
 
192
        
 
193
    def note(self, fmt_string, *args, **kwargs):
 
194
        """See _BaseProgressBar.note()."""
 
195
 
 
196
    def child_progress(self, **kwargs):
 
197
        return DummyProgress(**kwargs)
 
198
 
 
199
class DotsProgressBar(_BaseProgressBar):
 
200
 
 
201
    def __init__(self, **kwargs):
 
202
        _BaseProgressBar.__init__(self, **kwargs)
 
203
        self.last_msg = None
 
204
        self.need_nl = False
 
205
        
 
206
    def tick(self):
 
207
        self.update()
 
208
        
 
209
    def update(self, msg=None, current_cnt=None, total_cnt=None):
 
210
        if msg and msg != self.last_msg:
 
211
            if self.need_nl:
 
212
                self.to_file.write('\n')
 
213
            
 
214
            self.to_file.write(msg + ': ')
 
215
            self.last_msg = msg
 
216
        self.need_nl = True
 
217
        self.to_file.write('.')
 
218
        
 
219
    def clear(self):
 
220
        if self.need_nl:
 
221
            self.to_file.write('\n')
 
222
        
 
223
    def child_update(self, message, current, total):
 
224
        self.tick()
 
225
    
 
226
class TTYProgressBar(_BaseProgressBar):
 
227
    """Progress bar display object.
 
228
 
 
229
    Several options are available to control the display.  These can
 
230
    be passed as parameters to the constructor or assigned at any time:
 
231
 
 
232
    show_pct
 
233
        Show percentage complete.
 
234
    show_spinner
 
235
        Show rotating baton.  This ticks over on every update even
 
236
        if the values don't change.
 
237
    show_eta
 
238
        Show predicted time-to-completion.
 
239
    show_bar
 
240
        Show bar graph.
 
241
    show_count
 
242
        Show numerical counts.
 
243
 
 
244
    The output file should be in line-buffered or unbuffered mode.
 
245
    """
 
246
    SPIN_CHARS = r'/-\|'
 
247
 
 
248
 
 
249
    def __init__(self, **kwargs):
 
250
        from bzrlib.osutils import terminal_width
 
251
        _BaseProgressBar.__init__(self, **kwargs)
 
252
        self.spin_pos = 0
 
253
        self.width = terminal_width()
 
254
        self.start_time = None
 
255
        self.last_updates = deque()
 
256
        self.child_fraction = 0
 
257
    
 
258
 
 
259
    def throttle(self):
 
260
        """Return True if the bar was updated too recently"""
 
261
        # time.time consistently takes 40/4000 ms = 0.01 ms.
 
262
        # but every single update to the pb invokes it.
 
263
        # so we use time.clock which takes 20/4000 ms = 0.005ms
 
264
        # on the downside, time.clock() appears to have approximately
 
265
        # 10ms granularity, so we treat a zero-time change as 'throttled.'
 
266
        
 
267
        now = time.clock()
 
268
        interval = now - self.last_update
 
269
        # if interval > 0
 
270
        if interval < self.MIN_PAUSE:
 
271
            return True
 
272
 
 
273
        self.last_updates.append(now - self.last_update)
 
274
        self.last_update = now
 
275
        return False
 
276
        
 
277
 
 
278
    def tick(self):
 
279
        self.update(self.last_msg, self.last_cnt, self.last_total, 
 
280
                    self.child_fraction)
 
281
 
 
282
    def child_update(self, message, current, total):
 
283
        if current is not None and total != 0:
 
284
            child_fraction = float(current) / total
 
285
            if self.last_cnt is None:
 
286
                pass
 
287
            elif self.last_cnt + child_fraction <= self.last_total:
 
288
                self.child_fraction = child_fraction
 
289
            else:
 
290
                mutter('not updating child fraction')
 
291
        if self.last_msg is None:
 
292
            self.last_msg = ''
 
293
        self.tick()
 
294
 
 
295
 
 
296
    def update(self, msg, current_cnt=None, total_cnt=None, 
 
297
               child_fraction=0):
 
298
        """Update and redraw progress bar."""
 
299
 
 
300
        if current_cnt < 0:
 
301
            current_cnt = 0
 
302
            
 
303
        if current_cnt > total_cnt:
 
304
            total_cnt = current_cnt
 
305
        
 
306
        ## # optional corner case optimisation 
 
307
        ## # currently does not seem to fire so costs more than saved.
 
308
        ## # trivial optimal case:
 
309
        ## # NB if callers are doing a clear and restore with
 
310
        ## # the saved values, this will prevent that:
 
311
        ## # in that case add a restore method that calls
 
312
        ## # _do_update or some such
 
313
        ## if (self.last_msg == msg and
 
314
        ##     self.last_cnt == current_cnt and
 
315
        ##     self.last_total == total_cnt and
 
316
        ##     self.child_fraction == child_fraction):
 
317
        ##     return
 
318
 
 
319
        old_msg = self.last_msg
 
320
        # save these for the tick() function
 
321
        self.last_msg = msg
 
322
        self.last_cnt = current_cnt
 
323
        self.last_total = total_cnt
 
324
        self.child_fraction = child_fraction
 
325
 
 
326
        # each function call takes 20ms/4000 = 0.005 ms, 
 
327
        # but multiple that by 4000 calls -> starts to cost.
 
328
        # so anything to make this function call faster
 
329
        # will improve base 'diff' time by up to 0.1 seconds.
 
330
        if old_msg == self.last_msg and self.throttle():
 
331
            return
 
332
 
 
333
        if self.show_eta and self.start_time and self.last_total:
 
334
            eta = get_eta(self.start_time, self.last_cnt + self.child_fraction, 
 
335
                    self.last_total, last_updates = self.last_updates)
 
336
            eta_str = " " + str_tdelta(eta)
 
337
        else:
 
338
            eta_str = ""
 
339
 
 
340
        if self.show_spinner:
 
341
            spin_str = self.SPIN_CHARS[self.spin_pos % 4] + ' '            
 
342
        else:
 
343
            spin_str = ''
 
344
 
 
345
        # always update this; it's also used for the bar
 
346
        self.spin_pos += 1
 
347
 
 
348
        if self.show_pct and self.last_total and self.last_cnt:
 
349
            pct = 100.0 * ((self.last_cnt + self.child_fraction) / self.last_total)
 
350
            pct_str = ' (%5.1f%%)' % pct
 
351
        else:
 
352
            pct_str = ''
 
353
 
 
354
        if not self.show_count:
 
355
            count_str = ''
 
356
        elif self.last_cnt is None:
 
357
            count_str = ''
 
358
        elif self.last_total is None:
 
359
            count_str = ' %i' % (self.last_cnt)
 
360
        else:
 
361
            # make both fields the same size
 
362
            t = '%i' % (self.last_total)
 
363
            c = '%*i' % (len(t), self.last_cnt)
 
364
            count_str = ' ' + c + '/' + t 
 
365
 
 
366
        if self.show_bar:
 
367
            # progress bar, if present, soaks up all remaining space
 
368
            cols = self.width - 1 - len(self.last_msg) - len(spin_str) - len(pct_str) \
 
369
                   - len(eta_str) - len(count_str) - 3
 
370
 
 
371
            if self.last_total:
 
372
                # number of markers highlighted in bar
 
373
                markers = int(round(float(cols) * 
 
374
                              (self.last_cnt + self.child_fraction) / self.last_total))
 
375
                bar_str = '[' + ('=' * markers).ljust(cols) + '] '
 
376
            elif False:
 
377
                # don't know total, so can't show completion.
 
378
                # so just show an expanded spinning thingy
 
379
                m = self.spin_pos % cols
 
380
                ms = (' ' * m + '*').ljust(cols)
 
381
                
 
382
                bar_str = '[' + ms + '] '
 
383
            else:
 
384
                bar_str = ''
 
385
        else:
 
386
            bar_str = ''
 
387
 
 
388
        m = spin_str + bar_str + self.last_msg + count_str + pct_str + eta_str
 
389
 
 
390
        assert len(m) < self.width
 
391
        self.to_file.write('\r' + m.ljust(self.width - 1))
 
392
        #self.to_file.flush()
 
393
            
 
394
    def clear(self):        
 
395
        self.to_file.write('\r%s\r' % (' ' * (self.width - 1)))
 
396
        #self.to_file.flush()        
 
397
 
 
398
 
 
399
class ChildProgress(_BaseProgressBar):
 
400
    """A progress indicator that pushes its data to the parent"""
 
401
    def __init__(self, _stack, **kwargs):
 
402
        _BaseProgressBar.__init__(self, _stack=_stack, **kwargs)
 
403
        self.parent = _stack.top()
 
404
        self.current = None
 
405
        self.total = None
 
406
        self.child_fraction = 0
 
407
        self.message = None
 
408
 
 
409
    def update(self, msg, current_cnt=None, total_cnt=None):
 
410
        self.current = current_cnt
 
411
        self.total = total_cnt
 
412
        self.message = msg
 
413
        self.child_fraction = 0
 
414
        self.tick()
 
415
 
 
416
    def child_update(self, message, current, total):
 
417
        if current is None or total == 0:
 
418
            self.child_fraction = 0
 
419
        else:
 
420
            self.child_fraction = float(current) / total
 
421
        self.tick()
 
422
 
 
423
    def tick(self):
 
424
        if self.current is None:
 
425
            count = None
 
426
        else:
 
427
            count = self.current+self.child_fraction
 
428
            if count > self.total:
 
429
                if __debug__:
 
430
                    mutter('clamping count of %d to %d' % (count, self.total))
 
431
                count = self.total
 
432
        self.parent.child_update(self.message, count, self.total)
 
433
 
 
434
    def clear(self):
 
435
        pass
 
436
 
 
437
 
 
438
def str_tdelta(delt):
 
439
    if delt is None:
 
440
        return "-:--:--"
 
441
    delt = int(round(delt))
 
442
    return '%d:%02d:%02d' % (delt/3600,
 
443
                             (delt/60) % 60,
 
444
                             delt % 60)
 
445
 
 
446
 
 
447
def get_eta(start_time, current, total, enough_samples=3, last_updates=None, n_recent=10):
 
448
    if start_time is None:
 
449
        return None
 
450
 
 
451
    if not total:
 
452
        return None
 
453
 
 
454
    if current < enough_samples:
 
455
        return None
 
456
 
 
457
    if current > total:
 
458
        return None                     # wtf?
 
459
 
 
460
    elapsed = time.clock() - start_time
 
461
 
 
462
    if elapsed < 2.0:                   # not enough time to estimate
 
463
        return None
 
464
    
 
465
    total_duration = float(elapsed) * float(total) / float(current)
 
466
 
 
467
    assert total_duration >= elapsed
 
468
 
 
469
    if last_updates and len(last_updates) >= n_recent:
 
470
        while len(last_updates) > n_recent:
 
471
            last_updates.popleft()
 
472
        avg = sum(last_updates) / float(len(last_updates))
 
473
        time_left = avg * (total - current)
 
474
 
 
475
        old_time_left = total_duration - elapsed
 
476
 
 
477
        # We could return the average, or some other value here
 
478
        return (time_left + old_time_left) / 2
 
479
 
 
480
    return total_duration - elapsed
 
481
 
 
482
 
 
483
class ProgressPhase(object):
 
484
    """Update progress object with the current phase"""
 
485
    def __init__(self, message, total, pb):
 
486
        object.__init__(self)
 
487
        self.pb = pb
 
488
        self.message = message
 
489
        self.total = total
 
490
        self.cur_phase = None
 
491
 
 
492
    def next_phase(self):
 
493
        if self.cur_phase is None:
 
494
            self.cur_phase = 0
 
495
        else:
 
496
            self.cur_phase += 1
 
497
        assert self.cur_phase < self.total 
 
498
        self.pb.update(self.message, self.cur_phase, self.total)
 
499
 
 
500
 
 
501
def run_tests():
 
502
    import doctest
 
503
    result = doctest.testmod()
 
504
    if result[1] > 0:
 
505
        if result[0] == 0:
 
506
            print "All tests passed"
 
507
    else:
 
508
        print "No tests to run"
 
509
 
 
510
 
 
511
def demo():
 
512
    sleep = time.sleep
 
513
    
 
514
    print 'dumb-terminal test:'
 
515
    pb = DotsProgressBar()
 
516
    for i in range(100):
 
517
        pb.update('Leoparden', i, 99)
 
518
        sleep(0.1)
 
519
    sleep(1.5)
 
520
    pb.clear()
 
521
    sleep(1.5)
 
522
    
 
523
    print 'smart-terminal test:'
 
524
    pb = ProgressBar(show_pct=True, show_bar=True, show_spinner=False)
 
525
    for i in range(100):
 
526
        pb.update('Elephanten', i, 99)
 
527
        sleep(0.1)
 
528
    sleep(2)
 
529
    pb.clear()
 
530
    sleep(1)
 
531
 
 
532
    print 'done!'
 
533
 
 
534
if __name__ == "__main__":
 
535
    demo()