/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/ui/text.py

  • Committer: Patrick Regan
  • Date: 2009-12-02 20:34:07 UTC
  • mto: (4852.3.3 2.1.0b4-doc-updates)
  • mto: This revision was merged to the branch mainline in revision 4856.
  • Revision ID: patrick.rubbs.regan@gmail.com-20091202203407-fjd0mshgn3j3foel
Removed trailing whitespace from files in doc directory

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
""")
60
58
        self.stderr = stderr
61
59
        # paints progress, network activity, etc
62
60
        self._progress_view = self.make_progress_view()
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
 
 
 
61
        
70
62
    def clear_term(self):
71
63
        """Prepare the terminal for output.
72
64
 
90
82
                # end-of-file; possibly should raise an error here instead
91
83
                return None
92
84
 
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
 
 
102
85
    def get_non_echoed_password(self):
103
86
        isatty = getattr(self.stdin, 'isatty', None)
104
87
        if isatty is not None and isatty():
152
135
    def make_progress_view(self):
153
136
        """Construct and return a new ProgressView subclass for this UI.
154
137
        """
155
 
        # with --quiet, never any progress view
156
 
        # <https://bugs.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':
 
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':
162
141
            return TextProgressView(self.stderr)
163
142
        elif os.environ.get('BZR_PROGRESS_BAR') == 'none':
164
143
            return NullProgressView()
167
146
        else:
168
147
            return NullProgressView()
169
148
 
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
 
 
190
149
    def note(self, msg):
191
150
        """Write an already-formatted message, clearing the progress bar if necessary."""
192
151
        self.clear_term()
214
173
        self._progress_view.show_transport_activity(transport,
215
174
            direction, byte_count)
216
175
 
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
 
 
223
176
    def show_error(self, msg):
224
177
        self.clear_term()
225
178
        self.stderr.write("bzr: error: %s\n" % msg)
229
182
 
230
183
    def show_warning(self, msg):
231
184
        self.clear_term()
232
 
        if isinstance(msg, unicode):
233
 
            te = osutils.get_terminal_encoding()
234
 
            msg = msg.encode(te, 'replace')
235
185
        self.stderr.write("bzr: warning: %s\n" % msg)
236
186
 
237
187
    def _progress_updated(self, task):
241
191
            warnings.warn("%r updated but no tasks are active" %
242
192
                (task,))
243
193
        elif task != self._task_stack[-1]:
244
 
            # We used to check it was the top task, but it's hard to always
245
 
            # get this right and it's not necessarily useful: any actual
246
 
            # problems will be evident in use
247
 
            #warnings.warn("%r is not the top progress task %r" %
248
 
            #     (task, self._task_stack[-1]))
249
 
            pass
 
194
            warnings.warn("%r is not the top progress task %r" %
 
195
                (task, self._task_stack[-1]))
250
196
        self._progress_view.show_progress(task)
251
197
 
252
198
    def _progress_all_finished(self):
253
199
        self._progress_view.clear()
254
200
 
255
 
    def show_user_warning(self, warning_id, **message_args):
256
 
        """Show a text message to the user.
257
 
 
258
 
        Explicitly not for warnings about bzr apis, deprecations or internals.
259
 
        """
260
 
        # eventually trace.warning should migrate here, to avoid logging and
261
 
        # be easier to test; that has a lot of test fallout so for now just
262
 
        # new code can call this
263
 
        if warning_id not in self.suppressed_warnings:
264
 
            self.stderr.write(self.format_user_warning(warning_id, message_args) +
265
 
                '\n')
266
 
 
267
201
 
268
202
class TextProgressView(object):
269
203
    """Display of progress bar and other information on a tty.
284
218
        self._term_file = term_file
285
219
        # true when there's output on the screen we may need to clear
286
220
        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()
287
224
        self._last_transport_msg = ''
288
225
        self._spin_pos = 0
289
226
        # time we last repainted the screen
293
230
        self._last_task = None
294
231
        self._total_byte_count = 0
295
232
        self._bytes_since_update = 0
296
 
        self._bytes_by_direction = {'unknown': 0, 'read': 0, 'write': 0}
297
 
        self._first_byte_time = None
298
233
        self._fraction = 0
299
 
        # force the progress bar to be off, as at the moment it doesn't 
300
 
        # correspond reliably to overall command progress
301
 
        self.enable_bar = False
302
234
 
303
235
    def _show_line(self, s):
304
236
        # sys.stderr.write("progress %r\n" % s)
305
 
        width = osutils.terminal_width()
306
 
        if width is not None:
307
 
            # we need one extra space for terminals that wrap on last char
308
 
            width = width - 1
309
 
            s = '%-*.*s' % (width, width, s)
310
 
        self._term_file.write('\r' + s + '\r')
 
237
        n = self._width - 1
 
238
        self._term_file.write('\r%-*.*s\r' % (n, n, s))
311
239
 
312
240
    def clear(self):
313
241
        if self._have_output:
316
244
 
317
245
    def _render_bar(self):
318
246
        # return a string for the progress bar itself
319
 
        if self.enable_bar and (
320
 
            (self._last_task is None) or self._last_task.show_bar):
 
247
        if (self._last_task is None) or self._last_task.show_bar:
321
248
            # If there's no task object, we show space for the bar anyhow.
322
249
            # That's because most invocations of bzr will end showing progress
323
250
            # at some point, though perhaps only after doing some initial IO.
339
266
            markers = int(round(float(cols) * completion_fraction)) - 1
340
267
            bar_str = '[' + ('#' * markers + spin_str).ljust(cols) + '] '
341
268
            return bar_str
342
 
        elif (self._last_task is None) or self._last_task.show_spinner:
 
269
        elif self._last_task.show_spinner:
343
270
            # The last task wanted just a spinner, no bar
344
271
            spin_str =  r'/-\|'[self._spin_pos % 4]
345
272
            self._spin_pos += 1
407
334
        This may update a progress bar, spinner, or similar display.
408
335
        By default it does nothing.
409
336
        """
410
 
        # XXX: there should be a transport activity model, and that too should
411
 
        #      be seen by the progress view, rather than being poked in here.
 
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
412
348
        self._total_byte_count += byte_count
413
349
        self._bytes_since_update += byte_count
414
 
        if self._first_byte_time is None:
415
 
            # Note that this isn't great, as technically it should be the time
416
 
            # when the bytes started transferring, not when they completed.
417
 
            # However, we usually start with a small request anyway.
418
 
            self._first_byte_time = time.time()
419
 
        if direction in self._bytes_by_direction:
420
 
            self._bytes_by_direction[direction] += byte_count
421
 
        else:
422
 
            self._bytes_by_direction['unknown'] += byte_count
423
 
        if 'no_activity' in debug.debug_flags:
424
 
            # Can be used as a workaround if
425
 
            # <https://launchpad.net/bugs/321935> reappears and transport
426
 
            # activity is cluttering other output.  However, thanks to
427
 
            # TextUIOutputStream this shouldn't be a problem any more.
428
 
            return
429
350
        now = time.time()
430
351
        if self._total_byte_count < 2000:
431
352
            # a little resistance at first, so it doesn't stay stuck at 0
436
357
        elif now >= (self._transport_update_time + 0.5):
437
358
            # guard against clock stepping backwards, and don't update too
438
359
            # often
439
 
            rate = (self._bytes_since_update
440
 
                    / (now - self._transport_update_time))
441
 
            # using base-10 units (see HACKING.txt).
442
 
            msg = ("%6dkB %5dkB/s" %
443
 
                    (self._total_byte_count / 1000, int(rate) / 1000,))
 
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,))
444
363
            self._transport_update_time = now
445
364
            self._last_repaint = now
446
365
            self._bytes_since_update = 0
447
366
            self._last_transport_msg = msg
448
367
            self._repaint()
449
 
 
450
 
    def _format_bytes_by_direction(self):
451
 
        if self._first_byte_time is None:
452
 
            bps = 0.0
453
 
        else:
454
 
            transfer_time = time.time() - self._first_byte_time
455
 
            if transfer_time < 0.001:
456
 
                transfer_time = 0.001
457
 
            bps = self._total_byte_count / transfer_time
458
 
 
459
 
        # using base-10 units (see HACKING.txt).
460
 
        msg = ('Transferred: %.0fkB'
461
 
               ' (%.1fkB/s r:%.0fkB w:%.0fkB'
462
 
               % (self._total_byte_count / 1000.,
463
 
                  bps / 1000.,
464
 
                  self._bytes_by_direction['read'] / 1000.,
465
 
                  self._bytes_by_direction['write'] / 1000.,
466
 
                 ))
467
 
        if self._bytes_by_direction['unknown'] > 0:
468
 
            msg += ' u:%.0fkB)' % (
469
 
                self._bytes_by_direction['unknown'] / 1000.
470
 
                )
471
 
        else:
472
 
            msg += ')'
473
 
        return msg
474
 
 
475
 
    def log_transport_activity(self, display=False):
476
 
        msg = self._format_bytes_by_direction()
477
 
        trace.mutter(msg)
478
 
        if display and self._total_byte_count > 0:
479
 
            self.clear()
480
 
            self._term_file.write(msg + '\n')
481
 
 
482
 
 
483
 
class TextUIOutputStream(object):
484
 
    """Decorates an output stream so that the terminal is cleared before writing.
485
 
 
486
 
    This is supposed to ensure that the progress bar does not conflict with bulk
487
 
    text output.
488
 
    """
489
 
    # XXX: this does not handle the case of writing part of a line, then doing
490
 
    # progress bar output: the progress bar will probably write over it.
491
 
    # one option is just to buffer that text until we have a full line;
492
 
    # another is to save and restore it
493
 
 
494
 
    # XXX: might need to wrap more methods
495
 
 
496
 
    def __init__(self, ui_factory, wrapped_stream):
497
 
        self.ui_factory = ui_factory
498
 
        self.wrapped_stream = wrapped_stream
499
 
        # this does no transcoding, but it must expose the underlying encoding
500
 
        # because some callers need to know what can be written - see for
501
 
        # example unescape_for_display.
502
 
        self.encoding = getattr(wrapped_stream, 'encoding', None)
503
 
 
504
 
    def flush(self):
505
 
        self.ui_factory.clear_term()
506
 
        self.wrapped_stream.flush()
507
 
 
508
 
    def write(self, to_write):
509
 
        self.ui_factory.clear_term()
510
 
        self.wrapped_stream.write(to_write)
511
 
 
512
 
    def writelines(self, lines):
513
 
        self.ui_factory.clear_term()
514
 
        self.wrapped_stream.writelines(lines)