← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/ui/text.py

(jelmer) Use the absolute_import feature everywhere in bzrlib,
 and add a source test to make sure it's used everywhere. (Jelmer Vernooij)

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-2011 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
from __future__ import absolute_import
 
22
 
22
23
import os
23
24
import sys
24
25
import time
25
 
import warnings
26
26
 
27
27
from bzrlib.lazy_import import lazy_import
28
28
lazy_import(globals(), """
 
29
import codecs
 
30
import getpass
 
31
import warnings
 
32
 
29
33
from bzrlib import (
30
34
    debug,
31
35
    progress,
32
36
    osutils,
33
 
    symbol_versioning,
 
37
    trace,
34
38
    )
35
39
 
36
40
""")
41
45
    )
42
46
 
43
47
 
 
48
class _ChooseUI(object):
 
49
 
 
50
    """ Helper class for choose implementation.
 
51
    """
 
52
 
 
53
    def __init__(self, ui, msg, choices, default):
 
54
        self.ui = ui
 
55
        self._setup_mode()
 
56
        self._build_alternatives(msg, choices, default)
 
57
 
 
58
    def _setup_mode(self):
 
59
        """Setup input mode (line-based, char-based) and echo-back.
 
60
 
 
61
        Line-based input is used if the BZR_TEXTUI_INPUT environment
 
62
        variable is set to 'line-based', or if there is no controlling
 
63
        terminal.
 
64
        """
 
65
        if os.environ.get('BZR_TEXTUI_INPUT') != 'line-based' and \
 
66
           self.ui.stdin == sys.stdin and self.ui.stdin.isatty():
 
67
            self.line_based = False
 
68
            self.echo_back = True
 
69
        else:
 
70
            self.line_based = True
 
71
            self.echo_back = not self.ui.stdin.isatty()
 
72
 
 
73
    def _build_alternatives(self, msg, choices, default):
 
74
        """Parse choices string.
 
75
 
 
76
        Setup final prompt and the lists of choices and associated
 
77
        shortcuts.
 
78
        """
 
79
        index = 0
 
80
        help_list = []
 
81
        self.alternatives = {}
 
82
        choices = choices.split('\n')
 
83
        if default is not None and default not in range(0, len(choices)):
 
84
            raise ValueError("invalid default index")
 
85
        for c in choices:
 
86
            name = c.replace('&', '').lower()
 
87
            choice = (name, index)
 
88
            if name in self.alternatives:
 
89
                raise ValueError("duplicated choice: %s" % name)
 
90
            self.alternatives[name] = choice
 
91
            shortcut = c.find('&')
 
92
            if -1 != shortcut and (shortcut + 1) < len(c):
 
93
                help = c[:shortcut]
 
94
                help += '[' + c[shortcut + 1] + ']'
 
95
                help += c[(shortcut + 2):]
 
96
                shortcut = c[shortcut + 1]
 
97
            else:
 
98
                c = c.replace('&', '')
 
99
                shortcut = c[0]
 
100
                help = '[%s]%s' % (shortcut, c[1:])
 
101
            shortcut = shortcut.lower()
 
102
            if shortcut in self.alternatives:
 
103
                raise ValueError("duplicated shortcut: %s" % shortcut)
 
104
            self.alternatives[shortcut] = choice
 
105
            # Add redirections for default.
 
106
            if index == default:
 
107
                self.alternatives[''] = choice
 
108
                self.alternatives['\r'] = choice
 
109
            help_list.append(help)
 
110
            index += 1
 
111
 
 
112
        self.prompt = u'%s (%s): ' % (msg, ', '.join(help_list))
 
113
 
 
114
    def _getline(self):
 
115
        line = self.ui.stdin.readline()
 
116
        if '' == line:
 
117
            raise EOFError
 
118
        return line.strip()
 
119
 
 
120
    def _getchar(self):
 
121
        char = osutils.getchar()
 
122
        if char == chr(3): # INTR
 
123
            raise KeyboardInterrupt
 
124
        if char == chr(4): # EOF (^d, C-d)
 
125
            raise EOFError
 
126
        return char
 
127
 
 
128
    def interact(self):
 
129
        """Keep asking the user until a valid choice is made.
 
130
        """
 
131
        if self.line_based:
 
132
            getchoice = self._getline
 
133
        else:
 
134
            getchoice = self._getchar
 
135
        iter = 0
 
136
        while True:
 
137
            iter += 1
 
138
            if 1 == iter or self.line_based:
 
139
                self.ui.prompt(self.prompt)
 
140
            try:
 
141
                choice = getchoice()
 
142
            except EOFError:
 
143
                self.ui.stderr.write('\n')
 
144
                return None
 
145
            except KeyboardInterrupt:
 
146
                self.ui.stderr.write('\n')
 
147
                raise KeyboardInterrupt
 
148
            choice = choice.lower()
 
149
            if choice not in self.alternatives:
 
150
                # Not a valid choice, keep on asking.
 
151
                continue
 
152
            name, index = self.alternatives[choice]
 
153
            if self.echo_back:
 
154
                self.ui.stderr.write(name + '\n')
 
155
            return index
 
156
 
 
157
 
44
158
class TextUIFactory(UIFactory):
45
159
    """A UI factory for Text user interefaces."""
46
160
 
58
172
        self.stderr = stderr
59
173
        # paints progress, network activity, etc
60
174
        self._progress_view = self.make_progress_view()
61
 
        
 
175
 
 
176
    def choose(self, msg, choices, default=None):
 
177
        """Prompt the user for a list of alternatives.
 
178
 
 
179
        Support both line-based and char-based editing.
 
180
 
 
181
        In line-based mode, both the shortcut and full choice name are valid
 
182
        answers, e.g. for choose('prompt', '&yes\n&no'): 'y', ' Y ', ' yes',
 
183
        'YES ' are all valid input lines for choosing 'yes'.
 
184
 
 
185
        An empty line, when in line-based mode, or pressing enter in char-based
 
186
        mode will select the default choice (if any).
 
187
 
 
188
        Choice is echoed back if:
 
189
        - input is char-based; which means a controlling terminal is available,
 
190
          and osutils.getchar is used
 
191
        - input is line-based, and no controlling terminal is available
 
192
        """
 
193
 
 
194
        choose_ui = _ChooseUI(self, msg, choices, default)
 
195
        return choose_ui.interact()
 
196
 
 
197
    def be_quiet(self, state):
 
198
        if state and not self._quiet:
 
199
            self.clear_term()
 
200
        UIFactory.be_quiet(self, state)
 
201
        self._progress_view = self.make_progress_view()
 
202
 
62
203
    def clear_term(self):
63
204
        """Prepare the terminal for output.
64
205
 
70
211
        # to clear it.  We might need to separately check for the case of
71
212
        self._progress_view.clear()
72
213
 
73
 
    def get_boolean(self, prompt):
 
214
    def get_integer(self, prompt):
74
215
        while True:
75
 
            self.prompt(prompt + "? [y/n]: ")
76
 
            line = self.stdin.readline().lower()
77
 
            if line in ('y\n', 'yes\n'):
78
 
                return True
79
 
            elif line in ('n\n', 'no\n'):
80
 
                return False
81
 
            elif line in ('', None):
82
 
                # end-of-file; possibly should raise an error here instead
83
 
                return None
 
216
            self.prompt(prompt)
 
217
            line = self.stdin.readline()
 
218
            try:
 
219
                return int(line)
 
220
            except ValueError:
 
221
                pass
84
222
 
85
223
    def get_non_echoed_password(self):
86
224
        isatty = getattr(self.stdin, 'isatty', None)
97
235
                password = password[:-1]
98
236
        return password
99
237
 
100
 
    def get_password(self, prompt='', **kwargs):
 
238
    def get_password(self, prompt=u'', **kwargs):
101
239
        """Prompt the user for a password.
102
240
 
103
241
        :param prompt: The prompt to present the user
135
273
    def make_progress_view(self):
136
274
        """Construct and return a new ProgressView subclass for this UI.
137
275
        """
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':
 
276
        # with --quiet, never any progress view
 
277
        # <https://bugs.launchpad.net/bzr/+bug/320035>.  Otherwise if the
 
278
        # user specifically requests either text or no progress bars, always
 
279
        # do that.  otherwise, guess based on $TERM and tty presence.
 
280
        if self.is_quiet():
 
281
            return NullProgressView()
 
282
        elif os.environ.get('BZR_PROGRESS_BAR') == 'text':
141
283
            return TextProgressView(self.stderr)
142
284
        elif os.environ.get('BZR_PROGRESS_BAR') == 'none':
143
285
            return NullProgressView()
146
288
        else:
147
289
            return NullProgressView()
148
290
 
 
291
    def _make_output_stream_explicit(self, encoding, encoding_type):
 
292
        if encoding_type == 'exact':
 
293
            # force sys.stdout to be binary stream on win32; 
 
294
            # NB: this leaves the file set in that mode; may cause problems if
 
295
            # one process tries to do binary and then text output
 
296
            if sys.platform == 'win32':
 
297
                fileno = getattr(self.stdout, 'fileno', None)
 
298
                if fileno:
 
299
                    import msvcrt
 
300
                    msvcrt.setmode(fileno(), os.O_BINARY)
 
301
            return TextUIOutputStream(self, self.stdout)
 
302
        else:
 
303
            encoded_stdout = codecs.getwriter(encoding)(self.stdout,
 
304
                errors=encoding_type)
 
305
            # For whatever reason codecs.getwriter() does not advertise its encoding
 
306
            # it just returns the encoding of the wrapped file, which is completely
 
307
            # bogus. So set the attribute, so we can find the correct encoding later.
 
308
            encoded_stdout.encoding = encoding
 
309
            return TextUIOutputStream(self, encoded_stdout)
 
310
 
149
311
    def note(self, msg):
150
312
        """Write an already-formatted message, clearing the progress bar if necessary."""
151
313
        self.clear_term()
157
319
        :param kwargs: Dictionary of arguments to insert into the prompt,
158
320
            to allow UIs to reformat the prompt.
159
321
        """
 
322
        if type(prompt) != unicode:
 
323
            raise ValueError("prompt %r not a unicode string" % prompt)
160
324
        if kwargs:
161
325
            # See <https://launchpad.net/bugs/365891>
162
326
            prompt = prompt % kwargs
163
327
        prompt = prompt.encode(osutils.get_terminal_encoding(), 'replace')
164
328
        self.clear_term()
 
329
        self.stdout.flush()
165
330
        self.stderr.write(prompt)
166
331
 
167
332
    def report_transport_activity(self, transport, byte_count, direction):
173
338
        self._progress_view.show_transport_activity(transport,
174
339
            direction, byte_count)
175
340
 
 
341
    def log_transport_activity(self, display=False):
 
342
        """See UIFactory.log_transport_activity()"""
 
343
        log = getattr(self._progress_view, 'log_transport_activity', None)
 
344
        if log is not None:
 
345
            log(display=display)
 
346
 
176
347
    def show_error(self, msg):
177
348
        self.clear_term()
178
349
        self.stderr.write("bzr: error: %s\n" % msg)
182
353
 
183
354
    def show_warning(self, msg):
184
355
        self.clear_term()
 
356
        if isinstance(msg, unicode):
 
357
            te = osutils.get_terminal_encoding()
 
358
            msg = msg.encode(te, 'replace')
185
359
        self.stderr.write("bzr: warning: %s\n" % msg)
186
360
 
187
361
    def _progress_updated(self, task):
191
365
            warnings.warn("%r updated but no tasks are active" %
192
366
                (task,))
193
367
        elif task != self._task_stack[-1]:
194
 
            warnings.warn("%r is not the top progress task %r" %
195
 
                (task, self._task_stack[-1]))
 
368
            # We used to check it was the top task, but it's hard to always
 
369
            # get this right and it's not necessarily useful: any actual
 
370
            # problems will be evident in use
 
371
            #warnings.warn("%r is not the top progress task %r" %
 
372
            #     (task, self._task_stack[-1]))
 
373
            pass
196
374
        self._progress_view.show_progress(task)
197
375
 
198
376
    def _progress_all_finished(self):
199
377
        self._progress_view.clear()
200
378
 
 
379
    def show_user_warning(self, warning_id, **message_args):
 
380
        """Show a text message to the user.
 
381
 
 
382
        Explicitly not for warnings about bzr apis, deprecations or internals.
 
383
        """
 
384
        # eventually trace.warning should migrate here, to avoid logging and
 
385
        # be easier to test; that has a lot of test fallout so for now just
 
386
        # new code can call this
 
387
        if warning_id not in self.suppressed_warnings:
 
388
            self.stderr.write(self.format_user_warning(warning_id, message_args) +
 
389
                '\n')
 
390
 
201
391
 
202
392
class TextProgressView(object):
203
393
    """Display of progress bar and other information on a tty.
218
408
        self._term_file = term_file
219
409
        # true when there's output on the screen we may need to clear
220
410
        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
411
        self._last_transport_msg = ''
225
412
        self._spin_pos = 0
226
413
        # time we last repainted the screen
230
417
        self._last_task = None
231
418
        self._total_byte_count = 0
232
419
        self._bytes_since_update = 0
 
420
        self._bytes_by_direction = {'unknown': 0, 'read': 0, 'write': 0}
 
421
        self._first_byte_time = None
233
422
        self._fraction = 0
 
423
        # force the progress bar to be off, as at the moment it doesn't 
 
424
        # correspond reliably to overall command progress
 
425
        self.enable_bar = False
 
426
 
 
427
    def _avail_width(self):
 
428
        # we need one extra space for terminals that wrap on last char
 
429
        w = osutils.terminal_width() 
 
430
        if w is None:
 
431
            return None
 
432
        else:
 
433
            return w - 1
234
434
 
235
435
    def _show_line(self, s):
236
436
        # sys.stderr.write("progress %r\n" % s)
237
 
        n = self._width - 1
238
 
        self._term_file.write('\r%-*.*s\r' % (n, n, s))
 
437
        width = self._avail_width()
 
438
        if width is not None:
 
439
            s = '%-*.*s' % (width, width, s)
 
440
        self._term_file.write('\r' + s + '\r')
239
441
 
240
442
    def clear(self):
241
443
        if self._have_output:
244
446
 
245
447
    def _render_bar(self):
246
448
        # return a string for the progress bar itself
247
 
        if (self._last_task is None) or self._last_task.show_bar:
 
449
        if self.enable_bar and (
 
450
            (self._last_task is None) or self._last_task.show_bar):
248
451
            # If there's no task object, we show space for the bar anyhow.
249
452
            # That's because most invocations of bzr will end showing progress
250
453
            # at some point, though perhaps only after doing some initial IO.
266
469
            markers = int(round(float(cols) * completion_fraction)) - 1
267
470
            bar_str = '[' + ('#' * markers + spin_str).ljust(cols) + '] '
268
471
            return bar_str
269
 
        elif self._last_task.show_spinner:
 
472
        elif (self._last_task is None) or self._last_task.show_spinner:
270
473
            # The last task wanted just a spinner, no bar
271
474
            spin_str =  r'/-\|'[self._spin_pos % 4]
272
475
            self._spin_pos += 1
275
478
            return ''
276
479
 
277
480
    def _format_task(self, task):
 
481
        """Format task-specific parts of progress bar.
 
482
 
 
483
        :returns: (text_part, counter_part) both unicode strings.
 
484
        """
278
485
        if not task.show_count:
279
486
            s = ''
280
487
        elif task.current_cnt is not None and task.total_cnt is not None:
290
497
            t = t._parent_task
291
498
            if t.msg:
292
499
                m = t.msg + ':' + m
293
 
        return m + s
 
500
        return m, s
294
501
 
295
502
    def _render_line(self):
296
503
        bar_string = self._render_bar()
297
504
        if self._last_task:
298
 
            task_msg = self._format_task(self._last_task)
 
505
            task_part, counter_part = self._format_task(self._last_task)
299
506
        else:
300
 
            task_msg = ''
 
507
            task_part = counter_part = ''
301
508
        if self._last_task and not self._last_task.show_transport_activity:
302
509
            trans = ''
303
510
        else:
304
511
            trans = self._last_transport_msg
305
 
            if trans:
306
 
                trans += ' | '
307
 
        return (bar_string + trans + task_msg)
 
512
        # the bar separates the transport activity from the message, so even
 
513
        # if there's no bar or spinner, we must show something if both those
 
514
        # fields are present
 
515
        if (task_part or trans) and not bar_string:
 
516
            bar_string = '| '
 
517
        # preferentially truncate the task message if we don't have enough
 
518
        # space
 
519
        avail_width = self._avail_width()
 
520
        if avail_width is not None:
 
521
            # if terminal avail_width is unknown, don't truncate
 
522
            current_len = len(bar_string) + len(trans) + len(task_part) + len(counter_part)
 
523
            gap = current_len - avail_width
 
524
            if gap > 0:
 
525
                task_part = task_part[:-gap-2] + '..'
 
526
        s = trans + bar_string + task_part + counter_part
 
527
        if avail_width is not None:
 
528
            if len(s) < avail_width:
 
529
                s = s.ljust(avail_width)
 
530
            elif len(s) > avail_width:
 
531
                s = s[:avail_width]
 
532
        return s
308
533
 
309
534
    def _repaint(self):
310
535
        s = self._render_line()
334
559
        This may update a progress bar, spinner, or similar display.
335
560
        By default it does nothing.
336
561
        """
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
 
562
        # XXX: there should be a transport activity model, and that too should
 
563
        #      be seen by the progress view, rather than being poked in here.
348
564
        self._total_byte_count += byte_count
349
565
        self._bytes_since_update += byte_count
 
566
        if self._first_byte_time is None:
 
567
            # Note that this isn't great, as technically it should be the time
 
568
            # when the bytes started transferring, not when they completed.
 
569
            # However, we usually start with a small request anyway.
 
570
            self._first_byte_time = time.time()
 
571
        if direction in self._bytes_by_direction:
 
572
            self._bytes_by_direction[direction] += byte_count
 
573
        else:
 
574
            self._bytes_by_direction['unknown'] += byte_count
 
575
        if 'no_activity' in debug.debug_flags:
 
576
            # Can be used as a workaround if
 
577
            # <https://launchpad.net/bugs/321935> reappears and transport
 
578
            # activity is cluttering other output.  However, thanks to
 
579
            # TextUIOutputStream this shouldn't be a problem any more.
 
580
            return
350
581
        now = time.time()
351
582
        if self._total_byte_count < 2000:
352
583
            # a little resistance at first, so it doesn't stay stuck at 0
357
588
        elif now >= (self._transport_update_time + 0.5):
358
589
            # guard against clock stepping backwards, and don't update too
359
590
            # 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,))
 
591
            rate = (self._bytes_since_update
 
592
                    / (now - self._transport_update_time))
 
593
            # using base-10 units (see HACKING.txt).
 
594
            msg = ("%6dkB %5dkB/s " %
 
595
                    (self._total_byte_count / 1000, int(rate) / 1000,))
363
596
            self._transport_update_time = now
364
597
            self._last_repaint = now
365
598
            self._bytes_since_update = 0
366
599
            self._last_transport_msg = msg
367
600
            self._repaint()
 
601
 
 
602
    def _format_bytes_by_direction(self):
 
603
        if self._first_byte_time is None:
 
604
            bps = 0.0
 
605
        else:
 
606
            transfer_time = time.time() - self._first_byte_time
 
607
            if transfer_time < 0.001:
 
608
                transfer_time = 0.001
 
609
            bps = self._total_byte_count / transfer_time
 
610
 
 
611
        # using base-10 units (see HACKING.txt).
 
612
        msg = ('Transferred: %.0fkB'
 
613
               ' (%.1fkB/s r:%.0fkB w:%.0fkB'
 
614
               % (self._total_byte_count / 1000.,
 
615
                  bps / 1000.,
 
616
                  self._bytes_by_direction['read'] / 1000.,
 
617
                  self._bytes_by_direction['write'] / 1000.,
 
618
                 ))
 
619
        if self._bytes_by_direction['unknown'] > 0:
 
620
            msg += ' u:%.0fkB)' % (
 
621
                self._bytes_by_direction['unknown'] / 1000.
 
622
                )
 
623
        else:
 
624
            msg += ')'
 
625
        return msg
 
626
 
 
627
    def log_transport_activity(self, display=False):
 
628
        msg = self._format_bytes_by_direction()
 
629
        trace.mutter(msg)
 
630
        if display and self._total_byte_count > 0:
 
631
            self.clear()
 
632
            self._term_file.write(msg + '\n')
 
633
 
 
634
 
 
635
class TextUIOutputStream(object):
 
636
    """Decorates an output stream so that the terminal is cleared before writing.
 
637
 
 
638
    This is supposed to ensure that the progress bar does not conflict with bulk
 
639
    text output.
 
640
    """
 
641
    # XXX: this does not handle the case of writing part of a line, then doing
 
642
    # progress bar output: the progress bar will probably write over it.
 
643
    # one option is just to buffer that text until we have a full line;
 
644
    # another is to save and restore it
 
645
 
 
646
    # XXX: might need to wrap more methods
 
647
 
 
648
    def __init__(self, ui_factory, wrapped_stream):
 
649
        self.ui_factory = ui_factory
 
650
        self.wrapped_stream = wrapped_stream
 
651
        # this does no transcoding, but it must expose the underlying encoding
 
652
        # because some callers need to know what can be written - see for
 
653
        # example unescape_for_display.
 
654
        self.encoding = getattr(wrapped_stream, 'encoding', None)
 
655
 
 
656
    def flush(self):
 
657
        self.ui_factory.clear_term()
 
658
        self.wrapped_stream.flush()
 
659
 
 
660
    def write(self, to_write):
 
661
        self.ui_factory.clear_term()
 
662
        self.wrapped_stream.write(to_write)
 
663
 
 
664
    def writelines(self, lines):
 
665
        self.ui_factory.clear_term()
 
666
        self.wrapped_stream.writelines(lines)