← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/ui/text.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-09-08 06:59:26 UTC
  • mfrom: (4678.1.1 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20090908065926-at5dgy2j2spzl8u5
(vila) More test fixes for FreeBSD passing the full test suite

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
18
18
"""Text UI, write output to the console.
19
19
"""
20
20
 
21
 
import codecs
22
21
import getpass
23
22
import os
24
23
import sys
32
31
    progress,
33
32
    osutils,
34
33
    symbol_versioning,
35
 
    trace,
36
34
    )
37
35
 
38
36
""")
39
37
 
40
 
from bzrlib.osutils import watch_sigwinch
41
 
 
42
38
from bzrlib.ui import (
43
39
    UIFactory,
44
40
    NullProgressView,
53
49
                 stdout=None,
54
50
                 stderr=None):
55
51
        """Create a TextUIFactory.
 
52
 
 
53
        :param bar_type: The type of progress bar to create.  Deprecated
 
54
            and ignored; a TextProgressView is always used.
56
55
        """
57
56
        super(TextUIFactory, self).__init__()
58
57
        # TODO: there's no good reason not to pass all three streams, maybe we
62
61
        self.stderr = stderr
63
62
        # paints progress, network activity, etc
64
63
        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
 
 
 
64
        
74
65
    def clear_term(self):
75
66
        """Prepare the terminal for output.
76
67
 
94
85
                # end-of-file; possibly should raise an error here instead
95
86
                return None
96
87
 
97
 
    def get_integer(self, prompt):
98
 
        while True:
99
 
            self.prompt(prompt)
100
 
            line = self.stdin.readline()
101
 
            try:
102
 
                return int(line)
103
 
            except ValueError:
104
 
                pass
105
 
 
106
88
    def get_non_echoed_password(self):
107
89
        isatty = getattr(self.stdin, 'isatty', None)
108
90
        if isatty is not None and isatty():
156
138
    def make_progress_view(self):
157
139
        """Construct and return a new ProgressView subclass for this UI.
158
140
        """
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':
 
141
        # if the user specifically requests either text or no progress bars,
 
142
        # always do that.  otherwise, guess based on $TERM and tty presence.
 
143
        if os.environ.get('BZR_PROGRESS_BAR') == 'text':
166
144
            return TextProgressView(self.stderr)
167
145
        elif os.environ.get('BZR_PROGRESS_BAR') == 'none':
168
146
            return NullProgressView()
171
149
        else:
172
150
            return NullProgressView()
173
151
 
174
 
    def _make_output_stream_explicit(self, encoding, encoding_type):
175
 
        if encoding_type == 'exact':
176
 
            # force sys.stdout to be binary stream on win32; 
177
 
            # NB: this leaves the file set in that mode; may cause problems if
178
 
            # one process tries to do binary and then text output
179
 
            if sys.platform == 'win32':
180
 
                fileno = getattr(self.stdout, 'fileno', None)
181
 
                if fileno:
182
 
                    import msvcrt
183
 
                    msvcrt.setmode(fileno(), os.O_BINARY)
184
 
            return TextUIOutputStream(self, self.stdout)
185
 
        else:
186
 
            encoded_stdout = codecs.getwriter(encoding)(self.stdout,
187
 
                errors=encoding_type)
188
 
            # For whatever reason codecs.getwriter() does not advertise its encoding
189
 
            # it just returns the encoding of the wrapped file, which is completely
190
 
            # bogus. So set the attribute, so we can find the correct encoding later.
191
 
            encoded_stdout.encoding = encoding
192
 
            return TextUIOutputStream(self, encoded_stdout)
193
 
 
194
152
    def note(self, msg):
195
153
        """Write an already-formatted message, clearing the progress bar if necessary."""
196
154
        self.clear_term()
218
176
        self._progress_view.show_transport_activity(transport,
219
177
            direction, byte_count)
220
178
 
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
 
    def show_error(self, msg):
228
 
        self.clear_term()
229
 
        self.stderr.write("bzr: error: %s\n" % msg)
230
 
 
231
 
    def show_message(self, msg):
232
 
        self.note(msg)
233
 
 
234
 
    def show_warning(self, msg):
235
 
        self.clear_term()
236
 
        self.stderr.write("bzr: warning: %s\n" % msg)
237
 
 
238
179
    def _progress_updated(self, task):
239
180
        """A task has been updated and wants to be displayed.
240
181
        """
242
183
            warnings.warn("%r updated but no tasks are active" %
243
184
                (task,))
244
185
        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
 
186
            warnings.warn("%r is not the top progress task %r" %
 
187
                (task, self._task_stack[-1]))
251
188
        self._progress_view.show_progress(task)
252
189
 
253
190
    def _progress_all_finished(self):
273
210
        self._term_file = term_file
274
211
        # true when there's output on the screen we may need to clear
275
212
        self._have_output = False
 
213
        # XXX: We could listen for SIGWINCH and update the terminal width...
 
214
        # https://launchpad.net/bugs/316357
 
215
        self._width = osutils.terminal_width()
276
216
        self._last_transport_msg = ''
277
217
        self._spin_pos = 0
278
218
        # time we last repainted the screen
282
222
        self._last_task = None
283
223
        self._total_byte_count = 0
284
224
        self._bytes_since_update = 0
285
 
        self._bytes_by_direction = {'unknown': 0, 'read': 0, 'write': 0}
286
 
        self._first_byte_time = None
287
225
        self._fraction = 0
288
 
        # force the progress bar to be off, as at the moment it doesn't 
289
 
        # correspond reliably to overall command progress
290
 
        self.enable_bar = False
291
226
 
292
227
    def _show_line(self, s):
293
228
        # sys.stderr.write("progress %r\n" % s)
294
 
        width = osutils.terminal_width()
295
 
        if width is not None:
296
 
            # we need one extra space for terminals that wrap on last char
297
 
            width = width - 1
298
 
            s = '%-*.*s' % (width, width, s)
299
 
        self._term_file.write('\r' + s + '\r')
 
229
        n = self._width - 1
 
230
        self._term_file.write('\r%-*.*s\r' % (n, n, s))
300
231
 
301
232
    def clear(self):
302
233
        if self._have_output:
305
236
 
306
237
    def _render_bar(self):
307
238
        # return a string for the progress bar itself
308
 
        if self.enable_bar and (
309
 
            (self._last_task is None) or self._last_task.show_bar):
 
239
        if (self._last_task is None) or self._last_task.show_bar:
310
240
            # If there's no task object, we show space for the bar anyhow.
311
241
            # That's because most invocations of bzr will end showing progress
312
242
            # at some point, though perhaps only after doing some initial IO.
328
258
            markers = int(round(float(cols) * completion_fraction)) - 1
329
259
            bar_str = '[' + ('#' * markers + spin_str).ljust(cols) + '] '
330
260
            return bar_str
331
 
        elif (self._last_task is None) or self._last_task.show_spinner:
 
261
        elif self._last_task.show_spinner:
332
262
            # The last task wanted just a spinner, no bar
333
263
            spin_str =  r'/-\|'[self._spin_pos % 4]
334
264
            self._spin_pos += 1
396
326
        This may update a progress bar, spinner, or similar display.
397
327
        By default it does nothing.
398
328
        """
399
 
        # XXX: there should be a transport activity model, and that too should
400
 
        #      be seen by the progress view, rather than being poked in here.
 
329
        # XXX: Probably there should be a transport activity model, and that
 
330
        # too should be seen by the progress view, rather than being poked in
 
331
        # here.
 
332
        if not self._have_output:
 
333
            # As a workaround for <https://launchpad.net/bugs/321935> we only
 
334
            # show transport activity when there's already a progress bar
 
335
            # shown, which time the application code is expected to know to
 
336
            # clear off the progress bar when it's going to send some other
 
337
            # output.  Eventually it would be nice to have that automatically
 
338
            # synchronized.
 
339
            return
401
340
        self._total_byte_count += byte_count
402
341
        self._bytes_since_update += byte_count
403
 
        if self._first_byte_time is None:
404
 
            # Note that this isn't great, as technically it should be the time
405
 
            # when the bytes started transferring, not when they completed.
406
 
            # However, we usually start with a small request anyway.
407
 
            self._first_byte_time = time.time()
408
 
        if direction in self._bytes_by_direction:
409
 
            self._bytes_by_direction[direction] += byte_count
410
 
        else:
411
 
            self._bytes_by_direction['unknown'] += byte_count
412
 
        if 'no_activity' in debug.debug_flags:
413
 
            # Can be used as a workaround if
414
 
            # <https://launchpad.net/bugs/321935> reappears and transport
415
 
            # activity is cluttering other output.  However, thanks to
416
 
            # TextUIOutputStream this shouldn't be a problem any more.
417
 
            return
418
342
        now = time.time()
419
343
        if self._total_byte_count < 2000:
420
344
            # a little resistance at first, so it doesn't stay stuck at 0
425
349
        elif now >= (self._transport_update_time + 0.5):
426
350
            # guard against clock stepping backwards, and don't update too
427
351
            # often
428
 
            rate = (self._bytes_since_update
429
 
                    / (now - self._transport_update_time))
430
 
            # using base-10 units (see HACKING.txt).
431
 
            msg = ("%6dkB %5dkB/s" %
432
 
                    (self._total_byte_count / 1000, int(rate) / 1000,))
 
352
            rate = self._bytes_since_update / (now - self._transport_update_time)
 
353
            msg = ("%6dKB %5dKB/s" %
 
354
                    (self._total_byte_count>>10, int(rate)>>10,))
433
355
            self._transport_update_time = now
434
356
            self._last_repaint = now
435
357
            self._bytes_since_update = 0
436
358
            self._last_transport_msg = msg
437
359
            self._repaint()
438
 
 
439
 
    def _format_bytes_by_direction(self):
440
 
        if self._first_byte_time is None:
441
 
            bps = 0.0
442
 
        else:
443
 
            transfer_time = time.time() - self._first_byte_time
444
 
            if transfer_time < 0.001:
445
 
                transfer_time = 0.001
446
 
            bps = self._total_byte_count / transfer_time
447
 
 
448
 
        # using base-10 units (see HACKING.txt).
449
 
        msg = ('Transferred: %.0fkB'
450
 
               ' (%.1fkB/s r:%.0fkB w:%.0fkB'
451
 
               % (self._total_byte_count / 1000.,
452
 
                  bps / 1000.,
453
 
                  self._bytes_by_direction['read'] / 1000.,
454
 
                  self._bytes_by_direction['write'] / 1000.,
455
 
                 ))
456
 
        if self._bytes_by_direction['unknown'] > 0:
457
 
            msg += ' u:%.0fkB)' % (
458
 
                self._bytes_by_direction['unknown'] / 1000.
459
 
                )
460
 
        else:
461
 
            msg += ')'
462
 
        return msg
463
 
 
464
 
    def log_transport_activity(self, display=False):
465
 
        msg = self._format_bytes_by_direction()
466
 
        trace.mutter(msg)
467
 
        if display and self._total_byte_count > 0:
468
 
            self.clear()
469
 
            self._term_file.write(msg + '\n')
470
 
 
471
 
 
472
 
class TextUIOutputStream(object):
473
 
    """Decorates an output stream so that the terminal is cleared before writing.
474
 
 
475
 
    This is supposed to ensure that the progress bar does not conflict with bulk
476
 
    text output.
477
 
    """
478
 
    # XXX: this does not handle the case of writing part of a line, then doing
479
 
    # progress bar output: the progress bar will probably write over it.
480
 
    # one option is just to buffer that text until we have a full line;
481
 
    # another is to save and restore it
482
 
 
483
 
    # XXX: might need to wrap more methods
484
 
 
485
 
    def __init__(self, ui_factory, wrapped_stream):
486
 
        self.ui_factory = ui_factory
487
 
        self.wrapped_stream = wrapped_stream
488
 
        # this does no transcoding, but it must expose the underlying encoding
489
 
        # because some callers need to know what can be written - see for
490
 
        # example unescape_for_display.
491
 
        self.encoding = getattr(wrapped_stream, 'encoding', None)
492
 
 
493
 
    def flush(self):
494
 
        self.ui_factory.clear_term()
495
 
        self.wrapped_stream.flush()
496
 
 
497
 
    def write(self, to_write):
498
 
        self.ui_factory.clear_term()
499
 
        self.wrapped_stream.write(to_write)
500
 
 
501
 
    def writelines(self, lines):
502
 
        self.ui_factory.clear_term()
503
 
        self.wrapped_stream.writelines(lines)