/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: Martin Pool
  • Date: 2009-09-24 04:54:19 UTC
  • mfrom: (4471.2.2 deprecation)
  • mto: This revision was merged to the branch mainline in revision 4715.
  • Revision ID: mbp@sourcefrog.net-20090924045419-a9c162cyftiiggju
merge old deprecation of ProgressTask.note

Show diffs side-by-side

added added

removed removed

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