/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

Merge lp:bzr.

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