← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/ui/text.py

  • Committer: John Arbash Meinel
  • Date: 2009-06-02 19:56:24 UTC
  • mto: This revision was merged to the branch mainline in revision 4469.
  • Revision ID: john@arbash-meinel.com-20090602195624-utljsyz0qgmq63lg
Add a chunks_to_gzip function.
This allows the _record_to_data code to build up a list of chunks,
rather than requiring a single string.
It should be ~ the same performance when using a single string, since
we are only adding a for() loop over the chunks and an if check.
We could possibly just remove the if check and not worry about adding
some empty strings in there.

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
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
 
 
18
 
18
19
"""Text UI, write output to the console.
19
20
"""
20
21
 
21
 
import os
22
22
import sys
23
23
import time
 
24
import warnings
24
25
 
25
26
from bzrlib.lazy_import import lazy_import
26
27
lazy_import(globals(), """
27
 
import codecs
28
 
import getpass
29
 
import warnings
30
 
 
31
28
from bzrlib import (
32
 
    debug,
33
29
    progress,
34
30
    osutils,
35
 
    trace,
 
31
    symbol_versioning,
36
32
    )
37
33
 
38
34
""")
39
35
 
40
 
from bzrlib.ui import (
41
 
    UIFactory,
42
 
    NullProgressView,
43
 
    )
44
 
 
45
 
 
46
 
class TextUIFactory(UIFactory):
 
36
from bzrlib.ui import CLIUIFactory
 
37
 
 
38
 
 
39
class TextUIFactory(CLIUIFactory):
47
40
    """A UI factory for Text user interefaces."""
48
41
 
49
42
    def __init__(self,
 
43
                 bar_type=None,
50
44
                 stdin=None,
51
45
                 stdout=None,
52
46
                 stderr=None):
53
47
        """Create a TextUIFactory.
 
48
 
 
49
        :param bar_type: The type of progress bar to create. It defaults to
 
50
                         letting the bzrlib.progress.ProgressBar factory auto
 
51
                         select.   Deprecated.
54
52
        """
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
 
53
        super(TextUIFactory, self).__init__(stdin=stdin,
 
54
                stdout=stdout, stderr=stderr)
 
55
        if bar_type:
 
56
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 11, 0))
 
57
                % "bar_type parameter")
61
58
        # paints progress, network activity, etc
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()
 
59
        self._progress_view = TextProgressView(self.stderr)
69
60
 
70
61
    def clear_term(self):
71
62
        """Prepare the terminal for output.
78
69
        # to clear it.  We might need to separately check for the case of
79
70
        self._progress_view.clear()
80
71
 
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=u'', **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
 
 
190
72
    def note(self, msg):
191
73
        """Write an already-formatted message, clearing the progress bar if necessary."""
192
74
        self.clear_term()
193
75
        self.stdout.write(msg + '\n')
194
76
 
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 type(prompt) != unicode:
202
 
            raise ValueError("prompt %r not a unicode string" % prompt)
203
 
        if kwargs:
204
 
            # See <https://launchpad.net/bugs/365891>
205
 
            prompt = prompt % kwargs
206
 
        prompt = prompt.encode(osutils.get_terminal_encoding(), 'replace')
207
 
        self.clear_term()
208
 
        self.stderr.write(prompt)
209
 
 
210
77
    def report_transport_activity(self, transport, byte_count, direction):
211
78
        """Called by transports as they do IO.
212
79
 
213
80
        This may update a progress bar, spinner, or similar display.
214
81
        By default it does nothing.
215
82
        """
216
 
        self._progress_view.show_transport_activity(transport,
 
83
        self._progress_view._show_transport_activity(transport,
217
84
            direction, byte_count)
218
85
 
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
86
    def _progress_updated(self, task):
240
87
        """A task has been updated and wants to be displayed.
241
88
        """
243
90
            warnings.warn("%r updated but no tasks are active" %
244
91
                (task,))
245
92
        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
 
93
            warnings.warn("%r is not the top progress task %r" %
 
94
                (task, self._task_stack[-1]))
252
95
        self._progress_view.show_progress(task)
253
96
 
254
97
    def _progress_all_finished(self):
255
98
        self._progress_view.clear()
256
99
 
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
100
 
270
101
class TextProgressView(object):
271
102
    """Display of progress bar and other information on a tty.
286
117
        self._term_file = term_file
287
118
        # true when there's output on the screen we may need to clear
288
119
        self._have_output = False
 
120
        # XXX: We could listen for SIGWINCH and update the terminal width...
 
121
        self._width = osutils.terminal_width()
289
122
        self._last_transport_msg = ''
290
123
        self._spin_pos = 0
291
124
        # time we last repainted the screen
295
128
        self._last_task = None
296
129
        self._total_byte_count = 0
297
130
        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
131
 
313
132
    def _show_line(self, s):
314
 
        # 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')
 
133
        n = self._width - 1
 
134
        self._term_file.write('\r%-*.*s\r' % (n, n, s))
319
135
 
320
136
    def clear(self):
321
137
        if self._have_output:
324
140
 
325
141
    def _render_bar(self):
326
142
        # 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):
 
143
        if (self._last_task is None) or self._last_task.show_bar:
329
144
            # If there's no task object, we show space for the bar anyhow.
330
145
            # That's because most invocations of bzr will end showing progress
331
146
            # at some point, though perhaps only after doing some initial IO.
336
151
            cols = 20
337
152
            if self._last_task is None:
338
153
                completion_fraction = 0
339
 
                self._fraction = 0
340
154
            else:
341
155
                completion_fraction = \
342
156
                    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
157
            markers = int(round(float(cols) * completion_fraction)) - 1
348
158
            bar_str = '[' + ('#' * markers + spin_str).ljust(cols) + '] '
349
159
            return bar_str
350
 
        elif (self._last_task is None) or self._last_task.show_spinner:
 
160
        elif self._last_task.show_spinner:
351
161
            # The last task wanted just a spinner, no bar
352
162
            spin_str =  r'/-\|'[self._spin_pos % 4]
353
163
            self._spin_pos += 1
356
166
            return ''
357
167
 
358
168
    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
169
        if not task.show_count:
364
170
            s = ''
365
171
        elif task.current_cnt is not None and task.total_cnt is not None:
375
181
            t = t._parent_task
376
182
            if t.msg:
377
183
                m = t.msg + ':' + m
378
 
        return m, s
 
184
        return m + s
379
185
 
380
186
    def _render_line(self):
381
187
        bar_string = self._render_bar()
382
188
        if self._last_task:
383
 
            task_part, counter_part = self._format_task(self._last_task)
384
 
        else:
385
 
            task_part = counter_part = ''
386
 
        if self._last_task and not self._last_task.show_transport_activity:
387
 
            trans = ''
388
 
        else:
389
 
            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
 
189
            task_msg = self._format_task(self._last_task)
 
190
        else:
 
191
            task_msg = ''
 
192
        trans = self._last_transport_msg
 
193
        if trans:
 
194
            trans += ' | '
 
195
        return (bar_string + trans + task_msg)
411
196
 
412
197
    def _repaint(self):
413
198
        s = self._render_line()
423
208
        must_update = task is not self._last_task
424
209
        self._last_task = task
425
210
        now = time.time()
426
 
        if (not must_update) and (now < self._last_repaint + task.update_latency):
 
211
        if (not must_update) and (now < self._last_repaint + 0.1):
427
212
            return
428
213
        if now > self._transport_update_time + 10:
429
214
            # no recent activity; expire it
431
216
        self._last_repaint = now
432
217
        self._repaint()
433
218
 
434
 
    def show_transport_activity(self, transport, direction, byte_count):
 
219
    def _show_transport_activity(self, transport, direction, byte_count):
435
220
        """Called by transports via the ui_factory, as they do IO.
436
221
 
437
222
        This may update a progress bar, spinner, or similar display.
438
223
        By default it does nothing.
439
224
        """
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.
 
225
        # XXX: Probably there should be a transport activity model, and that
 
226
        # too should be seen by the progress view, rather than being poked in
 
227
        # here.
442
228
        self._total_byte_count += byte_count
443
229
        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
230
        now = time.time()
460
 
        if self._total_byte_count < 2000:
461
 
            # a little resistance at first, so it doesn't stay stuck at 0
462
 
            # while connecting...
463
 
            return
464
231
        if self._transport_update_time is None:
465
232
            self._transport_update_time = now
466
233
        elif now >= (self._transport_update_time + 0.5):
467
234
            # guard against clock stepping backwards, and don't update too
468
235
            # 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,))
 
236
            rate = self._bytes_since_update / (now - self._transport_update_time)
 
237
            scheme = getattr(transport, '_scheme', None) or repr(transport)
 
238
            if direction == 'read':
 
239
                dir_char = '>'
 
240
            elif direction == 'write':
 
241
                dir_char = '<'
 
242
            else:
 
243
                dir_char = ' '
 
244
            msg = ("%.7s %s %6dKB %5dKB/s" %
 
245
                    (scheme, dir_char, self._total_byte_count>>10, int(rate)>>10,))
474
246
            self._transport_update_time = now
475
247
            self._last_repaint = now
476
248
            self._bytes_since_update = 0
477
249
            self._last_transport_msg = msg
478
250
            self._repaint()
479
251
 
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)
 
252