← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/ui/text.py

  • Committer: Andrew Bennetts
  • Date: 2010-01-04 02:25:11 UTC
  • mfrom: (4634.108.8 2.0)
  • mto: This revision was merged to the branch mainline in revision 4928.
  • Revision ID: andrew.bennetts@canonical.com-20100104022511-2tq2r9w2te84wzgs
Merge lp:bzr/2.0 into lp:bzr, including fixes for #343218, #495000, #495023, #494406 and #498378.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/ui/text.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 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
32
32
    progress,
33
33
    osutils,
34
34
    symbol_versioning,
35
 
    trace,
36
35
    )
37
36
 
38
37
""")
39
38
 
40
 
from bzrlib.osutils import watch_sigwinch
41
 
 
42
39
from bzrlib.ui import (
43
40
    UIFactory,
44
41
    NullProgressView,
62
59
        self.stderr = stderr
63
60
        # paints progress, network activity, etc
64
61
        self._progress_view = self.make_progress_view()
65
 
        # hook up the signals to watch for terminal size changes
66
 
        watch_sigwinch()
67
 
 
68
 
    def be_quiet(self, state):
69
 
        if state and not self._quiet:
70
 
            self.clear_term()
71
 
        UIFactory.be_quiet(self, state)
72
 
        self._progress_view = self.make_progress_view()
73
 
 
 
62
        
74
63
    def clear_term(self):
75
64
        """Prepare the terminal for output.
76
65
 
156
145
    def make_progress_view(self):
157
146
        """Construct and return a new ProgressView subclass for this UI.
158
147
        """
159
 
        # with --quiet, never any progress view
160
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/320035>.  Otherwise if the
161
 
        # user specifically requests either text or no progress bars, always
162
 
        # do that.  otherwise, guess based on $TERM and tty presence.
163
 
        if self.is_quiet():
164
 
            return NullProgressView()
165
 
        elif os.environ.get('BZR_PROGRESS_BAR') == 'text':
 
148
        # if the user specifically requests either text or no progress bars,
 
149
        # always do that.  otherwise, guess based on $TERM and tty presence.
 
150
        if os.environ.get('BZR_PROGRESS_BAR') == 'text':
166
151
            return TextProgressView(self.stderr)
167
152
        elif os.environ.get('BZR_PROGRESS_BAR') == 'none':
168
153
            return NullProgressView()
218
203
        self._progress_view.show_transport_activity(transport,
219
204
            direction, byte_count)
220
205
 
221
 
    def log_transport_activity(self, display=False):
222
 
        """See UIFactory.log_transport_activity()"""
223
 
        log = getattr(self._progress_view, 'log_transport_activity', None)
224
 
        if log is not None:
225
 
            log(display=display)
226
 
 
227
206
    def show_error(self, msg):
228
207
        self.clear_term()
229
208
        self.stderr.write("bzr: error: %s\n" % msg)
242
221
            warnings.warn("%r updated but no tasks are active" %
243
222
                (task,))
244
223
        elif task != self._task_stack[-1]:
245
 
            # We used to check it was the top task, but it's hard to always
246
 
            # get this right and it's not necessarily useful: any actual
247
 
            # problems will be evident in use
248
 
            #warnings.warn("%r is not the top progress task %r" %
249
 
            #     (task, self._task_stack[-1]))
250
 
            pass
 
224
            warnings.warn("%r is not the top progress task %r" %
 
225
                (task, self._task_stack[-1]))
251
226
        self._progress_view.show_progress(task)
252
227
 
253
228
    def _progress_all_finished(self):
254
229
        self._progress_view.clear()
255
230
 
256
 
    def show_user_warning(self, warning_id, **message_args):
257
 
        """Show a text message to the user.
258
 
 
259
 
        Explicitly not for warnings about bzr apis, deprecations or internals.
260
 
        """
261
 
        # eventually trace.warning should migrate here, to avoid logging and
262
 
        # be easier to test; that has a lot of test fallout so for now just
263
 
        # new code can call this
264
 
        if warning_id not in self.suppressed_warnings:
265
 
            self.stderr.write(self.format_user_warning(warning_id, message_args) +
266
 
                '\n')
267
 
 
268
231
 
269
232
class TextProgressView(object):
270
233
    """Display of progress bar and other information on a tty.
294
257
        self._last_task = None
295
258
        self._total_byte_count = 0
296
259
        self._bytes_since_update = 0
297
 
        self._bytes_by_direction = {'unknown': 0, 'read': 0, 'write': 0}
298
 
        self._first_byte_time = None
299
260
        self._fraction = 0
300
261
        # force the progress bar to be off, as at the moment it doesn't 
301
262
        # correspond reliably to overall command progress
408
369
        This may update a progress bar, spinner, or similar display.
409
370
        By default it does nothing.
410
371
        """
411
 
        # XXX: there should be a transport activity model, and that too should
412
 
        #      be seen by the progress view, rather than being poked in here.
413
 
        self._total_byte_count += byte_count
414
 
        self._bytes_since_update += byte_count
415
 
        if self._first_byte_time is None:
416
 
            # Note that this isn't great, as technically it should be the time
417
 
            # when the bytes started transferring, not when they completed.
418
 
            # However, we usually start with a small request anyway.
419
 
            self._first_byte_time = time.time()
420
 
        if direction in self._bytes_by_direction:
421
 
            self._bytes_by_direction[direction] += byte_count
422
 
        else:
423
 
            self._bytes_by_direction['unknown'] += byte_count
 
372
        # XXX: Probably there should be a transport activity model, and that
 
373
        # too should be seen by the progress view, rather than being poked in
 
374
        # here.
424
375
        if 'no_activity' in debug.debug_flags:
425
376
            # Can be used as a workaround if
426
377
            # <https://launchpad.net/bugs/321935> reappears and transport
427
378
            # activity is cluttering other output.  However, thanks to
428
379
            # TextUIOutputStream this shouldn't be a problem any more.
429
380
            return
 
381
        self._total_byte_count += byte_count
 
382
        self._bytes_since_update += byte_count
430
383
        now = time.time()
431
384
        if self._total_byte_count < 2000:
432
385
            # a little resistance at first, so it doesn't stay stuck at 0
437
390
        elif now >= (self._transport_update_time + 0.5):
438
391
            # guard against clock stepping backwards, and don't update too
439
392
            # often
440
 
            rate = (self._bytes_since_update
441
 
                    / (now - self._transport_update_time))
442
 
            # using base-10 units (see HACKING.txt).
443
 
            msg = ("%6dkB %5dkB/s" %
444
 
                    (self._total_byte_count / 1000, int(rate) / 1000,))
 
393
            rate = self._bytes_since_update / (now - self._transport_update_time)
 
394
            msg = ("%6dKB %5dKB/s" %
 
395
                    (self._total_byte_count>>10, int(rate)>>10,))
445
396
            self._transport_update_time = now
446
397
            self._last_repaint = now
447
398
            self._bytes_since_update = 0
448
399
            self._last_transport_msg = msg
449
400
            self._repaint()
450
401
 
451
 
    def _format_bytes_by_direction(self):
452
 
        if self._first_byte_time is None:
453
 
            bps = 0.0
454
 
        else:
455
 
            transfer_time = time.time() - self._first_byte_time
456
 
            if transfer_time < 0.001:
457
 
                transfer_time = 0.001
458
 
            bps = self._total_byte_count / transfer_time
459
 
 
460
 
        # using base-10 units (see HACKING.txt).
461
 
        msg = ('Transferred: %.0fkB'
462
 
               ' (%.1fkB/s r:%.0fkB w:%.0fkB'
463
 
               % (self._total_byte_count / 1000.,
464
 
                  bps / 1000.,
465
 
                  self._bytes_by_direction['read'] / 1000.,
466
 
                  self._bytes_by_direction['write'] / 1000.,
467
 
                 ))
468
 
        if self._bytes_by_direction['unknown'] > 0:
469
 
            msg += ' u:%.0fkB)' % (
470
 
                self._bytes_by_direction['unknown'] / 1000.
471
 
                )
472
 
        else:
473
 
            msg += ')'
474
 
        return msg
475
 
 
476
 
    def log_transport_activity(self, display=False):
477
 
        msg = self._format_bytes_by_direction()
478
 
        trace.mutter(msg)
479
 
        if display and self._total_byte_count > 0:
480
 
            self.clear()
481
 
            self._term_file.write(msg + '\n')
482
 
 
483
402
 
484
403
class TextUIOutputStream(object):
485
404
    """Decorates an output stream so that the terminal is cleared before writing.