~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/progress.py

  • Committer: Robert Collins
  • Date: 2010-04-08 04:34:03 UTC
  • mfrom: (5138 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5139.
  • Revision ID: robertc@robertcollins.net-20100408043403-56z0d07vdqrx7f3t
Update bugfix for 528114 to trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
184
184
            self.ui_factory.clear_term()
185
185
 
186
186
 
187
 
@deprecated_function(deprecated_in((1, 16, 0)))
188
 
def ProgressBar(to_file=None, **kwargs):
189
 
    """Construct a progress bar.
190
 
 
191
 
    Deprecated; ask the ui_factory for a progress task instead.
192
 
    """
193
 
    if to_file is None:
194
 
        to_file = sys.stderr
195
 
    requested_bar_type = os.environ.get('BZR_PROGRESS_BAR')
196
 
    # An value of '' or not set reverts to standard processing
197
 
    if requested_bar_type in (None, ''):
198
 
        if _supports_progress(to_file):
199
 
            return TTYProgressBar(to_file=to_file, **kwargs)
200
 
        else:
201
 
            return DummyProgress(to_file=to_file, **kwargs)
202
 
    else:
203
 
        # Minor sanitation to prevent spurious errors
204
 
        requested_bar_type = requested_bar_type.lower().strip()
205
 
        # TODO: jam 20060710 Arguably we shouldn't raise an exception
206
 
        #       but should instead just disable progress bars if we
207
 
        #       don't recognize the type
208
 
        if requested_bar_type not in _progress_bar_types:
209
 
            raise errors.InvalidProgressBarType(requested_bar_type,
210
 
                                                _progress_bar_types.keys())
211
 
        return _progress_bar_types[requested_bar_type](to_file=to_file, **kwargs)
212
 
 
213
 
 
214
187
# NOTE: This is also deprecated; you should provide a ProgressView instead.
215
188
class _BaseProgressBar(object):
216
189
 
258
231
        self.to_messages_file.write(fmt_string % args)
259
232
        self.to_messages_file.write('\n')
260
233
 
261
 
    @deprecated_function(deprecated_in((1, 16, 0)))
262
 
    def child_progress(self, **kwargs):
263
 
        return ChildProgress(**kwargs)
264
 
 
265
 
 
266
 
class DummyProgress(_BaseProgressBar):
 
234
 
 
235
class DummyProgress(object):
267
236
    """Progress-bar standin that does nothing.
268
237
 
269
 
    This can be used as the default argument for methods that
270
 
    take an optional progress indicator."""
 
238
    This was previously often constructed by application code if no progress
 
239
    bar was explicitly passed in.  That's no longer recommended: instead, just
 
240
    create a progress task from the ui_factory.  This class can be used in
 
241
    test code that needs to fake a progress task for some reason.
 
242
    """
271
243
 
272
244
    def tick(self):
273
245
        pass
288
260
        return DummyProgress(**kwargs)
289
261
 
290
262
 
291
 
class DotsProgressBar(_BaseProgressBar):
292
 
 
293
 
    @deprecated_function(deprecated_in((1, 16, 0)))
294
 
    def __init__(self, **kwargs):
295
 
        _BaseProgressBar.__init__(self, **kwargs)
296
 
        self.last_msg = None
297
 
        self.need_nl = False
298
 
 
299
 
    def tick(self):
300
 
        self.update()
301
 
 
302
 
    def update(self, msg=None, current_cnt=None, total_cnt=None):
303
 
        if msg and msg != self.last_msg:
304
 
            if self.need_nl:
305
 
                self.to_file.write('\n')
306
 
            self.to_file.write(msg + ': ')
307
 
            self.last_msg = msg
308
 
        self.need_nl = True
309
 
        self.to_file.write('.')
310
 
 
311
 
    def clear(self):
312
 
        if self.need_nl:
313
 
            self.to_file.write('\n')
314
 
        self.need_nl = False
315
 
 
316
 
    def child_update(self, message, current, total):
317
 
        self.tick()
318
 
 
319
 
 
320
 
class TTYProgressBar(_BaseProgressBar):
321
 
    """Progress bar display object.
322
 
 
323
 
    Several options are available to control the display.  These can
324
 
    be passed as parameters to the constructor or assigned at any time:
325
 
 
326
 
    show_pct
327
 
        Show percentage complete.
328
 
    show_spinner
329
 
        Show rotating baton.  This ticks over on every update even
330
 
        if the values don't change.
331
 
    show_eta
332
 
        Show predicted time-to-completion.
333
 
    show_bar
334
 
        Show bar graph.
335
 
    show_count
336
 
        Show numerical counts.
337
 
 
338
 
    The output file should be in line-buffered or unbuffered mode.
339
 
    """
340
 
    SPIN_CHARS = r'/-\|'
341
 
 
342
 
    @deprecated_function(deprecated_in((1, 16, 0)))
343
 
    def __init__(self, **kwargs):
344
 
        from bzrlib.osutils import terminal_width
345
 
        _BaseProgressBar.__init__(self, **kwargs)
346
 
        self.spin_pos = 0
347
 
        self.width = terminal_width()
348
 
        self.last_updates = []
349
 
        self._max_last_updates = 10
350
 
        self.child_fraction = 0
351
 
        self._have_output = False
352
 
 
353
 
    def throttle(self, old_msg):
354
 
        """Return True if the bar was updated too recently"""
355
 
        # time.time consistently takes 40/4000 ms = 0.01 ms.
356
 
        # time.clock() is faster, but gives us CPU time, not wall-clock time
357
 
        now = time.time()
358
 
        if self.start_time is not None and (now - self.start_time) < 1:
359
 
            return True
360
 
        if old_msg != self.last_msg:
361
 
            return False
362
 
        interval = now - self.last_update
363
 
        # if interval > 0
364
 
        if interval < self.MIN_PAUSE:
365
 
            return True
366
 
 
367
 
        self.last_updates.append(now - self.last_update)
368
 
        # Don't let the queue grow without bound
369
 
        self.last_updates = self.last_updates[-self._max_last_updates:]
370
 
        self.last_update = now
371
 
        return False
372
 
 
373
 
    def tick(self):
374
 
        self.update(self.last_msg, self.last_cnt, self.last_total,
375
 
                    self.child_fraction)
376
 
 
377
 
    def child_update(self, message, current, total):
378
 
        if current is not None and total != 0:
379
 
            child_fraction = float(current) / total
380
 
            if self.last_cnt is None:
381
 
                pass
382
 
            elif self.last_cnt + child_fraction <= self.last_total:
383
 
                self.child_fraction = child_fraction
384
 
        if self.last_msg is None:
385
 
            self.last_msg = ''
386
 
        self.tick()
387
 
 
388
 
    def update(self, msg, current_cnt=None, total_cnt=None,
389
 
            child_fraction=0):
390
 
        """Update and redraw progress bar.
391
 
        """
392
 
        if msg is None:
393
 
            msg = self.last_msg
394
 
 
395
 
        if total_cnt is None:
396
 
            total_cnt = self.last_total
397
 
 
398
 
        if current_cnt < 0:
399
 
            current_cnt = 0
400
 
 
401
 
        if current_cnt > total_cnt:
402
 
            total_cnt = current_cnt
403
 
 
404
 
        ## # optional corner case optimisation
405
 
        ## # currently does not seem to fire so costs more than saved.
406
 
        ## # trivial optimal case:
407
 
        ## # NB if callers are doing a clear and restore with
408
 
        ## # the saved values, this will prevent that:
409
 
        ## # in that case add a restore method that calls
410
 
        ## # _do_update or some such
411
 
        ## if (self.last_msg == msg and
412
 
        ##     self.last_cnt == current_cnt and
413
 
        ##     self.last_total == total_cnt and
414
 
        ##     self.child_fraction == child_fraction):
415
 
        ##     return
416
 
 
417
 
        if msg is None:
418
 
            msg = ''
419
 
 
420
 
        old_msg = self.last_msg
421
 
        # save these for the tick() function
422
 
        self.last_msg = msg
423
 
        self.last_cnt = current_cnt
424
 
        self.last_total = total_cnt
425
 
        self.child_fraction = child_fraction
426
 
 
427
 
        # each function call takes 20ms/4000 = 0.005 ms,
428
 
        # but multiple that by 4000 calls -> starts to cost.
429
 
        # so anything to make this function call faster
430
 
        # will improve base 'diff' time by up to 0.1 seconds.
431
 
        if self.throttle(old_msg):
432
 
            return
433
 
 
434
 
        if self.show_eta and self.start_time and self.last_total:
435
 
            eta = get_eta(self.start_time, self.last_cnt + self.child_fraction,
436
 
                    self.last_total, last_updates = self.last_updates)
437
 
            eta_str = " " + str_tdelta(eta)
438
 
        else:
439
 
            eta_str = ""
440
 
 
441
 
        if self.show_spinner:
442
 
            spin_str = self.SPIN_CHARS[self.spin_pos % 4] + ' '
443
 
        else:
444
 
            spin_str = ''
445
 
 
446
 
        # always update this; it's also used for the bar
447
 
        self.spin_pos += 1
448
 
 
449
 
        if self.show_pct and self.last_total and self.last_cnt:
450
 
            pct = 100.0 * ((self.last_cnt + self.child_fraction) / self.last_total)
451
 
            pct_str = ' (%5.1f%%)' % pct
452
 
        else:
453
 
            pct_str = ''
454
 
 
455
 
        if not self.show_count:
456
 
            count_str = ''
457
 
        elif self.last_cnt is None:
458
 
            count_str = ''
459
 
        elif self.last_total is None:
460
 
            count_str = ' %i' % (self.last_cnt)
461
 
        else:
462
 
            # make both fields the same size
463
 
            t = '%i' % (self.last_total)
464
 
            c = '%*i' % (len(t), self.last_cnt)
465
 
            count_str = ' ' + c + '/' + t
466
 
 
467
 
        if self.show_bar:
468
 
            # progress bar, if present, soaks up all remaining space
469
 
            cols = self.width - 1 - len(self.last_msg) - len(spin_str) - len(pct_str) \
470
 
                   - len(eta_str) - len(count_str) - 3
471
 
 
472
 
            if self.last_total:
473
 
                # number of markers highlighted in bar
474
 
                markers = int(round(float(cols) *
475
 
                              (self.last_cnt + self.child_fraction) / self.last_total))
476
 
                bar_str = '[' + ('=' * markers).ljust(cols) + '] '
477
 
            elif False:
478
 
                # don't know total, so can't show completion.
479
 
                # so just show an expanded spinning thingy
480
 
                m = self.spin_pos % cols
481
 
                ms = (' ' * m + '*').ljust(cols)
482
 
 
483
 
                bar_str = '[' + ms + '] '
484
 
            else:
485
 
                bar_str = ''
486
 
        else:
487
 
            bar_str = ''
488
 
 
489
 
        m = spin_str + bar_str + self.last_msg + count_str \
490
 
            + pct_str + eta_str
491
 
        self.to_file.write('\r%-*.*s' % (self.width - 1, self.width - 1, m))
492
 
        self._have_output = True
493
 
        #self.to_file.flush()
494
 
 
495
 
    def clear(self):
496
 
        if self._have_output:
497
 
            self.to_file.write('\r%s\r' % (' ' * (self.width - 1)))
498
 
        self._have_output = False
499
 
        #self.to_file.flush()
500
 
 
501
 
 
502
 
 
503
 
# DEPRECATED
504
 
class ChildProgress(_BaseProgressBar):
505
 
    """A progress indicator that pushes its data to the parent"""
506
 
 
507
 
    @deprecated_function(deprecated_in((1, 16, 0)))
508
 
    def __init__(self, _stack, **kwargs):
509
 
        _BaseProgressBar.__init__(self, _stack=_stack, **kwargs)
510
 
        self.parent = _stack.top()
511
 
        self.current = None
512
 
        self.total = None
513
 
        self.child_fraction = 0
514
 
        self.message = None
515
 
 
516
 
    def update(self, msg, current_cnt=None, total_cnt=None):
517
 
        self.current = current_cnt
518
 
        if total_cnt is not None:
519
 
            self.total = total_cnt
520
 
        self.message = msg
521
 
        self.child_fraction = 0
522
 
        self.tick()
523
 
 
524
 
    def child_update(self, message, current, total):
525
 
        if current is None or total == 0:
526
 
            self.child_fraction = 0
527
 
        else:
528
 
            self.child_fraction = float(current) / total
529
 
        self.tick()
530
 
 
531
 
    def tick(self):
532
 
        if self.current is None:
533
 
            count = None
534
 
        else:
535
 
            count = self.current+self.child_fraction
536
 
            if count > self.total:
537
 
                if __debug__:
538
 
                    mutter('clamping count of %d to %d' % (count, self.total))
539
 
                count = self.total
540
 
        self.parent.child_update(self.message, count, self.total)
541
 
 
542
 
    def clear(self):
543
 
        pass
544
 
 
545
 
    def note(self, *args, **kwargs):
546
 
        self.parent.note(*args, **kwargs)
547
 
 
548
 
 
549
263
def str_tdelta(delt):
550
264
    if delt is None:
551
265
        return "-:--:--"
602
316
        else:
603
317
            self.cur_phase += 1
604
318
        self.pb.update(self.message, self.cur_phase, self.total)
605
 
 
606
 
 
607
 
_progress_bar_types = {}
608
 
_progress_bar_types['dummy'] = DummyProgress
609
 
_progress_bar_types['none'] = DummyProgress
610
 
_progress_bar_types['tty'] = TTYProgressBar
611
 
_progress_bar_types['dots'] = DotsProgressBar