← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/progress.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-02-23 17:00:36 UTC
  • mfrom: (4032.1.4 jam-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20090223170036-3q1v68ewdt8i0to5
(Marius Kruger) Remove all trailing whitespace and add tests to
        enforce this.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/progress.py
44
44
def _supports_progress(f):
45
45
    """Detect if we can use pretty progress bars on the output stream f.
46
46
 
47
 
    If this returns true we expect that a human may be looking at that 
 
47
    If this returns true we expect that a human may be looking at that
48
48
    output, and that we can repaint a line to update it.
49
49
    """
50
50
    isatty = getattr(f, 'isatty', None)
61
61
class ProgressTask(object):
62
62
    """Model component of a progress indicator.
63
63
 
64
 
    Most code that needs to indicate progress should update one of these, 
 
64
    Most code that needs to indicate progress should update one of these,
65
65
    and it will in turn update the display, if one is present.
66
66
 
67
67
    Code updating the task may also set fields as hints about how to display
158
158
 
159
159
class ProgressBarStack(object):
160
160
    """A stack of progress bars.
161
 
    
 
161
 
162
162
    This class is deprecated: instead, ask the ui factory for a new progress
163
163
    task and finish it when it's done.
164
164
    """
224
224
        else:
225
225
            self._stack.pop()
226
226
 
227
 
 
 
227
 
228
228
class _BaseProgressBar(object):
229
229
 
230
230
    def __init__(self,
292
292
 
293
293
    def clear(self):
294
294
        pass
295
 
        
 
295
 
296
296
    def note(self, fmt_string, *args, **kwargs):
297
297
        """See _BaseProgressBar.note()."""
298
298
 
306
306
        _BaseProgressBar.__init__(self, **kwargs)
307
307
        self.last_msg = None
308
308
        self.need_nl = False
309
 
        
 
309
 
310
310
    def tick(self):
311
311
        self.update()
312
 
        
 
312
 
313
313
    def update(self, msg=None, current_cnt=None, total_cnt=None):
314
314
        if msg and msg != self.last_msg:
315
315
            if self.need_nl:
318
318
            self.last_msg = msg
319
319
        self.need_nl = True
320
320
        self.to_file.write('.')
321
 
        
 
321
 
322
322
    def clear(self):
323
323
        if self.need_nl:
324
324
            self.to_file.write('\n')
325
325
        self.need_nl = False
326
 
        
 
326
 
327
327
    def child_update(self, message, current, total):
328
328
        self.tick()
329
329
 
330
330
 
331
331
 
332
 
    
 
332
 
333
333
class TTYProgressBar(_BaseProgressBar):
334
334
    """Progress bar display object.
335
335
 
362
362
        self._max_last_updates = 10
363
363
        self.child_fraction = 0
364
364
        self._have_output = False
365
 
    
 
365
 
366
366
    def throttle(self, old_msg):
367
367
        """Return True if the bar was updated too recently"""
368
368
        # time.time consistently takes 40/4000 ms = 0.01 ms.
382
382
        self.last_updates = self.last_updates[-self._max_last_updates:]
383
383
        self.last_update = now
384
384
        return False
385
 
        
 
385
 
386
386
    def tick(self):
387
387
        self.update(self.last_msg, self.last_cnt, self.last_total,
388
388
                    self.child_fraction)
410
410
 
411
411
        if current_cnt < 0:
412
412
            current_cnt = 0
413
 
            
 
413
 
414
414
        if current_cnt > total_cnt:
415
415
            total_cnt = current_cnt
416
 
        
417
 
        ## # optional corner case optimisation 
 
416
 
 
417
        ## # optional corner case optimisation
418
418
        ## # currently does not seem to fire so costs more than saved.
419
419
        ## # trivial optimal case:
420
420
        ## # NB if callers are doing a clear and restore with
437
437
        self.last_total = total_cnt
438
438
        self.child_fraction = child_fraction
439
439
 
440
 
        # each function call takes 20ms/4000 = 0.005 ms, 
 
440
        # each function call takes 20ms/4000 = 0.005 ms,
441
441
        # but multiple that by 4000 calls -> starts to cost.
442
442
        # so anything to make this function call faster
443
443
        # will improve base 'diff' time by up to 0.1 seconds.
445
445
            return
446
446
 
447
447
        if self.show_eta and self.start_time and self.last_total:
448
 
            eta = get_eta(self.start_time, self.last_cnt + self.child_fraction, 
 
448
            eta = get_eta(self.start_time, self.last_cnt + self.child_fraction,
449
449
                    self.last_total, last_updates = self.last_updates)
450
450
            eta_str = " " + str_tdelta(eta)
451
451
        else:
452
452
            eta_str = ""
453
453
 
454
454
        if self.show_spinner:
455
 
            spin_str = self.SPIN_CHARS[self.spin_pos % 4] + ' '            
 
455
            spin_str = self.SPIN_CHARS[self.spin_pos % 4] + ' '
456
456
        else:
457
457
            spin_str = ''
458
458
 
484
484
 
485
485
            if self.last_total:
486
486
                # number of markers highlighted in bar
487
 
                markers = int(round(float(cols) * 
 
487
                markers = int(round(float(cols) *
488
488
                              (self.last_cnt + self.child_fraction) / self.last_total))
489
489
                bar_str = '[' + ('=' * markers).ljust(cols) + '] '
490
490
            elif False:
492
492
                # so just show an expanded spinning thingy
493
493
                m = self.spin_pos % cols
494
494
                ms = (' ' * m + '*').ljust(cols)
495
 
                
 
495
 
496
496
                bar_str = '[' + ms + '] '
497
497
            else:
498
498
                bar_str = ''
504
504
        self.to_file.write('\r%-*.*s' % (self.width - 1, self.width - 1, m))
505
505
        self._have_output = True
506
506
        #self.to_file.flush()
507
 
            
 
507
 
508
508
    def clear(self):
509
509
        if self._have_output:
510
510
            self.to_file.write('\r%s\r' % (' ' * (self.width - 1)))
511
511
        self._have_output = False
512
 
        #self.to_file.flush()        
 
512
        #self.to_file.flush()
513
513
 
514
514
 
515
515
 
601
601
 
602
602
    if elapsed < 2.0:                   # not enough time to estimate
603
603
        return None
604
 
    
 
604
 
605
605
    total_duration = float(elapsed) * float(total) / float(current)
606
606
 
607
607
    if last_updates and len(last_updates) >= n_recent: