← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/ui/text.py

  • Committer: Tarmac
  • Author(s): Vincent Ladeuil
  • Date: 2017-01-30 14:42:05 UTC
  • mfrom: (6620.1.1 trunk)
  • Revision ID: tarmac-20170130144205-r8fh2xpmiuxyozpv
Merge  2.7 into trunk including fix for bug #1657238 [r=vila]

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
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
 
18
 
 
19
18
"""Text UI, write output to the console.
20
19
"""
21
20
 
 
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 (
 
34
    config,
 
35
    debug,
30
36
    progress,
31
37
    osutils,
32
 
    symbol_versioning,
 
38
    trace,
33
39
    )
34
40
 
35
41
""")
36
42
 
37
 
from bzrlib.ui import CLIUIFactory
38
 
 
39
 
 
40
 
class TextUIFactory(CLIUIFactory):
41
 
    """A UI factory for Text user interefaces."""
 
43
from bzrlib.ui import (
 
44
    UIFactory,
 
45
    NullProgressView,
 
46
    )
 
47
 
 
48
 
 
49
class _ChooseUI(object):
 
50
 
 
51
    """ Helper class for choose implementation.
 
52
    """
 
53
 
 
54
    def __init__(self, ui, msg, choices, default):
 
55
        self.ui = ui
 
56
        self._setup_mode()
 
57
        self._build_alternatives(msg, choices, default)
 
58
 
 
59
    def _setup_mode(self):
 
60
        """Setup input mode (line-based, char-based) and echo-back.
 
61
 
 
62
        Line-based input is used if the BZR_TEXTUI_INPUT environment
 
63
        variable is set to 'line-based', or if there is no controlling
 
64
        terminal.
 
65
        """
 
66
        if os.environ.get('BZR_TEXTUI_INPUT') != 'line-based' and \
 
67
           self.ui.stdin == sys.stdin and self.ui.stdin.isatty():
 
68
            self.line_based = False
 
69
            self.echo_back = True
 
70
        else:
 
71
            self.line_based = True
 
72
            self.echo_back = not self.ui.stdin.isatty()
 
73
 
 
74
    def _build_alternatives(self, msg, choices, default):
 
75
        """Parse choices string.
 
76
 
 
77
        Setup final prompt and the lists of choices and associated
 
78
        shortcuts.
 
79
        """
 
80
        index = 0
 
81
        help_list = []
 
82
        self.alternatives = {}
 
83
        choices = choices.split('\n')
 
84
        if default is not None and default not in range(0, len(choices)):
 
85
            raise ValueError("invalid default index")
 
86
        for c in choices:
 
87
            name = c.replace('&', '').lower()
 
88
            choice = (name, index)
 
89
            if name in self.alternatives:
 
90
                raise ValueError("duplicated choice: %s" % name)
 
91
            self.alternatives[name] = choice
 
92
            shortcut = c.find('&')
 
93
            if -1 != shortcut and (shortcut + 1) < len(c):
 
94
                help = c[:shortcut]
 
95
                help += '[' + c[shortcut + 1] + ']'
 
96
                help += c[(shortcut + 2):]
 
97
                shortcut = c[shortcut + 1]
 
98
            else:
 
99
                c = c.replace('&', '')
 
100
                shortcut = c[0]
 
101
                help = '[%s]%s' % (shortcut, c[1:])
 
102
            shortcut = shortcut.lower()
 
103
            if shortcut in self.alternatives:
 
104
                raise ValueError("duplicated shortcut: %s" % shortcut)
 
105
            self.alternatives[shortcut] = choice
 
106
            # Add redirections for default.
 
107
            if index == default:
 
108
                self.alternatives[''] = choice
 
109
                self.alternatives['\r'] = choice
 
110
            help_list.append(help)
 
111
            index += 1
 
112
 
 
113
        self.prompt = u'%s (%s): ' % (msg, ', '.join(help_list))
 
114
 
 
115
    def _getline(self):
 
116
        line = self.ui.stdin.readline()
 
117
        if '' == line:
 
118
            raise EOFError
 
119
        return line.strip()
 
120
 
 
121
    def _getchar(self):
 
122
        char = osutils.getchar()
 
123
        if char == chr(3): # INTR
 
124
            raise KeyboardInterrupt
 
125
        if char == chr(4): # EOF (^d, C-d)
 
126
            raise EOFError
 
127
        return char
 
128
 
 
129
    def interact(self):
 
130
        """Keep asking the user until a valid choice is made.
 
131
        """
 
132
        if self.line_based:
 
133
            getchoice = self._getline
 
134
        else:
 
135
            getchoice = self._getchar
 
136
        iter = 0
 
137
        while True:
 
138
            iter += 1
 
139
            if 1 == iter or self.line_based:
 
140
                self.ui.prompt(self.prompt)
 
141
            try:
 
142
                choice = getchoice()
 
143
            except EOFError:
 
144
                self.ui.stderr.write('\n')
 
145
                return None
 
146
            except KeyboardInterrupt:
 
147
                self.ui.stderr.write('\n')
 
148
                raise KeyboardInterrupt
 
149
            choice = choice.lower()
 
150
            if choice not in self.alternatives:
 
151
                # Not a valid choice, keep on asking.
 
152
                continue
 
153
            name, index = self.alternatives[choice]
 
154
            if self.echo_back:
 
155
                self.ui.stderr.write(name + '\n')
 
156
            return index
 
157
 
 
158
 
 
159
opt_progress_bar = config.Option(
 
160
    'progress_bar', help='Progress bar type.',
 
161
    default_from_env=['BZR_PROGRESS_BAR'], default=None,
 
162
    invalid='error')
 
163
 
 
164
 
 
165
class TextUIFactory(UIFactory):
 
166
    """A UI factory for Text user interfaces."""
42
167
 
43
168
    def __init__(self,
44
 
                 bar_type=None,
45
169
                 stdin=None,
46
170
                 stdout=None,
47
171
                 stderr=None):
48
172
        """Create a TextUIFactory.
49
 
 
50
 
        :param bar_type: The type of progress bar to create. It defaults to
51
 
                         letting the bzrlib.progress.ProgressBar factory auto
52
 
                         select.   Deprecated.
53
173
        """
54
 
        super(TextUIFactory, self).__init__(stdin=stdin,
55
 
                stdout=stdout, stderr=stderr)
56
 
        if bar_type:
57
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 11, 0))
58
 
                % "bar_type parameter")
 
174
        super(TextUIFactory, self).__init__()
 
175
        # TODO: there's no good reason not to pass all three streams, maybe we
 
176
        # should deprecate the default values...
 
177
        self.stdin = stdin
 
178
        self.stdout = stdout
 
179
        self.stderr = stderr
59
180
        # paints progress, network activity, etc
60
 
        self._progress_view = self._make_progress_view()
61
 
        
 
181
        self._progress_view = self.make_progress_view()
 
182
 
 
183
    def choose(self, msg, choices, default=None):
 
184
        """Prompt the user for a list of alternatives.
 
185
 
 
186
        Support both line-based and char-based editing.
 
187
 
 
188
        In line-based mode, both the shortcut and full choice name are valid
 
189
        answers, e.g. for choose('prompt', '&yes\n&no'): 'y', ' Y ', ' yes',
 
190
        'YES ' are all valid input lines for choosing 'yes'.
 
191
 
 
192
        An empty line, when in line-based mode, or pressing enter in char-based
 
193
        mode will select the default choice (if any).
 
194
 
 
195
        Choice is echoed back if:
 
196
        - input is char-based; which means a controlling terminal is available,
 
197
          and osutils.getchar is used
 
198
        - input is line-based, and no controlling terminal is available
 
199
        """
 
200
 
 
201
        choose_ui = _ChooseUI(self, msg, choices, default)
 
202
        return choose_ui.interact()
 
203
 
 
204
    def be_quiet(self, state):
 
205
        if state and not self._quiet:
 
206
            self.clear_term()
 
207
        UIFactory.be_quiet(self, state)
 
208
        self._progress_view = self.make_progress_view()
 
209
 
62
210
    def clear_term(self):
63
211
        """Prepare the terminal for output.
64
212
 
70
218
        # to clear it.  We might need to separately check for the case of
71
219
        self._progress_view.clear()
72
220
 
73
 
    def _make_progress_view(self):
74
 
        if os.environ.get('BZR_PROGRESS_BAR') in ('text', None, ''):
 
221
    def get_integer(self, prompt):
 
222
        while True:
 
223
            self.prompt(prompt)
 
224
            line = self.stdin.readline()
 
225
            try:
 
226
                return int(line)
 
227
            except ValueError:
 
228
                pass
 
229
 
 
230
    def get_non_echoed_password(self):
 
231
        isatty = getattr(self.stdin, 'isatty', None)
 
232
        if isatty is not None and isatty():
 
233
            # getpass() ensure the password is not echoed and other
 
234
            # cross-platform niceties
 
235
            password = getpass.getpass('')
 
236
        else:
 
237
            # echo doesn't make sense without a terminal
 
238
            password = self.stdin.readline()
 
239
            if not password:
 
240
                password = None
 
241
            else:
 
242
                password = password.decode(self.stdin.encoding)
 
243
 
 
244
                if password[-1] == '\n':
 
245
                    password = password[:-1]
 
246
        return password
 
247
 
 
248
    def get_password(self, prompt=u'', **kwargs):
 
249
        """Prompt the user for a password.
 
250
 
 
251
        :param prompt: The prompt to present the user
 
252
        :param kwargs: Arguments which will be expanded into the prompt.
 
253
                       This lets front ends display different things if
 
254
                       they so choose.
 
255
        :return: The password string, return None if the user
 
256
                 canceled the request.
 
257
        """
 
258
        prompt += ': '
 
259
        self.prompt(prompt, **kwargs)
 
260
        # There's currently no way to say 'i decline to enter a password'
 
261
        # as opposed to 'my password is empty' -- does it matter?
 
262
        return self.get_non_echoed_password()
 
263
 
 
264
    def get_username(self, prompt, **kwargs):
 
265
        """Prompt the user for a username.
 
266
 
 
267
        :param prompt: The prompt to present the user
 
268
        :param kwargs: Arguments which will be expanded into the prompt.
 
269
                       This lets front ends display different things if
 
270
                       they so choose.
 
271
        :return: The username string, return None if the user
 
272
                 canceled the request.
 
273
        """
 
274
        prompt += ': '
 
275
        self.prompt(prompt, **kwargs)
 
276
        username = self.stdin.readline()
 
277
        if not username:
 
278
            username = None
 
279
        else:
 
280
            username = username.decode(self.stdin.encoding)
 
281
            if username[-1] == '\n':
 
282
                username = username[:-1]
 
283
        return username
 
284
 
 
285
    def make_progress_view(self):
 
286
        """Construct and return a new ProgressView subclass for this UI.
 
287
        """
 
288
        # with --quiet, never any progress view
 
289
        # <https://bugs.launchpad.net/bzr/+bug/320035>.  Otherwise if the
 
290
        # user specifically requests either text or no progress bars, always
 
291
        # do that.  otherwise, guess based on $TERM and tty presence.
 
292
        if self.is_quiet():
 
293
            return NullProgressView()
 
294
        pb_type = config.GlobalStack().get('progress_bar')
 
295
        if pb_type == 'none': # Explicit requirement
 
296
            return NullProgressView()
 
297
        if (pb_type == 'text' # Explicit requirement
 
298
            or progress._supports_progress(self.stderr)): # Guess
75
299
            return TextProgressView(self.stderr)
 
300
        # No explicit requirement and no successful guess
 
301
        return NullProgressView()
 
302
 
 
303
    def _make_output_stream_explicit(self, encoding, encoding_type):
 
304
        if encoding_type == 'exact':
 
305
            # force sys.stdout to be binary stream on win32; 
 
306
            # NB: this leaves the file set in that mode; may cause problems if
 
307
            # one process tries to do binary and then text output
 
308
            if sys.platform == 'win32':
 
309
                fileno = getattr(self.stdout, 'fileno', None)
 
310
                if fileno:
 
311
                    import msvcrt
 
312
                    msvcrt.setmode(fileno(), os.O_BINARY)
 
313
            return TextUIOutputStream(self, self.stdout)
76
314
        else:
77
 
            return NullProgressView()
 
315
            encoded_stdout = codecs.getwriter(encoding)(self.stdout,
 
316
                errors=encoding_type)
 
317
            # For whatever reason codecs.getwriter() does not advertise its encoding
 
318
            # it just returns the encoding of the wrapped file, which is completely
 
319
            # bogus. So set the attribute, so we can find the correct encoding later.
 
320
            encoded_stdout.encoding = encoding
 
321
            return TextUIOutputStream(self, encoded_stdout)
78
322
 
79
323
    def note(self, msg):
80
324
        """Write an already-formatted message, clearing the progress bar if necessary."""
81
325
        self.clear_term()
82
326
        self.stdout.write(msg + '\n')
83
327
 
 
328
    def prompt(self, prompt, **kwargs):
 
329
        """Emit prompt on the CLI.
 
330
        
 
331
        :param kwargs: Dictionary of arguments to insert into the prompt,
 
332
            to allow UIs to reformat the prompt.
 
333
        """
 
334
        if type(prompt) != unicode:
 
335
            raise ValueError("prompt %r not a unicode string" % prompt)
 
336
        if kwargs:
 
337
            # See <https://launchpad.net/bugs/365891>
 
338
            prompt = prompt % kwargs
 
339
        try:
 
340
            prompt = prompt.encode(self.stderr.encoding)
 
341
        except (UnicodeError, AttributeError):
 
342
            # If stderr has no encoding attribute or can't properly encode,
 
343
            # fallback to terminal encoding for robustness (better display
 
344
            # something to the user than aborting with a traceback).
 
345
            prompt = prompt.encode(osutils.get_terminal_encoding(), 'replace')
 
346
        self.clear_term()
 
347
        self.stdout.flush()
 
348
        self.stderr.write(prompt)
 
349
 
84
350
    def report_transport_activity(self, transport, byte_count, direction):
85
351
        """Called by transports as they do IO.
86
352
 
90
356
        self._progress_view.show_transport_activity(transport,
91
357
            direction, byte_count)
92
358
 
 
359
    def log_transport_activity(self, display=False):
 
360
        """See UIFactory.log_transport_activity()"""
 
361
        log = getattr(self._progress_view, 'log_transport_activity', None)
 
362
        if log is not None:
 
363
            log(display=display)
 
364
 
 
365
    def show_error(self, msg):
 
366
        self.clear_term()
 
367
        self.stderr.write("bzr: error: %s\n" % msg)
 
368
 
 
369
    def show_message(self, msg):
 
370
        self.note(msg)
 
371
 
 
372
    def show_warning(self, msg):
 
373
        self.clear_term()
 
374
        if isinstance(msg, unicode):
 
375
            te = osutils.get_terminal_encoding()
 
376
            msg = msg.encode(te, 'replace')
 
377
        self.stderr.write("bzr: warning: %s\n" % msg)
 
378
 
93
379
    def _progress_updated(self, task):
94
380
        """A task has been updated and wants to be displayed.
95
381
        """
97
383
            warnings.warn("%r updated but no tasks are active" %
98
384
                (task,))
99
385
        elif task != self._task_stack[-1]:
100
 
            warnings.warn("%r is not the top progress task %r" %
101
 
                (task, self._task_stack[-1]))
 
386
            # We used to check it was the top task, but it's hard to always
 
387
            # get this right and it's not necessarily useful: any actual
 
388
            # problems will be evident in use
 
389
            #warnings.warn("%r is not the top progress task %r" %
 
390
            #     (task, self._task_stack[-1]))
 
391
            pass
102
392
        self._progress_view.show_progress(task)
103
393
 
104
394
    def _progress_all_finished(self):
105
395
        self._progress_view.clear()
106
396
 
107
 
 
108
 
class NullProgressView(object):
109
 
    """Soak up and ignore progress information."""
110
 
 
111
 
    def clear(self):
112
 
        pass
113
 
 
114
 
    def show_progress(self, task):
115
 
        pass
116
 
 
117
 
    def show_transport_activity(self, transport, direction, byte_count):
118
 
        pass
119
 
    
 
397
    def show_user_warning(self, warning_id, **message_args):
 
398
        """Show a text message to the user.
 
399
 
 
400
        Explicitly not for warnings about bzr apis, deprecations or internals.
 
401
        """
 
402
        # eventually trace.warning should migrate here, to avoid logging and
 
403
        # be easier to test; that has a lot of test fallout so for now just
 
404
        # new code can call this
 
405
        if warning_id not in self.suppressed_warnings:
 
406
            self.stderr.write(self.format_user_warning(warning_id, message_args) +
 
407
                '\n')
 
408
 
120
409
 
121
410
class TextProgressView(object):
122
411
    """Display of progress bar and other information on a tty.
133
422
    this only prints the stack from the nominated current task up to the root.
134
423
    """
135
424
 
136
 
    def __init__(self, term_file):
 
425
    def __init__(self, term_file, encoding=None, errors="replace"):
137
426
        self._term_file = term_file
 
427
        if encoding is None:
 
428
            self._encoding = getattr(term_file, "encoding", None) or "ascii"
 
429
        else:
 
430
            self._encoding = encoding
 
431
        self._encoding_errors = errors
138
432
        # true when there's output on the screen we may need to clear
139
433
        self._have_output = False
140
 
        # XXX: We could listen for SIGWINCH and update the terminal width...
141
 
        self._width = osutils.terminal_width()
142
434
        self._last_transport_msg = ''
143
435
        self._spin_pos = 0
144
436
        # time we last repainted the screen
148
440
        self._last_task = None
149
441
        self._total_byte_count = 0
150
442
        self._bytes_since_update = 0
151
 
 
152
 
    def _show_line(self, s):
153
 
        n = self._width - 1
154
 
        self._term_file.write('\r%-*.*s\r' % (n, n, s))
 
443
        self._bytes_by_direction = {'unknown': 0, 'read': 0, 'write': 0}
 
444
        self._first_byte_time = None
 
445
        self._fraction = 0
 
446
        # force the progress bar to be off, as at the moment it doesn't 
 
447
        # correspond reliably to overall command progress
 
448
        self.enable_bar = False
 
449
 
 
450
    def _avail_width(self):
 
451
        # we need one extra space for terminals that wrap on last char
 
452
        w = osutils.terminal_width() 
 
453
        if w is None:
 
454
            return None
 
455
        else:
 
456
            return w - 1
 
457
 
 
458
    def _show_line(self, u):
 
459
        s = u.encode(self._encoding, self._encoding_errors)
 
460
        width = self._avail_width()
 
461
        if width is not None:
 
462
            # GZ 2012-03-28: Counting bytes is wrong for calculating width of
 
463
            #                text but better than counting codepoints.
 
464
            s = '%-*.*s' % (width, width, s)
 
465
        self._term_file.write('\r' + s + '\r')
155
466
 
156
467
    def clear(self):
157
468
        if self._have_output:
160
471
 
161
472
    def _render_bar(self):
162
473
        # return a string for the progress bar itself
163
 
        if (self._last_task is None) or self._last_task.show_bar:
 
474
        if self.enable_bar and (
 
475
            (self._last_task is None) or self._last_task.show_bar):
164
476
            # If there's no task object, we show space for the bar anyhow.
165
477
            # That's because most invocations of bzr will end showing progress
166
478
            # at some point, though perhaps only after doing some initial IO.
171
483
            cols = 20
172
484
            if self._last_task is None:
173
485
                completion_fraction = 0
 
486
                self._fraction = 0
174
487
            else:
175
488
                completion_fraction = \
176
489
                    self._last_task._overall_completion_fraction() or 0
 
490
            if (completion_fraction < self._fraction and 'progress' in
 
491
                debug.debug_flags):
 
492
                import pdb;pdb.set_trace()
 
493
            self._fraction = completion_fraction
177
494
            markers = int(round(float(cols) * completion_fraction)) - 1
178
495
            bar_str = '[' + ('#' * markers + spin_str).ljust(cols) + '] '
179
496
            return bar_str
180
 
        elif self._last_task.show_spinner:
 
497
        elif (self._last_task is None) or self._last_task.show_spinner:
181
498
            # The last task wanted just a spinner, no bar
182
499
            spin_str =  r'/-\|'[self._spin_pos % 4]
183
500
            self._spin_pos += 1
186
503
            return ''
187
504
 
188
505
    def _format_task(self, task):
 
506
        """Format task-specific parts of progress bar.
 
507
 
 
508
        :returns: (text_part, counter_part) both unicode strings.
 
509
        """
189
510
        if not task.show_count:
190
511
            s = ''
191
512
        elif task.current_cnt is not None and task.total_cnt is not None:
201
522
            t = t._parent_task
202
523
            if t.msg:
203
524
                m = t.msg + ':' + m
204
 
        return m + s
 
525
        return m, s
205
526
 
206
527
    def _render_line(self):
207
528
        bar_string = self._render_bar()
208
529
        if self._last_task:
209
 
            task_msg = self._format_task(self._last_task)
210
 
        else:
211
 
            task_msg = ''
212
 
        trans = self._last_transport_msg
213
 
        if trans:
214
 
            trans += ' | '
215
 
        return (bar_string + trans + task_msg)
 
530
            task_part, counter_part = self._format_task(self._last_task)
 
531
        else:
 
532
            task_part = counter_part = ''
 
533
        if self._last_task and not self._last_task.show_transport_activity:
 
534
            trans = ''
 
535
        else:
 
536
            trans = self._last_transport_msg
 
537
        # the bar separates the transport activity from the message, so even
 
538
        # if there's no bar or spinner, we must show something if both those
 
539
        # fields are present
 
540
        if (task_part or trans) and not bar_string:
 
541
            bar_string = '| '
 
542
        # preferentially truncate the task message if we don't have enough
 
543
        # space
 
544
        avail_width = self._avail_width()
 
545
        if avail_width is not None:
 
546
            # if terminal avail_width is unknown, don't truncate
 
547
            current_len = len(bar_string) + len(trans) + len(task_part) + len(counter_part)
 
548
            gap = current_len - avail_width
 
549
            if gap > 0:
 
550
                task_part = task_part[:-gap-2] + '..'
 
551
        s = trans + bar_string + task_part + counter_part
 
552
        if avail_width is not None:
 
553
            if len(s) < avail_width:
 
554
                s = s.ljust(avail_width)
 
555
            elif len(s) > avail_width:
 
556
                s = s[:avail_width]
 
557
        return s
216
558
 
217
559
    def _repaint(self):
218
560
        s = self._render_line()
228
570
        must_update = task is not self._last_task
229
571
        self._last_task = task
230
572
        now = time.time()
231
 
        if (not must_update) and (now < self._last_repaint + 0.1):
 
573
        if (not must_update) and (now < self._last_repaint + task.update_latency):
232
574
            return
233
575
        if now > self._transport_update_time + 10:
234
576
            # no recent activity; expire it
242
584
        This may update a progress bar, spinner, or similar display.
243
585
        By default it does nothing.
244
586
        """
245
 
        # XXX: Probably there should be a transport activity model, and that
246
 
        # too should be seen by the progress view, rather than being poked in
247
 
        # here.
 
587
        # XXX: there should be a transport activity model, and that too should
 
588
        #      be seen by the progress view, rather than being poked in here.
248
589
        self._total_byte_count += byte_count
249
590
        self._bytes_since_update += byte_count
 
591
        if self._first_byte_time is None:
 
592
            # Note that this isn't great, as technically it should be the time
 
593
            # when the bytes started transferring, not when they completed.
 
594
            # However, we usually start with a small request anyway.
 
595
            self._first_byte_time = time.time()
 
596
        if direction in self._bytes_by_direction:
 
597
            self._bytes_by_direction[direction] += byte_count
 
598
        else:
 
599
            self._bytes_by_direction['unknown'] += byte_count
 
600
        if 'no_activity' in debug.debug_flags:
 
601
            # Can be used as a workaround if
 
602
            # <https://launchpad.net/bugs/321935> reappears and transport
 
603
            # activity is cluttering other output.  However, thanks to
 
604
            # TextUIOutputStream this shouldn't be a problem any more.
 
605
            return
250
606
        now = time.time()
 
607
        if self._total_byte_count < 2000:
 
608
            # a little resistance at first, so it doesn't stay stuck at 0
 
609
            # while connecting...
 
610
            return
251
611
        if self._transport_update_time is None:
252
612
            self._transport_update_time = now
253
613
        elif now >= (self._transport_update_time + 0.5):
254
614
            # guard against clock stepping backwards, and don't update too
255
615
            # often
256
 
            rate = self._bytes_since_update / (now - self._transport_update_time)
257
 
            scheme = getattr(transport, '_scheme', None) or repr(transport)
258
 
            if direction == 'read':
259
 
                dir_char = '>'
260
 
            elif direction == 'write':
261
 
                dir_char = '<'
262
 
            else:
263
 
                dir_char = ' '
264
 
            msg = ("%.7s %s %6dKB %5dKB/s" %
265
 
                    (scheme, dir_char, self._total_byte_count>>10, int(rate)>>10,))
 
616
            rate = (self._bytes_since_update
 
617
                    / (now - self._transport_update_time))
 
618
            # using base-10 units (see HACKING.txt).
 
619
            msg = ("%6dkB %5dkB/s " %
 
620
                    (self._total_byte_count / 1000, int(rate) / 1000,))
266
621
            self._transport_update_time = now
267
622
            self._last_repaint = now
268
623
            self._bytes_since_update = 0
269
624
            self._last_transport_msg = msg
270
625
            self._repaint()
271
626
 
272
 
 
 
627
    def _format_bytes_by_direction(self):
 
628
        if self._first_byte_time is None:
 
629
            bps = 0.0
 
630
        else:
 
631
            transfer_time = time.time() - self._first_byte_time
 
632
            if transfer_time < 0.001:
 
633
                transfer_time = 0.001
 
634
            bps = self._total_byte_count / transfer_time
 
635
 
 
636
        # using base-10 units (see HACKING.txt).
 
637
        msg = ('Transferred: %.0fkB'
 
638
               ' (%.1fkB/s r:%.0fkB w:%.0fkB'
 
639
               % (self._total_byte_count / 1000.,
 
640
                  bps / 1000.,
 
641
                  self._bytes_by_direction['read'] / 1000.,
 
642
                  self._bytes_by_direction['write'] / 1000.,
 
643
                 ))
 
644
        if self._bytes_by_direction['unknown'] > 0:
 
645
            msg += ' u:%.0fkB)' % (
 
646
                self._bytes_by_direction['unknown'] / 1000.
 
647
                )
 
648
        else:
 
649
            msg += ')'
 
650
        return msg
 
651
 
 
652
    def log_transport_activity(self, display=False):
 
653
        msg = self._format_bytes_by_direction()
 
654
        trace.mutter(msg)
 
655
        if display and self._total_byte_count > 0:
 
656
            self.clear()
 
657
            self._term_file.write(msg + '\n')
 
658
 
 
659
 
 
660
class TextUIOutputStream(object):
 
661
    """Decorates an output stream so that the terminal is cleared before writing.
 
662
 
 
663
    This is supposed to ensure that the progress bar does not conflict with bulk
 
664
    text output.
 
665
    """
 
666
    # XXX: this does not handle the case of writing part of a line, then doing
 
667
    # progress bar output: the progress bar will probably write over it.
 
668
    # one option is just to buffer that text until we have a full line;
 
669
    # another is to save and restore it
 
670
 
 
671
    # XXX: might need to wrap more methods
 
672
 
 
673
    def __init__(self, ui_factory, wrapped_stream):
 
674
        self.ui_factory = ui_factory
 
675
        self.wrapped_stream = wrapped_stream
 
676
        # this does no transcoding, but it must expose the underlying encoding
 
677
        # because some callers need to know what can be written - see for
 
678
        # example unescape_for_display.
 
679
        self.encoding = getattr(wrapped_stream, 'encoding', None)
 
680
 
 
681
    def flush(self):
 
682
        self.ui_factory.clear_term()
 
683
        self.wrapped_stream.flush()
 
684
 
 
685
    def write(self, to_write):
 
686
        self.ui_factory.clear_term()
 
687
        self.wrapped_stream.write(to_write)
 
688
 
 
689
    def writelines(self, lines):
 
690
        self.ui_factory.clear_term()
 
691
        self.wrapped_stream.writelines(lines)