← 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: 2010-09-01 08:02:42 UTC
  • mfrom: (5390.3.3 faster-revert-593560)
  • Revision ID: pqm@pqm.ubuntu.com-20100901080242-esg62ody4frwmy66
(spiv) Avoid repeatedly calling self.target.all_file_ids() in
 InterTree.iter_changes. (Andrew Bennetts)

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