← 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-06-25 06:47:40 UTC
  • mto: (5050.3.16 2.2)
  • mto: This revision was merged to the branch mainline in revision 5365.
  • Revision ID: andrew.bennetts@canonical.com-20100625064740-k93ngat248kdcqdm
Remove merge_into_helper for now, as it currently has no callers.

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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
 
 
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
16
 
18
17
 
19
18
"""Text UI, write output to the console.
20
19
"""
21
20
 
 
21
import codecs
 
22
import getpass
 
23
import os
22
24
import sys
23
25
import time
24
26
import warnings
25
27
 
26
28
from bzrlib.lazy_import import lazy_import
27
29
lazy_import(globals(), """
28
 
import getpass
29
 
 
30
30
from bzrlib import (
 
31
    debug,
31
32
    progress,
32
33
    osutils,
33
34
    symbol_versioning,
 
35
    trace,
34
36
    )
35
37
 
36
38
""")
37
39
 
38
 
from bzrlib.ui import CLIUIFactory
39
 
 
40
 
 
41
 
class TextUIFactory(CLIUIFactory):
 
40
from bzrlib.ui import (
 
41
    UIFactory,
 
42
    NullProgressView,
 
43
    )
 
44
 
 
45
 
 
46
class TextUIFactory(UIFactory):
42
47
    """A UI factory for Text user interefaces."""
43
48
 
44
49
    def __init__(self,
45
 
                 bar_type=None,
46
50
                 stdin=None,
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
 
        super(TextUIFactory, self).__init__(stdin=stdin,
56
 
                stdout=stdout, stderr=stderr)
57
 
        if bar_type:
58
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 11, 0))
59
 
                % "bar_type parameter")
 
55
        super(TextUIFactory, self).__init__()
 
56
        # TODO: there's no good reason not to pass all three streams, maybe we
 
57
        # should deprecate the default values...
 
58
        self.stdin = stdin
 
59
        self.stdout = stdout
 
60
        self.stderr = stderr
60
61
        # paints progress, network activity, etc
61
 
        self._progress_view = TextProgressView(self.stderr)
62
 
 
63
 
    def prompt(self, prompt):
64
 
        """Emit prompt on the CLI."""
65
 
        self.stdout.write(prompt)
66
 
        
 
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
 
67
70
    def clear_term(self):
68
71
        """Prepare the terminal for output.
69
72
 
72
75
        # XXX: If this is preparing to write to stdout, but that's for example
73
76
        # directed into a file rather than to the terminal, and the progress
74
77
        # bar _is_ going to the terminal, we shouldn't need
75
 
        # to clear it.  We might need to separately check for the case of 
 
78
        # to clear it.  We might need to separately check for the case of
76
79
        self._progress_view.clear()
77
80
 
 
81
    def get_boolean(self, prompt):
 
82
        while True:
 
83
            self.prompt(prompt + "? [y/n]: ")
 
84
            line = self.stdin.readline().lower()
 
85
            if line in ('y\n', 'yes\n'):
 
86
                return True
 
87
            elif line in ('n\n', 'no\n'):
 
88
                return False
 
89
            elif line in ('', None):
 
90
                # end-of-file; possibly should raise an error here instead
 
91
                return None
 
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
 
 
102
    def get_non_echoed_password(self):
 
103
        isatty = getattr(self.stdin, 'isatty', None)
 
104
        if isatty is not None and isatty():
 
105
            # getpass() ensure the password is not echoed and other
 
106
            # cross-platform niceties
 
107
            password = getpass.getpass('')
 
108
        else:
 
109
            # echo doesn't make sense without a terminal
 
110
            password = self.stdin.readline()
 
111
            if not password:
 
112
                password = None
 
113
            elif password[-1] == '\n':
 
114
                password = password[:-1]
 
115
        return password
 
116
 
 
117
    def get_password(self, prompt='', **kwargs):
 
118
        """Prompt the user for a password.
 
119
 
 
120
        :param prompt: The prompt to present the user
 
121
        :param kwargs: Arguments which will be expanded into the prompt.
 
122
                       This lets front ends display different things if
 
123
                       they so choose.
 
124
        :return: The password string, return None if the user
 
125
                 canceled the request.
 
126
        """
 
127
        prompt += ': '
 
128
        self.prompt(prompt, **kwargs)
 
129
        # There's currently no way to say 'i decline to enter a password'
 
130
        # as opposed to 'my password is empty' -- does it matter?
 
131
        return self.get_non_echoed_password()
 
132
 
 
133
    def get_username(self, prompt, **kwargs):
 
134
        """Prompt the user for a username.
 
135
 
 
136
        :param prompt: The prompt to present the user
 
137
        :param kwargs: Arguments which will be expanded into the prompt.
 
138
                       This lets front ends display different things if
 
139
                       they so choose.
 
140
        :return: The username string, return None if the user
 
141
                 canceled the request.
 
142
        """
 
143
        prompt += ': '
 
144
        self.prompt(prompt, **kwargs)
 
145
        username = self.stdin.readline()
 
146
        if not username:
 
147
            username = None
 
148
        elif username[-1] == '\n':
 
149
            username = username[:-1]
 
150
        return username
 
151
 
 
152
    def make_progress_view(self):
 
153
        """Construct and return a new ProgressView subclass for this UI.
 
154
        """
 
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':
 
162
            return TextProgressView(self.stderr)
 
163
        elif os.environ.get('BZR_PROGRESS_BAR') == 'none':
 
164
            return NullProgressView()
 
165
        elif progress._supports_progress(self.stderr):
 
166
            return TextProgressView(self.stderr)
 
167
        else:
 
168
            return NullProgressView()
 
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
 
78
190
    def note(self, msg):
79
191
        """Write an already-formatted message, clearing the progress bar if necessary."""
80
192
        self.clear_term()
81
193
        self.stdout.write(msg + '\n')
82
194
 
 
195
    def prompt(self, prompt, **kwargs):
 
196
        """Emit prompt on the CLI.
 
197
        
 
198
        :param kwargs: Dictionary of arguments to insert into the prompt,
 
199
            to allow UIs to reformat the prompt.
 
200
        """
 
201
        if kwargs:
 
202
            # See <https://launchpad.net/bugs/365891>
 
203
            prompt = prompt % kwargs
 
204
        prompt = prompt.encode(osutils.get_terminal_encoding(), 'replace')
 
205
        self.clear_term()
 
206
        self.stderr.write(prompt)
 
207
 
83
208
    def report_transport_activity(self, transport, byte_count, direction):
84
209
        """Called by transports as they do IO.
85
 
        
 
210
 
86
211
        This may update a progress bar, spinner, or similar display.
87
212
        By default it does nothing.
88
213
        """
89
 
        self._progress_view.show_transport_activity(byte_count)
 
214
        self._progress_view.show_transport_activity(transport,
 
215
            direction, byte_count)
 
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)
90
236
 
91
237
    def _progress_updated(self, task):
92
238
        """A task has been updated and wants to be displayed.
93
239
        """
94
 
        if task != self._task_stack[-1]:
95
 
            warnings.warn("%r is not the top progress task %r" %
96
 
                (task, self._task_stack[-1]))
 
240
        if not self._task_stack:
 
241
            warnings.warn("%r updated but no tasks are active" %
 
242
                (task,))
 
243
        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
97
250
        self._progress_view.show_progress(task)
98
251
 
99
252
    def _progress_all_finished(self):
100
253
        self._progress_view.clear()
101
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
 
102
267
 
103
268
class TextProgressView(object):
104
269
    """Display of progress bar and other information on a tty.
105
 
    
106
 
    This shows one line of text, including possibly a network indicator, spinner, 
 
270
 
 
271
    This shows one line of text, including possibly a network indicator, spinner,
107
272
    progress bar, message, etc.
108
273
 
109
274
    One instance of this is created and held by the UI, and fed updates when a
119
284
        self._term_file = term_file
120
285
        # true when there's output on the screen we may need to clear
121
286
        self._have_output = False
122
 
        # XXX: We could listen for SIGWINCH and update the terminal width...
123
 
        self._width = osutils.terminal_width()
124
287
        self._last_transport_msg = ''
125
288
        self._spin_pos = 0
126
289
        # time we last repainted the screen
127
290
        self._last_repaint = 0
128
291
        # time we last got information about transport activity
129
292
        self._transport_update_time = 0
130
 
        self._task_fraction = None
131
293
        self._last_task = None
132
294
        self._total_byte_count = 0
133
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
134
302
 
135
303
    def _show_line(self, s):
136
 
        n = self._width - 1
137
 
        self._term_file.write('\r%-*.*s\r' % (n, n, s))
 
304
        # 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')
138
311
 
139
312
    def clear(self):
140
313
        if self._have_output:
143
316
 
144
317
    def _render_bar(self):
145
318
        # return a string for the progress bar itself
146
 
        if (self._last_task is not None) and self._last_task.show_bar:
 
319
        if self.enable_bar and (
 
320
            (self._last_task is None) or self._last_task.show_bar):
 
321
            # If there's no task object, we show space for the bar anyhow.
 
322
            # That's because most invocations of bzr will end showing progress
 
323
            # at some point, though perhaps only after doing some initial IO.
 
324
            # It looks better to draw the progress bar initially rather than
 
325
            # to have what looks like an incomplete progress bar.
147
326
            spin_str =  r'/-\|'[self._spin_pos % 4]
148
327
            self._spin_pos += 1
149
 
            f = self._task_fraction or 0
150
328
            cols = 20
151
 
            # number of markers highlighted in bar
152
 
            markers = int(round(float(cols) * f)) - 1
 
329
            if self._last_task is None:
 
330
                completion_fraction = 0
 
331
                self._fraction = 0
 
332
            else:
 
333
                completion_fraction = \
 
334
                    self._last_task._overall_completion_fraction() or 0
 
335
            if (completion_fraction < self._fraction and 'progress' in
 
336
                debug.debug_flags):
 
337
                import pdb;pdb.set_trace()
 
338
            self._fraction = completion_fraction
 
339
            markers = int(round(float(cols) * completion_fraction)) - 1
153
340
            bar_str = '[' + ('#' * markers + spin_str).ljust(cols) + '] '
154
341
            return bar_str
155
342
        elif (self._last_task is None) or self._last_task.show_spinner:
 
343
            # The last task wanted just a spinner, no bar
156
344
            spin_str =  r'/-\|'[self._spin_pos % 4]
157
345
            self._spin_pos += 1
158
346
            return spin_str + ' '
162
350
    def _format_task(self, task):
163
351
        if not task.show_count:
164
352
            s = ''
165
 
        elif task.total_cnt is not None:
 
353
        elif task.current_cnt is not None and task.total_cnt is not None:
166
354
            s = ' %d/%d' % (task.current_cnt, task.total_cnt)
167
355
        elif task.current_cnt is not None:
168
356
            s = ' %d' % (task.current_cnt)
169
357
        else:
170
358
            s = ''
171
 
        self._task_fraction = task._overall_completion_fraction()
172
359
        # compose all the parent messages
173
360
        t = task
174
361
        m = task.msg
178
365
                m = t.msg + ':' + m
179
366
        return m + s
180
367
 
181
 
    def _repaint(self):
 
368
    def _render_line(self):
182
369
        bar_string = self._render_bar()
183
370
        if self._last_task:
184
371
            task_msg = self._format_task(self._last_task)
185
372
        else:
186
373
            task_msg = ''
187
 
        trans = self._last_transport_msg
188
 
        if trans and task_msg:
189
 
            trans += ' | '
190
 
        s = (bar_string
191
 
             + trans
192
 
             + task_msg
193
 
             )
 
374
        if self._last_task and not self._last_task.show_transport_activity:
 
375
            trans = ''
 
376
        else:
 
377
            trans = self._last_transport_msg
 
378
            if trans:
 
379
                trans += ' | '
 
380
        return (bar_string + trans + task_msg)
 
381
 
 
382
    def _repaint(self):
 
383
        s = self._render_line()
194
384
        self._show_line(s)
195
385
        self._have_output = True
196
386
 
197
387
    def show_progress(self, task):
 
388
        """Called by the task object when it has changed.
 
389
        
 
390
        :param task: The top task object; its parents are also included 
 
391
            by following links.
 
392
        """
 
393
        must_update = task is not self._last_task
198
394
        self._last_task = task
199
395
        now = time.time()
200
 
        if now < self._last_repaint + 0.1:
 
396
        if (not must_update) and (now < self._last_repaint + task.update_latency):
201
397
            return
202
 
        if now > self._transport_update_time + 5:
 
398
        if now > self._transport_update_time + 10:
203
399
            # no recent activity; expire it
204
400
            self._last_transport_msg = ''
205
401
        self._last_repaint = now
206
402
        self._repaint()
207
403
 
208
 
    def show_transport_activity(self, byte_count):
209
 
        """Called by transports as they do IO.
210
 
        
 
404
    def show_transport_activity(self, transport, direction, byte_count):
 
405
        """Called by transports via the ui_factory, as they do IO.
 
406
 
211
407
        This may update a progress bar, spinner, or similar display.
212
408
        By default it does nothing.
213
409
        """
214
 
        # XXX: Probably there should be a transport activity model, and that
215
 
        # too should be seen by the progress view, rather than being poked in
216
 
        # here.
 
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.
217
412
        self._total_byte_count += byte_count
218
413
        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
219
429
        now = time.time()
 
430
        if self._total_byte_count < 2000:
 
431
            # a little resistance at first, so it doesn't stay stuck at 0
 
432
            # while connecting...
 
433
            return
220
434
        if self._transport_update_time is None:
221
435
            self._transport_update_time = now
222
 
        elif now >= (self._transport_update_time + 0.2):
 
436
        elif now >= (self._transport_update_time + 0.5):
223
437
            # guard against clock stepping backwards, and don't update too
224
438
            # often
225
 
            rate = self._bytes_since_update / (now - self._transport_update_time)
226
 
            msg = ("%6dkB @ %4dkB/s" %
227
 
                (self._total_byte_count>>10, int(rate)>>10,))
 
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,))
228
444
            self._transport_update_time = now
229
445
            self._last_repaint = now
230
446
            self._bytes_since_update = 0
231
447
            self._last_transport_msg = msg
232
448
            self._repaint()
233
449
 
234
 
 
 
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)