← 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: 2010-01-13 16:23:07 UTC
  • mto: (4634.119.7 2.0)
  • mto: This revision was merged to the branch mainline in revision 4959.
  • Revision ID: john@arbash-meinel.com-20100113162307-0bs82td16gzih827
Update the MANIFEST.in file.

Show diffs side-by-side

added added

removed removed

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