/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/ui/text.py

  • Committer: John Arbash Meinel
  • Date: 2010-02-17 17:11:16 UTC
  • mfrom: (4797.2.17 2.1)
  • mto: (4797.2.18 2.1)
  • mto: This revision was merged to the branch mainline in revision 5055.
  • Revision ID: john@arbash-meinel.com-20100217171116-h7t9223ystbnx5h8
merge bzr.2.1 in preparation for NEWS entry.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/ui/text.py
 
1
# Copyright (C) 2005-2010 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
 
 
18
"""Text UI, write output to the console.
 
19
"""
 
20
 
 
21
import codecs
 
22
import getpass
 
23
import os
 
24
import sys
 
25
import time
 
26
import warnings
 
27
 
 
28
from bzrlib.lazy_import import lazy_import
 
29
lazy_import(globals(), """
 
30
from bzrlib import (
 
31
    debug,
 
32
    progress,
 
33
    osutils,
 
34
    symbol_versioning,
 
35
    trace,
 
36
    )
 
37
 
 
38
""")
 
39
 
 
40
from bzrlib.osutils import watch_sigwinch
 
41
 
 
42
from bzrlib.ui import (
 
43
    UIFactory,
 
44
    NullProgressView,
 
45
    )
 
46
 
 
47
 
 
48
class TextUIFactory(UIFactory):
 
49
    """A UI factory for Text user interefaces."""
 
50
 
 
51
    def __init__(self,
 
52
                 stdin=None,
 
53
                 stdout=None,
 
54
                 stderr=None):
 
55
        """Create a TextUIFactory.
 
56
        """
 
57
        super(TextUIFactory, self).__init__()
 
58
        # TODO: there's no good reason not to pass all three streams, maybe we
 
59
        # should deprecate the default values...
 
60
        self.stdin = stdin
 
61
        self.stdout = stdout
 
62
        self.stderr = stderr
 
63
        # paints progress, network activity, etc
 
64
        self._progress_view = self.make_progress_view()
 
65
        # hook up the signals to watch for terminal size changes
 
66
        watch_sigwinch()
 
67
 
 
68
    def be_quiet(self, state):
 
69
        if state and not self._quiet:
 
70
            self.clear_term()
 
71
        UIFactory.be_quiet(self, state)
 
72
        self._progress_view = self.make_progress_view()
 
73
 
 
74
    def clear_term(self):
 
75
        """Prepare the terminal for output.
 
76
 
 
77
        This will, clear any progress bars, and leave the cursor at the
 
78
        leftmost position."""
 
79
        # XXX: If this is preparing to write to stdout, but that's for example
 
80
        # directed into a file rather than to the terminal, and the progress
 
81
        # bar _is_ going to the terminal, we shouldn't need
 
82
        # to clear it.  We might need to separately check for the case of
 
83
        self._progress_view.clear()
 
84
 
 
85
    def get_boolean(self, prompt):
 
86
        while True:
 
87
            self.prompt(prompt + "? [y/n]: ")
 
88
            line = self.stdin.readline().lower()
 
89
            if line in ('y\n', 'yes\n'):
 
90
                return True
 
91
            elif line in ('n\n', 'no\n'):
 
92
                return False
 
93
            elif line in ('', None):
 
94
                # end-of-file; possibly should raise an error here instead
 
95
                return None
 
96
 
 
97
    def get_integer(self, prompt):
 
98
        while True:
 
99
            self.prompt(prompt)
 
100
            line = self.stdin.readline()
 
101
            try:
 
102
                return int(line)
 
103
            except ValueError:
 
104
                pass
 
105
 
 
106
    def get_non_echoed_password(self):
 
107
        isatty = getattr(self.stdin, 'isatty', None)
 
108
        if isatty is not None and isatty():
 
109
            # getpass() ensure the password is not echoed and other
 
110
            # cross-platform niceties
 
111
            password = getpass.getpass('')
 
112
        else:
 
113
            # echo doesn't make sense without a terminal
 
114
            password = self.stdin.readline()
 
115
            if not password:
 
116
                password = None
 
117
            elif password[-1] == '\n':
 
118
                password = password[:-1]
 
119
        return password
 
120
 
 
121
    def get_password(self, prompt='', **kwargs):
 
122
        """Prompt the user for a password.
 
123
 
 
124
        :param prompt: The prompt to present the user
 
125
        :param kwargs: Arguments which will be expanded into the prompt.
 
126
                       This lets front ends display different things if
 
127
                       they so choose.
 
128
        :return: The password string, return None if the user
 
129
                 canceled the request.
 
130
        """
 
131
        prompt += ': '
 
132
        self.prompt(prompt, **kwargs)
 
133
        # There's currently no way to say 'i decline to enter a password'
 
134
        # as opposed to 'my password is empty' -- does it matter?
 
135
        return self.get_non_echoed_password()
 
136
 
 
137
    def get_username(self, prompt, **kwargs):
 
138
        """Prompt the user for a username.
 
139
 
 
140
        :param prompt: The prompt to present the user
 
141
        :param kwargs: Arguments which will be expanded into the prompt.
 
142
                       This lets front ends display different things if
 
143
                       they so choose.
 
144
        :return: The username string, return None if the user
 
145
                 canceled the request.
 
146
        """
 
147
        prompt += ': '
 
148
        self.prompt(prompt, **kwargs)
 
149
        username = self.stdin.readline()
 
150
        if not username:
 
151
            username = None
 
152
        elif username[-1] == '\n':
 
153
            username = username[:-1]
 
154
        return username
 
155
 
 
156
    def make_progress_view(self):
 
157
        """Construct and return a new ProgressView subclass for this UI.
 
158
        """
 
159
        # with --quiet, never any progress view
 
160
        # <https://bugs.edge.launchpad.net/bzr/+bug/320035>.  Otherwise if the
 
161
        # user specifically requests either text or no progress bars, always
 
162
        # do that.  otherwise, guess based on $TERM and tty presence.
 
163
        if self.is_quiet():
 
164
            return NullProgressView()
 
165
        elif os.environ.get('BZR_PROGRESS_BAR') == 'text':
 
166
            return TextProgressView(self.stderr)
 
167
        elif os.environ.get('BZR_PROGRESS_BAR') == 'none':
 
168
            return NullProgressView()
 
169
        elif progress._supports_progress(self.stderr):
 
170
            return TextProgressView(self.stderr)
 
171
        else:
 
172
            return NullProgressView()
 
173
 
 
174
    def _make_output_stream_explicit(self, encoding, encoding_type):
 
175
        if encoding_type == 'exact':
 
176
            # force sys.stdout to be binary stream on win32; 
 
177
            # NB: this leaves the file set in that mode; may cause problems if
 
178
            # one process tries to do binary and then text output
 
179
            if sys.platform == 'win32':
 
180
                fileno = getattr(self.stdout, 'fileno', None)
 
181
                if fileno:
 
182
                    import msvcrt
 
183
                    msvcrt.setmode(fileno(), os.O_BINARY)
 
184
            return TextUIOutputStream(self, self.stdout)
 
185
        else:
 
186
            encoded_stdout = codecs.getwriter(encoding)(self.stdout,
 
187
                errors=encoding_type)
 
188
            # For whatever reason codecs.getwriter() does not advertise its encoding
 
189
            # it just returns the encoding of the wrapped file, which is completely
 
190
            # bogus. So set the attribute, so we can find the correct encoding later.
 
191
            encoded_stdout.encoding = encoding
 
192
            return TextUIOutputStream(self, encoded_stdout)
 
193
 
 
194
    def note(self, msg):
 
195
        """Write an already-formatted message, clearing the progress bar if necessary."""
 
196
        self.clear_term()
 
197
        self.stdout.write(msg + '\n')
 
198
 
 
199
    def prompt(self, prompt, **kwargs):
 
200
        """Emit prompt on the CLI.
 
201
        
 
202
        :param kwargs: Dictionary of arguments to insert into the prompt,
 
203
            to allow UIs to reformat the prompt.
 
204
        """
 
205
        if kwargs:
 
206
            # See <https://launchpad.net/bugs/365891>
 
207
            prompt = prompt % kwargs
 
208
        prompt = prompt.encode(osutils.get_terminal_encoding(), 'replace')
 
209
        self.clear_term()
 
210
        self.stderr.write(prompt)
 
211
 
 
212
    def report_transport_activity(self, transport, byte_count, direction):
 
213
        """Called by transports as they do IO.
 
214
 
 
215
        This may update a progress bar, spinner, or similar display.
 
216
        By default it does nothing.
 
217
        """
 
218
        self._progress_view.show_transport_activity(transport,
 
219
            direction, byte_count)
 
220
 
 
221
    def log_transport_activity(self, display=False):
 
222
        """See UIFactory.log_transport_activity()"""
 
223
        log = getattr(self._progress_view, 'log_transport_activity', None)
 
224
        if log is not None:
 
225
            log(display=display)
 
226
 
 
227
    def show_error(self, msg):
 
228
        self.clear_term()
 
229
        self.stderr.write("bzr: error: %s\n" % msg)
 
230
 
 
231
    def show_message(self, msg):
 
232
        self.note(msg)
 
233
 
 
234
    def show_warning(self, msg):
 
235
        self.clear_term()
 
236
        self.stderr.write("bzr: warning: %s\n" % msg)
 
237
 
 
238
    def _progress_updated(self, task):
 
239
        """A task has been updated and wants to be displayed.
 
240
        """
 
241
        if not self._task_stack:
 
242
            warnings.warn("%r updated but no tasks are active" %
 
243
                (task,))
 
244
        elif task != self._task_stack[-1]:
 
245
            warnings.warn("%r is not the top progress task %r" %
 
246
                (task, self._task_stack[-1]))
 
247
        self._progress_view.show_progress(task)
 
248
 
 
249
    def _progress_all_finished(self):
 
250
        self._progress_view.clear()
 
251
 
 
252
 
 
253
class TextProgressView(object):
 
254
    """Display of progress bar and other information on a tty.
 
255
 
 
256
    This shows one line of text, including possibly a network indicator, spinner,
 
257
    progress bar, message, etc.
 
258
 
 
259
    One instance of this is created and held by the UI, and fed updates when a
 
260
    task wants to be painted.
 
261
 
 
262
    Transports feed data to this through the ui_factory object.
 
263
 
 
264
    The Progress views can comprise a tree with _parent_task pointers, but
 
265
    this only prints the stack from the nominated current task up to the root.
 
266
    """
 
267
 
 
268
    def __init__(self, term_file):
 
269
        self._term_file = term_file
 
270
        # true when there's output on the screen we may need to clear
 
271
        self._have_output = False
 
272
        self._last_transport_msg = ''
 
273
        self._spin_pos = 0
 
274
        # time we last repainted the screen
 
275
        self._last_repaint = 0
 
276
        # time we last got information about transport activity
 
277
        self._transport_update_time = 0
 
278
        self._last_task = None
 
279
        self._total_byte_count = 0
 
280
        self._bytes_since_update = 0
 
281
        self._bytes_by_direction = {'unknown': 0, 'read': 0, 'write': 0}
 
282
        self._first_byte_time = None
 
283
        self._fraction = 0
 
284
        # force the progress bar to be off, as at the moment it doesn't 
 
285
        # correspond reliably to overall command progress
 
286
        self.enable_bar = False
 
287
 
 
288
    def _show_line(self, s):
 
289
        # sys.stderr.write("progress %r\n" % s)
 
290
        width = osutils.terminal_width()
 
291
        if width is not None:
 
292
            # we need one extra space for terminals that wrap on last char
 
293
            width = width - 1
 
294
            s = '%-*.*s' % (width, width, s)
 
295
        self._term_file.write('\r' + s + '\r')
 
296
 
 
297
    def clear(self):
 
298
        if self._have_output:
 
299
            self._show_line('')
 
300
        self._have_output = False
 
301
 
 
302
    def _render_bar(self):
 
303
        # return a string for the progress bar itself
 
304
        if self.enable_bar and (
 
305
            (self._last_task is None) or self._last_task.show_bar):
 
306
            # If there's no task object, we show space for the bar anyhow.
 
307
            # That's because most invocations of bzr will end showing progress
 
308
            # at some point, though perhaps only after doing some initial IO.
 
309
            # It looks better to draw the progress bar initially rather than
 
310
            # to have what looks like an incomplete progress bar.
 
311
            spin_str =  r'/-\|'[self._spin_pos % 4]
 
312
            self._spin_pos += 1
 
313
            cols = 20
 
314
            if self._last_task is None:
 
315
                completion_fraction = 0
 
316
                self._fraction = 0
 
317
            else:
 
318
                completion_fraction = \
 
319
                    self._last_task._overall_completion_fraction() or 0
 
320
            if (completion_fraction < self._fraction and 'progress' in
 
321
                debug.debug_flags):
 
322
                import pdb;pdb.set_trace()
 
323
            self._fraction = completion_fraction
 
324
            markers = int(round(float(cols) * completion_fraction)) - 1
 
325
            bar_str = '[' + ('#' * markers + spin_str).ljust(cols) + '] '
 
326
            return bar_str
 
327
        elif (self._last_task is None) or self._last_task.show_spinner:
 
328
            # The last task wanted just a spinner, no bar
 
329
            spin_str =  r'/-\|'[self._spin_pos % 4]
 
330
            self._spin_pos += 1
 
331
            return spin_str + ' '
 
332
        else:
 
333
            return ''
 
334
 
 
335
    def _format_task(self, task):
 
336
        if not task.show_count:
 
337
            s = ''
 
338
        elif task.current_cnt is not None and task.total_cnt is not None:
 
339
            s = ' %d/%d' % (task.current_cnt, task.total_cnt)
 
340
        elif task.current_cnt is not None:
 
341
            s = ' %d' % (task.current_cnt)
 
342
        else:
 
343
            s = ''
 
344
        # compose all the parent messages
 
345
        t = task
 
346
        m = task.msg
 
347
        while t._parent_task:
 
348
            t = t._parent_task
 
349
            if t.msg:
 
350
                m = t.msg + ':' + m
 
351
        return m + s
 
352
 
 
353
    def _render_line(self):
 
354
        bar_string = self._render_bar()
 
355
        if self._last_task:
 
356
            task_msg = self._format_task(self._last_task)
 
357
        else:
 
358
            task_msg = ''
 
359
        if self._last_task and not self._last_task.show_transport_activity:
 
360
            trans = ''
 
361
        else:
 
362
            trans = self._last_transport_msg
 
363
            if trans:
 
364
                trans += ' | '
 
365
        return (bar_string + trans + task_msg)
 
366
 
 
367
    def _repaint(self):
 
368
        s = self._render_line()
 
369
        self._show_line(s)
 
370
        self._have_output = True
 
371
 
 
372
    def show_progress(self, task):
 
373
        """Called by the task object when it has changed.
 
374
        
 
375
        :param task: The top task object; its parents are also included 
 
376
            by following links.
 
377
        """
 
378
        must_update = task is not self._last_task
 
379
        self._last_task = task
 
380
        now = time.time()
 
381
        if (not must_update) and (now < self._last_repaint + task.update_latency):
 
382
            return
 
383
        if now > self._transport_update_time + 10:
 
384
            # no recent activity; expire it
 
385
            self._last_transport_msg = ''
 
386
        self._last_repaint = now
 
387
        self._repaint()
 
388
 
 
389
    def show_transport_activity(self, transport, direction, byte_count):
 
390
        """Called by transports via the ui_factory, as they do IO.
 
391
 
 
392
        This may update a progress bar, spinner, or similar display.
 
393
        By default it does nothing.
 
394
        """
 
395
        # XXX: there should be a transport activity model, and that too should
 
396
        #      be seen by the progress view, rather than being poked in here.
 
397
        self._total_byte_count += byte_count
 
398
        self._bytes_since_update += byte_count
 
399
        if self._first_byte_time is None:
 
400
            # Note that this isn't great, as technically it should be the time
 
401
            # when the bytes started transferring, not when they completed.
 
402
            # However, we usually start with a small request anyway.
 
403
            self._first_byte_time = time.time()
 
404
        if direction in self._bytes_by_direction:
 
405
            self._bytes_by_direction[direction] += byte_count
 
406
        else:
 
407
            self._bytes_by_direction['unknown'] += byte_count
 
408
        if 'no_activity' in debug.debug_flags:
 
409
            # Can be used as a workaround if
 
410
            # <https://launchpad.net/bugs/321935> reappears and transport
 
411
            # activity is cluttering other output.  However, thanks to
 
412
            # TextUIOutputStream this shouldn't be a problem any more.
 
413
            return
 
414
        now = time.time()
 
415
        if self._total_byte_count < 2000:
 
416
            # a little resistance at first, so it doesn't stay stuck at 0
 
417
            # while connecting...
 
418
            return
 
419
        if self._transport_update_time is None:
 
420
            self._transport_update_time = now
 
421
        elif now >= (self._transport_update_time + 0.5):
 
422
            # guard against clock stepping backwards, and don't update too
 
423
            # often
 
424
            rate = self._bytes_since_update / (now - self._transport_update_time)
 
425
            msg = ("%6dKB %5dKB/s" %
 
426
                    (self._total_byte_count>>10, int(rate)>>10,))
 
427
            self._transport_update_time = now
 
428
            self._last_repaint = now
 
429
            self._bytes_since_update = 0
 
430
            self._last_transport_msg = msg
 
431
            self._repaint()
 
432
 
 
433
    def _format_bytes_by_direction(self):
 
434
        if self._first_byte_time is None:
 
435
            bps = 0.0
 
436
        else:
 
437
            transfer_time = time.time() - self._first_byte_time
 
438
            if transfer_time < 0.001:
 
439
                transfer_time = 0.001
 
440
            bps = self._total_byte_count / transfer_time
 
441
 
 
442
        msg = ('Transferred: %.0fKiB'
 
443
               ' (%.1fK/s r:%.0fK w:%.0fK'
 
444
               % (self._total_byte_count / 1024.,
 
445
                  bps / 1024.,
 
446
                  self._bytes_by_direction['read'] / 1024.,
 
447
                  self._bytes_by_direction['write'] / 1024.,
 
448
                 ))
 
449
        if self._bytes_by_direction['unknown'] > 0:
 
450
            msg += ' u:%.0fK)' % (
 
451
                self._bytes_by_direction['unknown'] / 1024.
 
452
                )
 
453
        else:
 
454
            msg += ')'
 
455
        return msg
 
456
 
 
457
    def log_transport_activity(self, display=False):
 
458
        msg = self._format_bytes_by_direction()
 
459
        trace.mutter(msg)
 
460
        if display and self._total_byte_count > 0:
 
461
            self.clear()
 
462
            self._term_file.write(msg + '\n')
 
463
 
 
464
 
 
465
class TextUIOutputStream(object):
 
466
    """Decorates an output stream so that the terminal is cleared before writing.
 
467
 
 
468
    This is supposed to ensure that the progress bar does not conflict with bulk
 
469
    text output.
 
470
    """
 
471
    # XXX: this does not handle the case of writing part of a line, then doing
 
472
    # progress bar output: the progress bar will probably write over it.
 
473
    # one option is just to buffer that text until we have a full line;
 
474
    # another is to save and restore it
 
475
 
 
476
    # XXX: might need to wrap more methods
 
477
 
 
478
    def __init__(self, ui_factory, wrapped_stream):
 
479
        self.ui_factory = ui_factory
 
480
        self.wrapped_stream = wrapped_stream
 
481
        # this does no transcoding, but it must expose the underlying encoding
 
482
        # because some callers need to know what can be written - see for
 
483
        # example unescape_for_display.
 
484
        self.encoding = getattr(wrapped_stream, 'encoding', None)
 
485
 
 
486
    def flush(self):
 
487
        self.ui_factory.clear_term()
 
488
        self.wrapped_stream.flush()
 
489
 
 
490
    def write(self, to_write):
 
491
        self.ui_factory.clear_term()
 
492
        self.wrapped_stream.write(to_write)
 
493
 
 
494
    def writelines(self, lines):
 
495
        self.ui_factory.clear_term()
 
496
        self.wrapped_stream.writelines(lines)