← 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: 2009-08-07 04:17:51 UTC
  • mto: This revision was merged to the branch mainline in revision 4608.
  • Revision ID: andrew.bennetts@canonical.com-20090807041751-0vhb0y0g7k49hr45
Review comments from John.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/ui/text.py
1
 
# Copyright (C) 2005-2011 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 getpass
21
22
import os
22
23
import sys
23
24
import time
 
25
import warnings
24
26
 
25
27
from bzrlib.lazy_import import lazy_import
26
28
lazy_import(globals(), """
27
 
import codecs
28
 
import getpass
29
 
import warnings
30
 
 
31
29
from bzrlib import (
32
 
    debug,
33
30
    progress,
34
31
    osutils,
35
 
    trace,
 
32
    symbol_versioning,
36
33
    )
37
34
 
38
35
""")
51
48
                 stdout=None,
52
49
                 stderr=None):
53
50
        """Create a TextUIFactory.
 
51
 
 
52
        :param bar_type: The type of progress bar to create.  Deprecated
 
53
            and ignored; a TextProgressView is always used.
54
54
        """
55
55
        super(TextUIFactory, self).__init__()
56
56
        # TODO: there's no good reason not to pass all three streams, maybe we
60
60
        self.stderr = stderr
61
61
        # paints progress, network activity, etc
62
62
        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
 
 
 
63
        
70
64
    def clear_term(self):
71
65
        """Prepare the terminal for output.
72
66
 
90
84
                # end-of-file; possibly should raise an error here instead
91
85
                return None
92
86
 
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
87
    def get_non_echoed_password(self):
103
88
        isatty = getattr(self.stdin, 'isatty', None)
104
89
        if isatty is not None and isatty():
114
99
                password = password[:-1]
115
100
        return password
116
101
 
117
 
    def get_password(self, prompt=u'', **kwargs):
 
102
    def get_password(self, prompt='', **kwargs):
118
103
        """Prompt the user for a password.
119
104
 
120
105
        :param prompt: The prompt to present the user
152
137
    def make_progress_view(self):
153
138
        """Construct and return a new ProgressView subclass for this UI.
154
139
        """
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':
 
140
        # if the user specifically requests either text or no progress bars,
 
141
        # always do that.  otherwise, guess based on $TERM and tty presence.
 
142
        if os.environ.get('BZR_PROGRESS_BAR') == 'text':
162
143
            return TextProgressView(self.stderr)
163
144
        elif os.environ.get('BZR_PROGRESS_BAR') == 'none':
164
145
            return NullProgressView()
167
148
        else:
168
149
            return NullProgressView()
169
150
 
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
151
    def note(self, msg):
191
152
        """Write an already-formatted message, clearing the progress bar if necessary."""
192
153
        self.clear_term()
198
159
        :param kwargs: Dictionary of arguments to insert into the prompt,
199
160
            to allow UIs to reformat the prompt.
200
161
        """
201
 
        if type(prompt) != unicode:
202
 
            raise ValueError("prompt %r not a unicode string" % prompt)
203
162
        if kwargs:
204
163
            # See <https://launchpad.net/bugs/365891>
205
164
            prompt = prompt % kwargs
216
175
        self._progress_view.show_transport_activity(transport,
217
176
            direction, byte_count)
218
177
 
219
 
    def log_transport_activity(self, display=False):
220
 
        """See UIFactory.log_transport_activity()"""
221
 
        log = getattr(self._progress_view, 'log_transport_activity', None)
222
 
        if log is not None:
223
 
            log(display=display)
224
 
 
225
 
    def show_error(self, msg):
226
 
        self.clear_term()
227
 
        self.stderr.write("bzr: error: %s\n" % msg)
228
 
 
229
 
    def show_message(self, msg):
230
 
        self.note(msg)
231
 
 
232
 
    def show_warning(self, msg):
233
 
        self.clear_term()
234
 
        if isinstance(msg, unicode):
235
 
            te = osutils.get_terminal_encoding()
236
 
            msg = msg.encode(te, 'replace')
237
 
        self.stderr.write("bzr: warning: %s\n" % msg)
238
 
 
239
178
    def _progress_updated(self, task):
240
179
        """A task has been updated and wants to be displayed.
241
180
        """
243
182
            warnings.warn("%r updated but no tasks are active" %
244
183
                (task,))
245
184
        elif task != self._task_stack[-1]:
246
 
            # We used to check it was the top task, but it's hard to always
247
 
            # get this right and it's not necessarily useful: any actual
248
 
            # problems will be evident in use
249
 
            #warnings.warn("%r is not the top progress task %r" %
250
 
            #     (task, self._task_stack[-1]))
251
 
            pass
 
185
            warnings.warn("%r is not the top progress task %r" %
 
186
                (task, self._task_stack[-1]))
252
187
        self._progress_view.show_progress(task)
253
188
 
254
189
    def _progress_all_finished(self):
255
190
        self._progress_view.clear()
256
191
 
257
 
    def show_user_warning(self, warning_id, **message_args):
258
 
        """Show a text message to the user.
259
 
 
260
 
        Explicitly not for warnings about bzr apis, deprecations or internals.
261
 
        """
262
 
        # eventually trace.warning should migrate here, to avoid logging and
263
 
        # be easier to test; that has a lot of test fallout so for now just
264
 
        # new code can call this
265
 
        if warning_id not in self.suppressed_warnings:
266
 
            self.stderr.write(self.format_user_warning(warning_id, message_args) +
267
 
                '\n')
268
 
 
269
192
 
270
193
class TextProgressView(object):
271
194
    """Display of progress bar and other information on a tty.
286
209
        self._term_file = term_file
287
210
        # true when there's output on the screen we may need to clear
288
211
        self._have_output = False
 
212
        # XXX: We could listen for SIGWINCH and update the terminal width...
 
213
        # https://launchpad.net/bugs/316357
 
214
        self._width = osutils.terminal_width()
289
215
        self._last_transport_msg = ''
290
216
        self._spin_pos = 0
291
217
        # time we last repainted the screen
295
221
        self._last_task = None
296
222
        self._total_byte_count = 0
297
223
        self._bytes_since_update = 0
298
 
        self._bytes_by_direction = {'unknown': 0, 'read': 0, 'write': 0}
299
 
        self._first_byte_time = None
300
 
        self._fraction = 0
301
 
        # force the progress bar to be off, as at the moment it doesn't 
302
 
        # correspond reliably to overall command progress
303
 
        self.enable_bar = False
304
 
 
305
 
    def _avail_width(self):
306
 
        # we need one extra space for terminals that wrap on last char
307
 
        w = osutils.terminal_width() 
308
 
        if w is None:
309
 
            return None
310
 
        else:
311
 
            return w - 1
312
224
 
313
225
    def _show_line(self, s):
314
226
        # sys.stderr.write("progress %r\n" % s)
315
 
        width = self._avail_width()
316
 
        if width is not None:
317
 
            s = '%-*.*s' % (width, width, s)
318
 
        self._term_file.write('\r' + s + '\r')
 
227
        n = self._width - 1
 
228
        self._term_file.write('\r%-*.*s\r' % (n, n, s))
319
229
 
320
230
    def clear(self):
321
231
        if self._have_output:
324
234
 
325
235
    def _render_bar(self):
326
236
        # return a string for the progress bar itself
327
 
        if self.enable_bar and (
328
 
            (self._last_task is None) or self._last_task.show_bar):
 
237
        if (self._last_task is None) or self._last_task.show_bar:
329
238
            # If there's no task object, we show space for the bar anyhow.
330
239
            # That's because most invocations of bzr will end showing progress
331
240
            # at some point, though perhaps only after doing some initial IO.
336
245
            cols = 20
337
246
            if self._last_task is None:
338
247
                completion_fraction = 0
339
 
                self._fraction = 0
340
248
            else:
341
249
                completion_fraction = \
342
250
                    self._last_task._overall_completion_fraction() or 0
343
 
            if (completion_fraction < self._fraction and 'progress' in
344
 
                debug.debug_flags):
345
 
                import pdb;pdb.set_trace()
346
 
            self._fraction = completion_fraction
347
251
            markers = int(round(float(cols) * completion_fraction)) - 1
348
252
            bar_str = '[' + ('#' * markers + spin_str).ljust(cols) + '] '
349
253
            return bar_str
350
 
        elif (self._last_task is None) or self._last_task.show_spinner:
 
254
        elif self._last_task.show_spinner:
351
255
            # The last task wanted just a spinner, no bar
352
256
            spin_str =  r'/-\|'[self._spin_pos % 4]
353
257
            self._spin_pos += 1
356
260
            return ''
357
261
 
358
262
    def _format_task(self, task):
359
 
        """Format task-specific parts of progress bar.
360
 
 
361
 
        :returns: (text_part, counter_part) both unicode strings.
362
 
        """
363
263
        if not task.show_count:
364
264
            s = ''
365
265
        elif task.current_cnt is not None and task.total_cnt is not None:
375
275
            t = t._parent_task
376
276
            if t.msg:
377
277
                m = t.msg + ':' + m
378
 
        return m, s
 
278
        return m + s
379
279
 
380
280
    def _render_line(self):
381
281
        bar_string = self._render_bar()
382
282
        if self._last_task:
383
 
            task_part, counter_part = self._format_task(self._last_task)
 
283
            task_msg = self._format_task(self._last_task)
384
284
        else:
385
 
            task_part = counter_part = ''
 
285
            task_msg = ''
386
286
        if self._last_task and not self._last_task.show_transport_activity:
387
287
            trans = ''
388
288
        else:
389
289
            trans = self._last_transport_msg
390
 
        # the bar separates the transport activity from the message, so even
391
 
        # if there's no bar or spinner, we must show something if both those
392
 
        # fields are present
393
 
        if (task_part or trans) and not bar_string:
394
 
            bar_string = '| '
395
 
        # preferentially truncate the task message if we don't have enough
396
 
        # space
397
 
        avail_width = self._avail_width()
398
 
        if avail_width is not None:
399
 
            # if terminal avail_width is unknown, don't truncate
400
 
            current_len = len(bar_string) + len(trans) + len(task_part) + len(counter_part)
401
 
            gap = current_len - avail_width
402
 
            if gap > 0:
403
 
                task_part = task_part[:-gap-2] + '..'
404
 
        s = trans + bar_string + task_part + counter_part
405
 
        if avail_width is not None:
406
 
            if len(s) < avail_width:
407
 
                s = s.ljust(avail_width)
408
 
            elif len(s) > avail_width:
409
 
                s = s[:avail_width]
410
 
        return s
 
290
            if trans:
 
291
                trans += ' | '
 
292
        return (bar_string + trans + task_msg)
411
293
 
412
294
    def _repaint(self):
413
295
        s = self._render_line()
437
319
        This may update a progress bar, spinner, or similar display.
438
320
        By default it does nothing.
439
321
        """
440
 
        # XXX: there should be a transport activity model, and that too should
441
 
        #      be seen by the progress view, rather than being poked in here.
 
322
        # XXX: Probably there should be a transport activity model, and that
 
323
        # too should be seen by the progress view, rather than being poked in
 
324
        # here.
 
325
        if not self._have_output:
 
326
            # As a workaround for <https://launchpad.net/bugs/321935> we only
 
327
            # show transport activity when there's already a progress bar
 
328
            # shown, which time the application code is expected to know to
 
329
            # clear off the progress bar when it's going to send some other
 
330
            # output.  Eventually it would be nice to have that automatically
 
331
            # synchronized.
 
332
            return
442
333
        self._total_byte_count += byte_count
443
334
        self._bytes_since_update += byte_count
444
 
        if self._first_byte_time is None:
445
 
            # Note that this isn't great, as technically it should be the time
446
 
            # when the bytes started transferring, not when they completed.
447
 
            # However, we usually start with a small request anyway.
448
 
            self._first_byte_time = time.time()
449
 
        if direction in self._bytes_by_direction:
450
 
            self._bytes_by_direction[direction] += byte_count
451
 
        else:
452
 
            self._bytes_by_direction['unknown'] += byte_count
453
 
        if 'no_activity' in debug.debug_flags:
454
 
            # Can be used as a workaround if
455
 
            # <https://launchpad.net/bugs/321935> reappears and transport
456
 
            # activity is cluttering other output.  However, thanks to
457
 
            # TextUIOutputStream this shouldn't be a problem any more.
458
 
            return
459
335
        now = time.time()
460
336
        if self._total_byte_count < 2000:
461
337
            # a little resistance at first, so it doesn't stay stuck at 0
466
342
        elif now >= (self._transport_update_time + 0.5):
467
343
            # guard against clock stepping backwards, and don't update too
468
344
            # often
469
 
            rate = (self._bytes_since_update
470
 
                    / (now - self._transport_update_time))
471
 
            # using base-10 units (see HACKING.txt).
472
 
            msg = ("%6dkB %5dkB/s " %
473
 
                    (self._total_byte_count / 1000, int(rate) / 1000,))
 
345
            rate = self._bytes_since_update / (now - self._transport_update_time)
 
346
            msg = ("%6dKB %5dKB/s" %
 
347
                    (self._total_byte_count>>10, int(rate)>>10,))
474
348
            self._transport_update_time = now
475
349
            self._last_repaint = now
476
350
            self._bytes_since_update = 0
477
351
            self._last_transport_msg = msg
478
352
            self._repaint()
479
 
 
480
 
    def _format_bytes_by_direction(self):
481
 
        if self._first_byte_time is None:
482
 
            bps = 0.0
483
 
        else:
484
 
            transfer_time = time.time() - self._first_byte_time
485
 
            if transfer_time < 0.001:
486
 
                transfer_time = 0.001
487
 
            bps = self._total_byte_count / transfer_time
488
 
 
489
 
        # using base-10 units (see HACKING.txt).
490
 
        msg = ('Transferred: %.0fkB'
491
 
               ' (%.1fkB/s r:%.0fkB w:%.0fkB'
492
 
               % (self._total_byte_count / 1000.,
493
 
                  bps / 1000.,
494
 
                  self._bytes_by_direction['read'] / 1000.,
495
 
                  self._bytes_by_direction['write'] / 1000.,
496
 
                 ))
497
 
        if self._bytes_by_direction['unknown'] > 0:
498
 
            msg += ' u:%.0fkB)' % (
499
 
                self._bytes_by_direction['unknown'] / 1000.
500
 
                )
501
 
        else:
502
 
            msg += ')'
503
 
        return msg
504
 
 
505
 
    def log_transport_activity(self, display=False):
506
 
        msg = self._format_bytes_by_direction()
507
 
        trace.mutter(msg)
508
 
        if display and self._total_byte_count > 0:
509
 
            self.clear()
510
 
            self._term_file.write(msg + '\n')
511
 
 
512
 
 
513
 
class TextUIOutputStream(object):
514
 
    """Decorates an output stream so that the terminal is cleared before writing.
515
 
 
516
 
    This is supposed to ensure that the progress bar does not conflict with bulk
517
 
    text output.
518
 
    """
519
 
    # XXX: this does not handle the case of writing part of a line, then doing
520
 
    # progress bar output: the progress bar will probably write over it.
521
 
    # one option is just to buffer that text until we have a full line;
522
 
    # another is to save and restore it
523
 
 
524
 
    # XXX: might need to wrap more methods
525
 
 
526
 
    def __init__(self, ui_factory, wrapped_stream):
527
 
        self.ui_factory = ui_factory
528
 
        self.wrapped_stream = wrapped_stream
529
 
        # this does no transcoding, but it must expose the underlying encoding
530
 
        # because some callers need to know what can be written - see for
531
 
        # example unescape_for_display.
532
 
        self.encoding = getattr(wrapped_stream, 'encoding', None)
533
 
 
534
 
    def flush(self):
535
 
        self.ui_factory.clear_term()
536
 
        self.wrapped_stream.flush()
537
 
 
538
 
    def write(self, to_write):
539
 
        self.ui_factory.clear_term()
540
 
        self.wrapped_stream.write(to_write)
541
 
 
542
 
    def writelines(self, lines):
543
 
        self.ui_factory.clear_term()
544
 
        self.wrapped_stream.writelines(lines)