← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/progress.py

  • Committer: Danny van Heumen
  • Date: 2010-03-09 21:42:11 UTC
  • mto: (4634.139.5 2.0)
  • mto: This revision was merged to the branch mainline in revision 5160.
  • Revision ID: danny@dannyvanheumen.nl-20100309214211-iqh42x6qcikgd9p3
Reverted now-useless TODO list.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/progress.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2008, 2009 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
27
27
import os
28
28
 
29
29
 
 
30
from bzrlib import (
 
31
    errors,
 
32
    )
 
33
from bzrlib.trace import mutter
30
34
from bzrlib.symbol_versioning import (
 
35
    deprecated_function,
31
36
    deprecated_in,
32
 
    deprecated_method,
33
37
    )
34
38
 
35
39
 
152
156
                own_fraction = 0.0
153
157
            return self._parent_task._overall_completion_fraction(own_fraction)
154
158
 
 
159
    def note(self, fmt_string, *args):
 
160
        """Record a note without disrupting the progress bar."""
 
161
        # XXX: shouldn't be here; put it in mutter or the ui instead
 
162
        if args:
 
163
            self.ui_factory.note(fmt_string % args)
 
164
        else:
 
165
            self.ui_factory.note(fmt_string)
 
166
 
155
167
    def clear(self):
156
 
        # TODO: deprecate this method; the model object shouldn't be concerned
157
 
        # with whether it's shown or not.  Most callers use this because they
158
 
        # want to write some different non-progress output to the screen, but
159
 
        # they should probably instead use a stream that's synchronized with
160
 
        # the progress output.  It may be there is a model-level use for
161
 
        # saying "this task's not active at the moment" but I don't see it. --
162
 
        # mbp 20090623
 
168
        # XXX: shouldn't be here; put it in mutter or the ui instead
163
169
        if self.progress_view:
164
170
            self.progress_view.clear()
165
171
        else:
166
172
            self.ui_factory.clear_term()
167
173
 
168
174
 
 
175
@deprecated_function(deprecated_in((1, 16, 0)))
 
176
def ProgressBar(to_file=None, **kwargs):
 
177
    """Construct a progress bar.
 
178
 
 
179
    Deprecated; ask the ui_factory for a progress task instead.
 
180
    """
 
181
    if to_file is None:
 
182
        to_file = sys.stderr
 
183
    requested_bar_type = os.environ.get('BZR_PROGRESS_BAR')
 
184
    # An value of '' or not set reverts to standard processing
 
185
    if requested_bar_type in (None, ''):
 
186
        if _supports_progress(to_file):
 
187
            return TTYProgressBar(to_file=to_file, **kwargs)
 
188
        else:
 
189
            return DummyProgress(to_file=to_file, **kwargs)
 
190
    else:
 
191
        # Minor sanitation to prevent spurious errors
 
192
        requested_bar_type = requested_bar_type.lower().strip()
 
193
        # TODO: jam 20060710 Arguably we shouldn't raise an exception
 
194
        #       but should instead just disable progress bars if we
 
195
        #       don't recognize the type
 
196
        if requested_bar_type not in _progress_bar_types:
 
197
            raise errors.InvalidProgressBarType(requested_bar_type,
 
198
                                                _progress_bar_types.keys())
 
199
        return _progress_bar_types[requested_bar_type](to_file=to_file, **kwargs)
 
200
 
 
201
 
169
202
# NOTE: This is also deprecated; you should provide a ProgressView instead.
170
203
class _BaseProgressBar(object):
171
204
 
207
240
        self.clear()
208
241
        self._stack.return_pb(self)
209
242
 
210
 
 
211
 
class DummyProgress(object):
 
243
    def note(self, fmt_string, *args, **kwargs):
 
244
        """Record a note without disrupting the progress bar."""
 
245
        self.clear()
 
246
        self.to_messages_file.write(fmt_string % args)
 
247
        self.to_messages_file.write('\n')
 
248
 
 
249
    @deprecated_function(deprecated_in((1, 16, 0)))
 
250
    def child_progress(self, **kwargs):
 
251
        return ChildProgress(**kwargs)
 
252
 
 
253
 
 
254
class DummyProgress(_BaseProgressBar):
212
255
    """Progress-bar standin that does nothing.
213
256
 
214
 
    This was previously often constructed by application code if no progress
215
 
    bar was explicitly passed in.  That's no longer recommended: instead, just
216
 
    create a progress task from the ui_factory.  This class can be used in
217
 
    test code that needs to fake a progress task for some reason.
218
 
    """
 
257
    This can be used as the default argument for methods that
 
258
    take an optional progress indicator."""
219
259
 
220
260
    def tick(self):
221
261
        pass
229
269
    def clear(self):
230
270
        pass
231
271
 
 
272
    def note(self, fmt_string, *args, **kwargs):
 
273
        """See _BaseProgressBar.note()."""
 
274
 
232
275
    def child_progress(self, **kwargs):
233
276
        return DummyProgress(**kwargs)
234
277
 
235
278
 
 
279
class DotsProgressBar(_BaseProgressBar):
 
280
 
 
281
    @deprecated_function(deprecated_in((1, 16, 0)))
 
282
    def __init__(self, **kwargs):
 
283
        _BaseProgressBar.__init__(self, **kwargs)
 
284
        self.last_msg = None
 
285
        self.need_nl = False
 
286
 
 
287
    def tick(self):
 
288
        self.update()
 
289
 
 
290
    def update(self, msg=None, current_cnt=None, total_cnt=None):
 
291
        if msg and msg != self.last_msg:
 
292
            if self.need_nl:
 
293
                self.to_file.write('\n')
 
294
            self.to_file.write(msg + ': ')
 
295
            self.last_msg = msg
 
296
        self.need_nl = True
 
297
        self.to_file.write('.')
 
298
 
 
299
    def clear(self):
 
300
        if self.need_nl:
 
301
            self.to_file.write('\n')
 
302
        self.need_nl = False
 
303
 
 
304
    def child_update(self, message, current, total):
 
305
        self.tick()
 
306
 
 
307
 
 
308
class TTYProgressBar(_BaseProgressBar):
 
309
    """Progress bar display object.
 
310
 
 
311
    Several options are available to control the display.  These can
 
312
    be passed as parameters to the constructor or assigned at any time:
 
313
 
 
314
    show_pct
 
315
        Show percentage complete.
 
316
    show_spinner
 
317
        Show rotating baton.  This ticks over on every update even
 
318
        if the values don't change.
 
319
    show_eta
 
320
        Show predicted time-to-completion.
 
321
    show_bar
 
322
        Show bar graph.
 
323
    show_count
 
324
        Show numerical counts.
 
325
 
 
326
    The output file should be in line-buffered or unbuffered mode.
 
327
    """
 
328
    SPIN_CHARS = r'/-\|'
 
329
 
 
330
    @deprecated_function(deprecated_in((1, 16, 0)))
 
331
    def __init__(self, **kwargs):
 
332
        from bzrlib.osutils import terminal_width
 
333
        _BaseProgressBar.__init__(self, **kwargs)
 
334
        self.spin_pos = 0
 
335
        self.width = terminal_width()
 
336
        self.last_updates = []
 
337
        self._max_last_updates = 10
 
338
        self.child_fraction = 0
 
339
        self._have_output = False
 
340
 
 
341
    def throttle(self, old_msg):
 
342
        """Return True if the bar was updated too recently"""
 
343
        # time.time consistently takes 40/4000 ms = 0.01 ms.
 
344
        # time.clock() is faster, but gives us CPU time, not wall-clock time
 
345
        now = time.time()
 
346
        if self.start_time is not None and (now - self.start_time) < 1:
 
347
            return True
 
348
        if old_msg != self.last_msg:
 
349
            return False
 
350
        interval = now - self.last_update
 
351
        # if interval > 0
 
352
        if interval < self.MIN_PAUSE:
 
353
            return True
 
354
 
 
355
        self.last_updates.append(now - self.last_update)
 
356
        # Don't let the queue grow without bound
 
357
        self.last_updates = self.last_updates[-self._max_last_updates:]
 
358
        self.last_update = now
 
359
        return False
 
360
 
 
361
    def tick(self):
 
362
        self.update(self.last_msg, self.last_cnt, self.last_total,
 
363
                    self.child_fraction)
 
364
 
 
365
    def child_update(self, message, current, total):
 
366
        if current is not None and total != 0:
 
367
            child_fraction = float(current) / total
 
368
            if self.last_cnt is None:
 
369
                pass
 
370
            elif self.last_cnt + child_fraction <= self.last_total:
 
371
                self.child_fraction = child_fraction
 
372
        if self.last_msg is None:
 
373
            self.last_msg = ''
 
374
        self.tick()
 
375
 
 
376
    def update(self, msg, current_cnt=None, total_cnt=None,
 
377
            child_fraction=0):
 
378
        """Update and redraw progress bar.
 
379
        """
 
380
        if msg is None:
 
381
            msg = self.last_msg
 
382
 
 
383
        if total_cnt is None:
 
384
            total_cnt = self.last_total
 
385
 
 
386
        if current_cnt < 0:
 
387
            current_cnt = 0
 
388
 
 
389
        if current_cnt > total_cnt:
 
390
            total_cnt = current_cnt
 
391
 
 
392
        ## # optional corner case optimisation
 
393
        ## # currently does not seem to fire so costs more than saved.
 
394
        ## # trivial optimal case:
 
395
        ## # NB if callers are doing a clear and restore with
 
396
        ## # the saved values, this will prevent that:
 
397
        ## # in that case add a restore method that calls
 
398
        ## # _do_update or some such
 
399
        ## if (self.last_msg == msg and
 
400
        ##     self.last_cnt == current_cnt and
 
401
        ##     self.last_total == total_cnt and
 
402
        ##     self.child_fraction == child_fraction):
 
403
        ##     return
 
404
 
 
405
        if msg is None:
 
406
            msg = ''
 
407
 
 
408
        old_msg = self.last_msg
 
409
        # save these for the tick() function
 
410
        self.last_msg = msg
 
411
        self.last_cnt = current_cnt
 
412
        self.last_total = total_cnt
 
413
        self.child_fraction = child_fraction
 
414
 
 
415
        # each function call takes 20ms/4000 = 0.005 ms,
 
416
        # but multiple that by 4000 calls -> starts to cost.
 
417
        # so anything to make this function call faster
 
418
        # will improve base 'diff' time by up to 0.1 seconds.
 
419
        if self.throttle(old_msg):
 
420
            return
 
421
 
 
422
        if self.show_eta and self.start_time and self.last_total:
 
423
            eta = get_eta(self.start_time, self.last_cnt + self.child_fraction,
 
424
                    self.last_total, last_updates = self.last_updates)
 
425
            eta_str = " " + str_tdelta(eta)
 
426
        else:
 
427
            eta_str = ""
 
428
 
 
429
        if self.show_spinner:
 
430
            spin_str = self.SPIN_CHARS[self.spin_pos % 4] + ' '
 
431
        else:
 
432
            spin_str = ''
 
433
 
 
434
        # always update this; it's also used for the bar
 
435
        self.spin_pos += 1
 
436
 
 
437
        if self.show_pct and self.last_total and self.last_cnt:
 
438
            pct = 100.0 * ((self.last_cnt + self.child_fraction) / self.last_total)
 
439
            pct_str = ' (%5.1f%%)' % pct
 
440
        else:
 
441
            pct_str = ''
 
442
 
 
443
        if not self.show_count:
 
444
            count_str = ''
 
445
        elif self.last_cnt is None:
 
446
            count_str = ''
 
447
        elif self.last_total is None:
 
448
            count_str = ' %i' % (self.last_cnt)
 
449
        else:
 
450
            # make both fields the same size
 
451
            t = '%i' % (self.last_total)
 
452
            c = '%*i' % (len(t), self.last_cnt)
 
453
            count_str = ' ' + c + '/' + t
 
454
 
 
455
        if self.show_bar:
 
456
            # progress bar, if present, soaks up all remaining space
 
457
            cols = self.width - 1 - len(self.last_msg) - len(spin_str) - len(pct_str) \
 
458
                   - len(eta_str) - len(count_str) - 3
 
459
 
 
460
            if self.last_total:
 
461
                # number of markers highlighted in bar
 
462
                markers = int(round(float(cols) *
 
463
                              (self.last_cnt + self.child_fraction) / self.last_total))
 
464
                bar_str = '[' + ('=' * markers).ljust(cols) + '] '
 
465
            elif False:
 
466
                # don't know total, so can't show completion.
 
467
                # so just show an expanded spinning thingy
 
468
                m = self.spin_pos % cols
 
469
                ms = (' ' * m + '*').ljust(cols)
 
470
 
 
471
                bar_str = '[' + ms + '] '
 
472
            else:
 
473
                bar_str = ''
 
474
        else:
 
475
            bar_str = ''
 
476
 
 
477
        m = spin_str + bar_str + self.last_msg + count_str \
 
478
            + pct_str + eta_str
 
479
        self.to_file.write('\r%-*.*s' % (self.width - 1, self.width - 1, m))
 
480
        self._have_output = True
 
481
        #self.to_file.flush()
 
482
 
 
483
    def clear(self):
 
484
        if self._have_output:
 
485
            self.to_file.write('\r%s\r' % (' ' * (self.width - 1)))
 
486
        self._have_output = False
 
487
        #self.to_file.flush()
 
488
 
 
489
 
 
490
 
 
491
# DEPRECATED
 
492
class ChildProgress(_BaseProgressBar):
 
493
    """A progress indicator that pushes its data to the parent"""
 
494
 
 
495
    @deprecated_function(deprecated_in((1, 16, 0)))
 
496
    def __init__(self, _stack, **kwargs):
 
497
        _BaseProgressBar.__init__(self, _stack=_stack, **kwargs)
 
498
        self.parent = _stack.top()
 
499
        self.current = None
 
500
        self.total = None
 
501
        self.child_fraction = 0
 
502
        self.message = None
 
503
 
 
504
    def update(self, msg, current_cnt=None, total_cnt=None):
 
505
        self.current = current_cnt
 
506
        if total_cnt is not None:
 
507
            self.total = total_cnt
 
508
        self.message = msg
 
509
        self.child_fraction = 0
 
510
        self.tick()
 
511
 
 
512
    def child_update(self, message, current, total):
 
513
        if current is None or total == 0:
 
514
            self.child_fraction = 0
 
515
        else:
 
516
            self.child_fraction = float(current) / total
 
517
        self.tick()
 
518
 
 
519
    def tick(self):
 
520
        if self.current is None:
 
521
            count = None
 
522
        else:
 
523
            count = self.current+self.child_fraction
 
524
            if count > self.total:
 
525
                if __debug__:
 
526
                    mutter('clamping count of %d to %d' % (count, self.total))
 
527
                count = self.total
 
528
        self.parent.child_update(self.message, count, self.total)
 
529
 
 
530
    def clear(self):
 
531
        pass
 
532
 
 
533
    def note(self, *args, **kwargs):
 
534
        self.parent.note(*args, **kwargs)
 
535
 
 
536
 
236
537
def str_tdelta(delt):
237
538
    if delt is None:
238
539
        return "-:--:--"
289
590
        else:
290
591
            self.cur_phase += 1
291
592
        self.pb.update(self.message, self.cur_phase, self.total)
 
593
 
 
594
 
 
595
_progress_bar_types = {}
 
596
_progress_bar_types['dummy'] = DummyProgress
 
597
_progress_bar_types['none'] = DummyProgress
 
598
_progress_bar_types['tty'] = TTYProgressBar
 
599
_progress_bar_types['dots'] = DotsProgressBar