← 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-02-12 04:33:05 UTC
  • mfrom: (5031 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5032.
  • Revision ID: andrew.bennetts@canonical.com-20100212043305-ujdbsdoviql2t7i3
Merge lp:bzr

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/ui/text.py
1
 
# Copyright (C) 2005, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2005-2010 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
21
22
import getpass
22
23
import os
23
24
import sys
31
32
    progress,
32
33
    osutils,
33
34
    symbol_versioning,
 
35
    trace,
34
36
    )
35
37
 
36
38
""")
59
61
        # paints progress, network activity, etc
60
62
        self._progress_view = self.make_progress_view()
61
63
        
 
64
    def be_quiet(self, state):
 
65
        if state and not self._quiet:
 
66
            self.clear_term()
 
67
        UIFactory.be_quiet(self, state)
 
68
        self._progress_view = self.make_progress_view()
 
69
 
62
70
    def clear_term(self):
63
71
        """Prepare the terminal for output.
64
72
 
82
90
                # end-of-file; possibly should raise an error here instead
83
91
                return None
84
92
 
 
93
    def get_integer(self, prompt):
 
94
        while True:
 
95
            self.prompt(prompt)
 
96
            line = self.stdin.readline()
 
97
            try:
 
98
                return int(line)
 
99
            except ValueError:
 
100
                pass
 
101
 
85
102
    def get_non_echoed_password(self):
86
103
        isatty = getattr(self.stdin, 'isatty', None)
87
104
        if isatty is not None and isatty():
135
152
    def make_progress_view(self):
136
153
        """Construct and return a new ProgressView subclass for this UI.
137
154
        """
138
 
        # if the user specifically requests either text or no progress bars,
139
 
        # always do that.  otherwise, guess based on $TERM and tty presence.
140
 
        if os.environ.get('BZR_PROGRESS_BAR') == 'text':
 
155
        # with --quiet, never any progress view
 
156
        # <https://bugs.edge.launchpad.net/bzr/+bug/320035>.  Otherwise if the
 
157
        # user specifically requests either text or no progress bars, always
 
158
        # do that.  otherwise, guess based on $TERM and tty presence.
 
159
        if self.is_quiet():
 
160
            return NullProgressView()
 
161
        elif os.environ.get('BZR_PROGRESS_BAR') == 'text':
141
162
            return TextProgressView(self.stderr)
142
163
        elif os.environ.get('BZR_PROGRESS_BAR') == 'none':
143
164
            return NullProgressView()
146
167
        else:
147
168
            return NullProgressView()
148
169
 
 
170
    def _make_output_stream_explicit(self, encoding, encoding_type):
 
171
        if encoding_type == 'exact':
 
172
            # force sys.stdout to be binary stream on win32; 
 
173
            # NB: this leaves the file set in that mode; may cause problems if
 
174
            # one process tries to do binary and then text output
 
175
            if sys.platform == 'win32':
 
176
                fileno = getattr(self.stdout, 'fileno', None)
 
177
                if fileno:
 
178
                    import msvcrt
 
179
                    msvcrt.setmode(fileno(), os.O_BINARY)
 
180
            return TextUIOutputStream(self, self.stdout)
 
181
        else:
 
182
            encoded_stdout = codecs.getwriter(encoding)(self.stdout,
 
183
                errors=encoding_type)
 
184
            # For whatever reason codecs.getwriter() does not advertise its encoding
 
185
            # it just returns the encoding of the wrapped file, which is completely
 
186
            # bogus. So set the attribute, so we can find the correct encoding later.
 
187
            encoded_stdout.encoding = encoding
 
188
            return TextUIOutputStream(self, encoded_stdout)
 
189
 
149
190
    def note(self, msg):
150
191
        """Write an already-formatted message, clearing the progress bar if necessary."""
151
192
        self.clear_term()
173
214
        self._progress_view.show_transport_activity(transport,
174
215
            direction, byte_count)
175
216
 
 
217
    def log_transport_activity(self, display=False):
 
218
        """See UIFactory.log_transport_activity()"""
 
219
        log = getattr(self._progress_view, 'log_transport_activity', None)
 
220
        if log is not None:
 
221
            log(display=display)
 
222
 
176
223
    def show_error(self, msg):
177
224
        self.clear_term()
178
225
        self.stderr.write("bzr: error: %s\n" % msg)
191
238
            warnings.warn("%r updated but no tasks are active" %
192
239
                (task,))
193
240
        elif task != self._task_stack[-1]:
194
 
            warnings.warn("%r is not the top progress task %r" %
195
 
                (task, self._task_stack[-1]))
 
241
            # We used to check it was the top task, but it's hard to always
 
242
            # get this right and it's not necessarily useful: any actual
 
243
            # problems will be evident in use
 
244
            #warnings.warn("%r is not the top progress task %r" %
 
245
            #     (task, self._task_stack[-1]))
 
246
            pass
196
247
        self._progress_view.show_progress(task)
197
248
 
198
249
    def _progress_all_finished(self):
218
269
        self._term_file = term_file
219
270
        # true when there's output on the screen we may need to clear
220
271
        self._have_output = False
221
 
        # XXX: We could listen for SIGWINCH and update the terminal width...
222
 
        # https://launchpad.net/bugs/316357
223
 
        self._width = osutils.terminal_width()
224
272
        self._last_transport_msg = ''
225
273
        self._spin_pos = 0
226
274
        # time we last repainted the screen
230
278
        self._last_task = None
231
279
        self._total_byte_count = 0
232
280
        self._bytes_since_update = 0
 
281
        self._bytes_by_direction = {'unknown': 0, 'read': 0, 'write': 0}
 
282
        self._first_byte_time = None
233
283
        self._fraction = 0
 
284
        # force the progress bar to be off, as at the moment it doesn't 
 
285
        # correspond reliably to overall command progress
 
286
        self.enable_bar = False
234
287
 
235
288
    def _show_line(self, s):
236
289
        # sys.stderr.write("progress %r\n" % s)
237
 
        n = self._width - 1
238
 
        self._term_file.write('\r%-*.*s\r' % (n, n, s))
 
290
        width = osutils.terminal_width()
 
291
        if width is not None:
 
292
            # we need one extra space for terminals that wrap on last char
 
293
            width = width - 1
 
294
            s = '%-*.*s' % (width, width, s)
 
295
        self._term_file.write('\r' + s + '\r')
239
296
 
240
297
    def clear(self):
241
298
        if self._have_output:
244
301
 
245
302
    def _render_bar(self):
246
303
        # return a string for the progress bar itself
247
 
        if (self._last_task is None) or self._last_task.show_bar:
 
304
        if self.enable_bar and (
 
305
            (self._last_task is None) or self._last_task.show_bar):
248
306
            # If there's no task object, we show space for the bar anyhow.
249
307
            # That's because most invocations of bzr will end showing progress
250
308
            # at some point, though perhaps only after doing some initial IO.
266
324
            markers = int(round(float(cols) * completion_fraction)) - 1
267
325
            bar_str = '[' + ('#' * markers + spin_str).ljust(cols) + '] '
268
326
            return bar_str
269
 
        elif self._last_task.show_spinner:
 
327
        elif (self._last_task is None) or self._last_task.show_spinner:
270
328
            # The last task wanted just a spinner, no bar
271
329
            spin_str =  r'/-\|'[self._spin_pos % 4]
272
330
            self._spin_pos += 1
334
392
        This may update a progress bar, spinner, or similar display.
335
393
        By default it does nothing.
336
394
        """
337
 
        # XXX: Probably there should be a transport activity model, and that
338
 
        # too should be seen by the progress view, rather than being poked in
339
 
        # here.
340
 
        if not self._have_output:
341
 
            # As a workaround for <https://launchpad.net/bugs/321935> we only
342
 
            # show transport activity when there's already a progress bar
343
 
            # shown, which time the application code is expected to know to
344
 
            # clear off the progress bar when it's going to send some other
345
 
            # output.  Eventually it would be nice to have that automatically
346
 
            # synchronized.
347
 
            return
 
395
        # XXX: there should be a transport activity model, and that too should
 
396
        #      be seen by the progress view, rather than being poked in here.
348
397
        self._total_byte_count += byte_count
349
398
        self._bytes_since_update += byte_count
 
399
        if self._first_byte_time is None:
 
400
            # Note that this isn't great, as technically it should be the time
 
401
            # when the bytes started transferring, not when they completed.
 
402
            # However, we usually start with a small request anyway.
 
403
            self._first_byte_time = time.time()
 
404
        if direction in self._bytes_by_direction:
 
405
            self._bytes_by_direction[direction] += byte_count
 
406
        else:
 
407
            self._bytes_by_direction['unknown'] += byte_count
 
408
        if 'no_activity' in debug.debug_flags:
 
409
            # Can be used as a workaround if
 
410
            # <https://launchpad.net/bugs/321935> reappears and transport
 
411
            # activity is cluttering other output.  However, thanks to
 
412
            # TextUIOutputStream this shouldn't be a problem any more.
 
413
            return
350
414
        now = time.time()
351
415
        if self._total_byte_count < 2000:
352
416
            # a little resistance at first, so it doesn't stay stuck at 0
357
421
        elif now >= (self._transport_update_time + 0.5):
358
422
            # guard against clock stepping backwards, and don't update too
359
423
            # often
360
 
            rate = self._bytes_since_update / (now - self._transport_update_time)
361
 
            msg = ("%6dKB %5dKB/s" %
362
 
                    (self._total_byte_count>>10, int(rate)>>10,))
 
424
            rate = (self._bytes_since_update
 
425
                    / (now - self._transport_update_time))
 
426
            # using base-10 units (see HACKING.txt).
 
427
            msg = ("%6dkB %5dkB/s" %
 
428
                    (self._total_byte_count / 1000, int(rate) / 1000,))
363
429
            self._transport_update_time = now
364
430
            self._last_repaint = now
365
431
            self._bytes_since_update = 0
366
432
            self._last_transport_msg = msg
367
433
            self._repaint()
 
434
 
 
435
    def _format_bytes_by_direction(self):
 
436
        if self._first_byte_time is None:
 
437
            bps = 0.0
 
438
        else:
 
439
            transfer_time = time.time() - self._first_byte_time
 
440
            if transfer_time < 0.001:
 
441
                transfer_time = 0.001
 
442
            bps = self._total_byte_count / transfer_time
 
443
 
 
444
        # using base-10 units (see HACKING.txt).
 
445
        msg = ('Transferred: %.0fkB'
 
446
               ' (%.1fkB/s r:%.0fkB w:%.0fkB'
 
447
               % (self._total_byte_count / 1000.,
 
448
                  bps / 1000.,
 
449
                  self._bytes_by_direction['read'] / 1000.,
 
450
                  self._bytes_by_direction['write'] / 1000.,
 
451
                 ))
 
452
        if self._bytes_by_direction['unknown'] > 0:
 
453
            msg += ' u:%.0fkB)' % (
 
454
                self._bytes_by_direction['unknown'] / 1000.
 
455
                )
 
456
        else:
 
457
            msg += ')'
 
458
        return msg
 
459
 
 
460
    def log_transport_activity(self, display=False):
 
461
        msg = self._format_bytes_by_direction()
 
462
        trace.mutter(msg)
 
463
        if display and self._total_byte_count > 0:
 
464
            self.clear()
 
465
            self._term_file.write(msg + '\n')
 
466
 
 
467
 
 
468
class TextUIOutputStream(object):
 
469
    """Decorates an output stream so that the terminal is cleared before writing.
 
470
 
 
471
    This is supposed to ensure that the progress bar does not conflict with bulk
 
472
    text output.
 
473
    """
 
474
    # XXX: this does not handle the case of writing part of a line, then doing
 
475
    # progress bar output: the progress bar will probably write over it.
 
476
    # one option is just to buffer that text until we have a full line;
 
477
    # another is to save and restore it
 
478
 
 
479
    # XXX: might need to wrap more methods
 
480
 
 
481
    def __init__(self, ui_factory, wrapped_stream):
 
482
        self.ui_factory = ui_factory
 
483
        self.wrapped_stream = wrapped_stream
 
484
        # this does no transcoding, but it must expose the underlying encoding
 
485
        # because some callers need to know what can be written - see for
 
486
        # example unescape_for_display.
 
487
        self.encoding = getattr(wrapped_stream, 'encoding', None)
 
488
 
 
489
    def flush(self):
 
490
        self.ui_factory.clear_term()
 
491
        self.wrapped_stream.flush()
 
492
 
 
493
    def write(self, to_write):
 
494
        self.ui_factory.clear_term()
 
495
        self.wrapped_stream.write(to_write)
 
496
 
 
497
    def writelines(self, lines):
 
498
        self.ui_factory.clear_term()
 
499
        self.wrapped_stream.writelines(lines)