/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: Marius Kruger
  • Date: 2010-07-10 21:28:56 UTC
  • mto: (5384.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5385.
  • Revision ID: marius.kruger@enerweb.co.za-20100710212856-uq4ji3go0u5se7hx
* Update documentation
* add NEWS

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-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
"""Text UI, write output to the console."""
18
17
 
19
 
from __future__ import absolute_import
 
18
"""Text UI, write output to the console.
 
19
"""
20
20
 
21
21
import codecs
22
 
import io
 
22
import getpass
23
23
import os
24
24
import sys
 
25
import time
25
26
import warnings
26
27
 
27
 
from ..lazy_import import lazy_import
 
28
from bzrlib.lazy_import import lazy_import
28
29
lazy_import(globals(), """
29
 
import getpass
30
 
import time
31
 
 
32
 
from breezy import (
 
30
from bzrlib import (
33
31
    debug,
34
32
    progress,
35
 
    )
36
 
""")
37
 
 
38
 
from .. import (
39
 
    config,
40
33
    osutils,
 
34
    symbol_versioning,
41
35
    trace,
42
36
    )
43
 
from ..sixish import (
44
 
    text_type,
45
 
    )
46
 
from . import (
 
37
 
 
38
""")
 
39
 
 
40
from bzrlib.ui import (
 
41
    UIFactory,
47
42
    NullProgressView,
48
 
    UIFactory,
49
43
    )
50
44
 
51
45
 
52
 
class _ChooseUI(object):
53
 
 
54
 
    """ Helper class for choose implementation.
55
 
    """
56
 
 
57
 
    def __init__(self, ui, msg, choices, default):
58
 
        self.ui = ui
59
 
        self._setup_mode()
60
 
        self._build_alternatives(msg, choices, default)
61
 
 
62
 
    def _setup_mode(self):
63
 
        """Setup input mode (line-based, char-based) and echo-back.
64
 
 
65
 
        Line-based input is used if the BRZ_TEXTUI_INPUT environment
66
 
        variable is set to 'line-based', or if there is no controlling
67
 
        terminal.
68
 
        """
69
 
        is_tty = self.ui.raw_stdin.isatty()
70
 
        if (os.environ.get('BRZ_TEXTUI_INPUT') != 'line-based' and
71
 
                self.ui.raw_stdin == _unwrap_stream(sys.stdin) and is_tty):
72
 
            self.line_based = False
73
 
            self.echo_back = True
74
 
        else:
75
 
            self.line_based = True
76
 
            self.echo_back = not is_tty
77
 
 
78
 
    def _build_alternatives(self, msg, choices, default):
79
 
        """Parse choices string.
80
 
 
81
 
        Setup final prompt and the lists of choices and associated
82
 
        shortcuts.
83
 
        """
84
 
        index = 0
85
 
        help_list = []
86
 
        self.alternatives = {}
87
 
        choices = choices.split('\n')
88
 
        if default is not None and default not in range(0, len(choices)):
89
 
            raise ValueError("invalid default index")
90
 
        for c in choices:
91
 
            name = c.replace('&', '').lower()
92
 
            choice = (name, index)
93
 
            if name in self.alternatives:
94
 
                raise ValueError("duplicated choice: %s" % name)
95
 
            self.alternatives[name] = choice
96
 
            shortcut = c.find('&')
97
 
            if -1 != shortcut and (shortcut + 1) < len(c):
98
 
                help = c[:shortcut]
99
 
                help += '[' + c[shortcut + 1] + ']'
100
 
                help += c[(shortcut + 2):]
101
 
                shortcut = c[shortcut + 1]
102
 
            else:
103
 
                c = c.replace('&', '')
104
 
                shortcut = c[0]
105
 
                help = '[%s]%s' % (shortcut, c[1:])
106
 
            shortcut = shortcut.lower()
107
 
            if shortcut in self.alternatives:
108
 
                raise ValueError("duplicated shortcut: %s" % shortcut)
109
 
            self.alternatives[shortcut] = choice
110
 
            # Add redirections for default.
111
 
            if index == default:
112
 
                self.alternatives[''] = choice
113
 
                self.alternatives['\r'] = choice
114
 
            help_list.append(help)
115
 
            index += 1
116
 
 
117
 
        self.prompt = u'%s (%s): ' % (msg, ', '.join(help_list))
118
 
 
119
 
    def _getline(self):
120
 
        line = self.ui.stdin.readline()
121
 
        if '' == line:
122
 
            raise EOFError
123
 
        return line.strip()
124
 
 
125
 
    def _getchar(self):
126
 
        char = osutils.getchar()
127
 
        if char == chr(3):  # INTR
128
 
            raise KeyboardInterrupt
129
 
        if char == chr(4):  # EOF (^d, C-d)
130
 
            raise EOFError
131
 
        if isinstance(char, bytes):
132
 
            return char.decode('ascii', 'replace')
133
 
        return char
134
 
 
135
 
    def interact(self):
136
 
        """Keep asking the user until a valid choice is made.
137
 
        """
138
 
        if self.line_based:
139
 
            getchoice = self._getline
140
 
        else:
141
 
            getchoice = self._getchar
142
 
        iter = 0
143
 
        while True:
144
 
            iter += 1
145
 
            if 1 == iter or self.line_based:
146
 
                self.ui.prompt(self.prompt)
147
 
            try:
148
 
                choice = getchoice()
149
 
            except EOFError:
150
 
                self.ui.stderr.write(u'\n')
151
 
                return None
152
 
            except KeyboardInterrupt:
153
 
                self.ui.stderr.write(u'\n')
154
 
                raise
155
 
            choice = choice.lower()
156
 
            if choice not in self.alternatives:
157
 
                # Not a valid choice, keep on asking.
158
 
                continue
159
 
            name, index = self.alternatives[choice]
160
 
            if self.echo_back:
161
 
                self.ui.stderr.write(name + u'\n')
162
 
            return index
163
 
 
164
 
 
165
 
opt_progress_bar = config.Option(
166
 
    'progress_bar', help='Progress bar type.',
167
 
    default_from_env=['BRZ_PROGRESS_BAR'], default=None,
168
 
    invalid='error')
169
 
 
170
 
 
171
46
class TextUIFactory(UIFactory):
172
 
    """A UI factory for Text user interfaces."""
 
47
    """A UI factory for Text user interefaces."""
173
48
 
174
 
    def __init__(self, stdin, stdout, stderr):
175
 
        """Create a TextUIFactory."""
 
49
    def __init__(self,
 
50
                 stdin=None,
 
51
                 stdout=None,
 
52
                 stderr=None):
 
53
        """Create a TextUIFactory.
 
54
        """
176
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...
177
58
        self.stdin = stdin
178
59
        self.stdout = stdout
179
60
        self.stderr = stderr
180
 
        self._progress_view = NullProgressView()
181
 
 
182
 
    def __enter__(self):
183
 
        # Choose default encoding and handle py2/3 differences
184
 
        self._setup_streams()
185
61
        # paints progress, network activity, etc
186
62
        self._progress_view = self.make_progress_view()
187
 
        return self
188
 
 
189
 
    def _setup_streams(self):
190
 
        self.raw_stdin = _unwrap_stream(self.stdin)
191
 
        self.stdin = _wrap_in_stream(self.raw_stdin)
192
 
        self.raw_stdout = _unwrap_stream(self.stdout)
193
 
        self.stdout = _wrap_out_stream(self.raw_stdout)
194
 
        self.raw_stderr = _unwrap_stream(self.stderr)
195
 
        self.stderr = _wrap_out_stream(self.raw_stderr)
196
 
 
197
 
    def choose(self, msg, choices, default=None):
198
 
        """Prompt the user for a list of alternatives.
199
 
 
200
 
        Support both line-based and char-based editing.
201
 
 
202
 
        In line-based mode, both the shortcut and full choice name are valid
203
 
        answers, e.g. for choose('prompt', '&yes\n&no'): 'y', ' Y ', ' yes',
204
 
        'YES ' are all valid input lines for choosing 'yes'.
205
 
 
206
 
        An empty line, when in line-based mode, or pressing enter in char-based
207
 
        mode will select the default choice (if any).
208
 
 
209
 
        Choice is echoed back if:
210
 
        - input is char-based; which means a controlling terminal is available,
211
 
          and osutils.getchar is used
212
 
        - input is line-based, and no controlling terminal is available
213
 
        """
214
 
 
215
 
        choose_ui = _ChooseUI(self, msg, choices, default)
216
 
        return choose_ui.interact()
217
63
 
218
64
    def be_quiet(self, state):
219
65
        if state and not self._quiet:
232
78
        # to clear it.  We might need to separately check for the case of
233
79
        self._progress_view.clear()
234
80
 
 
81
    def get_boolean(self, prompt):
 
82
        while True:
 
83
            self.prompt(prompt + "? [y/n]: ")
 
84
            line = self.stdin.readline().lower()
 
85
            if line in ('y\n', 'yes\n'):
 
86
                return True
 
87
            elif line in ('n\n', 'no\n'):
 
88
                return False
 
89
            elif line in ('', None):
 
90
                # end-of-file; possibly should raise an error here instead
 
91
                return None
 
92
 
235
93
    def get_integer(self, prompt):
236
94
        while True:
237
95
            self.prompt(prompt)
252
110
            password = self.stdin.readline()
253
111
            if not password:
254
112
                password = None
255
 
            else:
256
 
                if password[-1] == '\n':
257
 
                    password = password[:-1]
 
113
            elif password[-1] == '\n':
 
114
                password = password[:-1]
258
115
        return password
259
116
 
260
 
    def get_password(self, prompt=u'', **kwargs):
 
117
    def get_password(self, prompt='', **kwargs):
261
118
        """Prompt the user for a password.
262
119
 
263
120
        :param prompt: The prompt to present the user
288
145
        username = self.stdin.readline()
289
146
        if not username:
290
147
            username = None
291
 
        else:
292
 
            if username[-1] == '\n':
293
 
                username = username[:-1]
 
148
        elif username[-1] == '\n':
 
149
            username = username[:-1]
294
150
        return username
295
151
 
296
152
    def make_progress_view(self):
302
158
        # do that.  otherwise, guess based on $TERM and tty presence.
303
159
        if self.is_quiet():
304
160
            return NullProgressView()
305
 
        pb_type = config.GlobalStack().get('progress_bar')
306
 
        if pb_type == 'none':  # Explicit requirement
307
 
            return NullProgressView()
308
 
        if (pb_type == 'text' or # Explicit requirement
309
 
                progress._supports_progress(self.stderr)):  # Guess
310
 
            return TextProgressView(self.stderr)
311
 
        # No explicit requirement and no successful guess
312
 
        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()
313
169
 
314
170
    def _make_output_stream_explicit(self, encoding, encoding_type):
315
 
        return TextUIOutputStream(self, self.stdout, 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)
316
189
 
317
190
    def note(self, msg):
318
191
        """Write an already-formatted message, clearing the progress bar if necessary."""
321
194
 
322
195
    def prompt(self, prompt, **kwargs):
323
196
        """Emit prompt on the CLI.
324
 
 
 
197
        
325
198
        :param kwargs: Dictionary of arguments to insert into the prompt,
326
199
            to allow UIs to reformat the prompt.
327
200
        """
328
 
        if not isinstance(prompt, text_type):
329
 
            raise ValueError("prompt %r not a unicode string" % prompt)
330
201
        if kwargs:
331
202
            # See <https://launchpad.net/bugs/365891>
332
203
            prompt = prompt % kwargs
 
204
        prompt = prompt.encode(osutils.get_terminal_encoding(), 'replace')
333
205
        self.clear_term()
334
 
        self.stdout.flush()
335
206
        self.stderr.write(prompt)
336
 
        self.stderr.flush()
337
207
 
338
208
    def report_transport_activity(self, transport, byte_count, direction):
339
209
        """Called by transports as they do IO.
342
212
        By default it does nothing.
343
213
        """
344
214
        self._progress_view.show_transport_activity(transport,
345
 
                                                    direction, byte_count)
 
215
            direction, byte_count)
346
216
 
347
217
    def log_transport_activity(self, display=False):
348
218
        """See UIFactory.log_transport_activity()"""
359
229
 
360
230
    def show_warning(self, msg):
361
231
        self.clear_term()
 
232
        if isinstance(msg, unicode):
 
233
            te = osutils.get_terminal_encoding()
 
234
            msg = msg.encode(te, 'replace')
362
235
        self.stderr.write("bzr: warning: %s\n" % msg)
363
236
 
364
237
    def _progress_updated(self, task):
366
239
        """
367
240
        if not self._task_stack:
368
241
            warnings.warn("%r updated but no tasks are active" %
369
 
                          (task,))
 
242
                (task,))
370
243
        elif task != self._task_stack[-1]:
371
244
            # We used to check it was the top task, but it's hard to always
372
245
            # get this right and it's not necessarily useful: any actual
373
246
            # problems will be evident in use
374
 
            # warnings.warn("%r is not the top progress task %r" %
 
247
            #warnings.warn("%r is not the top progress task %r" %
375
248
            #     (task, self._task_stack[-1]))
376
249
            pass
377
250
        self._progress_view.show_progress(task)
388
261
        # be easier to test; that has a lot of test fallout so for now just
389
262
        # new code can call this
390
263
        if warning_id not in self.suppressed_warnings:
391
 
            warning = self.format_user_warning(warning_id, message_args)
392
 
            self.stderr.write(warning + '\n')
393
 
 
394
 
 
395
 
def pad_to_width(line, width, encoding_hint='ascii'):
396
 
    """Truncate or pad unicode line to width.
397
 
 
398
 
    This is best-effort for now, and strings containing control codes or
399
 
    non-ascii text may be cut and padded incorrectly.
400
 
    """
401
 
    s = line.encode(encoding_hint, 'replace')
402
 
    return (b'%-*.*s' % (width, width, s)).decode(encoding_hint)
 
264
            self.stderr.write(self.format_user_warning(warning_id, message_args) +
 
265
                '\n')
403
266
 
404
267
 
405
268
class TextProgressView(object):
406
269
    """Display of progress bar and other information on a tty.
407
270
 
408
 
    This shows one line of text, including possibly a network indicator,
409
 
    spinner, progress bar, message, etc.
 
271
    This shows one line of text, including possibly a network indicator, spinner,
 
272
    progress bar, message, etc.
410
273
 
411
274
    One instance of this is created and held by the UI, and fed updates when a
412
275
    task wants to be painted.
417
280
    this only prints the stack from the nominated current task up to the root.
418
281
    """
419
282
 
420
 
    def __init__(self, term_file, encoding=None, errors=None):
 
283
    def __init__(self, term_file):
421
284
        self._term_file = term_file
422
 
        if encoding is None:
423
 
            self._encoding = getattr(term_file, "encoding", None) or "ascii"
424
 
        else:
425
 
            self._encoding = encoding
426
285
        # true when there's output on the screen we may need to clear
427
286
        self._have_output = False
428
287
        self._last_transport_msg = ''
437
296
        self._bytes_by_direction = {'unknown': 0, 'read': 0, 'write': 0}
438
297
        self._first_byte_time = None
439
298
        self._fraction = 0
440
 
        # force the progress bar to be off, as at the moment it doesn't
 
299
        # force the progress bar to be off, as at the moment it doesn't 
441
300
        # correspond reliably to overall command progress
442
301
        self.enable_bar = False
443
302
 
444
 
    def _avail_width(self):
445
 
        # we need one extra space for terminals that wrap on last char
446
 
        w = osutils.terminal_width()
447
 
        if w is None:
448
 
            return None
449
 
        else:
450
 
            return w - 1
451
 
 
452
 
    def _show_line(self, u):
453
 
        width = self._avail_width()
 
303
    def _show_line(self, s):
 
304
        # sys.stderr.write("progress %r\n" % s)
 
305
        width = osutils.terminal_width()
454
306
        if width is not None:
455
 
            u = pad_to_width(u, width, encoding_hint=self._encoding)
456
 
        self._term_file.write('\r' + u + '\r')
 
307
            # we need one extra space for terminals that wrap on last char
 
308
            width = width - 1
 
309
            s = '%-*.*s' % (width, width, s)
 
310
        self._term_file.write('\r' + s + '\r')
457
311
 
458
312
    def clear(self):
459
313
        if self._have_output:
463
317
    def _render_bar(self):
464
318
        # return a string for the progress bar itself
465
319
        if self.enable_bar and (
466
 
                (self._last_task is None) or self._last_task.show_bar):
 
320
            (self._last_task is None) or self._last_task.show_bar):
467
321
            # If there's no task object, we show space for the bar anyhow.
468
322
            # That's because most invocations of bzr will end showing progress
469
323
            # at some point, though perhaps only after doing some initial IO.
470
324
            # It looks better to draw the progress bar initially rather than
471
325
            # to have what looks like an incomplete progress bar.
472
 
            spin_str = r'/-\|'[self._spin_pos % 4]
 
326
            spin_str =  r'/-\|'[self._spin_pos % 4]
473
327
            self._spin_pos += 1
474
328
            cols = 20
475
329
            if self._last_task is None:
479
333
                completion_fraction = \
480
334
                    self._last_task._overall_completion_fraction() or 0
481
335
            if (completion_fraction < self._fraction and 'progress' in
482
 
                    debug.debug_flags):
483
 
                debug.set_trace()
 
336
                debug.debug_flags):
 
337
                import pdb;pdb.set_trace()
484
338
            self._fraction = completion_fraction
485
339
            markers = int(round(float(cols) * completion_fraction)) - 1
486
340
            bar_str = '[' + ('#' * markers + spin_str).ljust(cols) + '] '
487
341
            return bar_str
488
342
        elif (self._last_task is None) or self._last_task.show_spinner:
489
343
            # The last task wanted just a spinner, no bar
490
 
            spin_str = r'/-\|'[self._spin_pos % 4]
 
344
            spin_str =  r'/-\|'[self._spin_pos % 4]
491
345
            self._spin_pos += 1
492
346
            return spin_str + ' '
493
347
        else:
494
348
            return ''
495
349
 
496
350
    def _format_task(self, task):
497
 
        """Format task-specific parts of progress bar.
498
 
 
499
 
        :returns: (text_part, counter_part) both unicode strings.
500
 
        """
501
351
        if not task.show_count:
502
352
            s = ''
503
353
        elif task.current_cnt is not None and task.total_cnt is not None:
513
363
            t = t._parent_task
514
364
            if t.msg:
515
365
                m = t.msg + ':' + m
516
 
        return m, s
 
366
        return m + s
517
367
 
518
368
    def _render_line(self):
519
369
        bar_string = self._render_bar()
520
370
        if self._last_task:
521
 
            task_part, counter_part = self._format_task(self._last_task)
 
371
            task_msg = self._format_task(self._last_task)
522
372
        else:
523
 
            task_part = counter_part = ''
 
373
            task_msg = ''
524
374
        if self._last_task and not self._last_task.show_transport_activity:
525
375
            trans = ''
526
376
        else:
527
377
            trans = self._last_transport_msg
528
 
        # the bar separates the transport activity from the message, so even
529
 
        # if there's no bar or spinner, we must show something if both those
530
 
        # fields are present
531
 
        if (task_part or trans) and not bar_string:
532
 
            bar_string = '| '
533
 
        # preferentially truncate the task message if we don't have enough
534
 
        # space
535
 
        avail_width = self._avail_width()
536
 
        if avail_width is not None:
537
 
            # if terminal avail_width is unknown, don't truncate
538
 
            current_len = len(bar_string) + len(trans) + \
539
 
                len(task_part) + len(counter_part)
540
 
            # GZ 2017-04-22: Should measure and truncate task_part properly
541
 
            gap = current_len - avail_width
542
 
            if gap > 0:
543
 
                task_part = task_part[:-gap - 2] + '..'
544
 
        s = trans + bar_string + task_part + counter_part
545
 
        if avail_width is not None:
546
 
            if len(s) < avail_width:
547
 
                s = s.ljust(avail_width)
548
 
            elif len(s) > avail_width:
549
 
                s = s[:avail_width]
550
 
        return s
 
378
            if trans:
 
379
                trans += ' | '
 
380
        return (bar_string + trans + task_msg)
551
381
 
552
382
    def _repaint(self):
553
383
        s = self._render_line()
556
386
 
557
387
    def show_progress(self, task):
558
388
        """Called by the task object when it has changed.
559
 
 
560
 
        :param task: The top task object; its parents are also included
 
389
        
 
390
        :param task: The top task object; its parents are also included 
561
391
            by following links.
562
392
        """
563
393
        must_update = task is not self._last_task
606
436
        elif now >= (self._transport_update_time + 0.5):
607
437
            # guard against clock stepping backwards, and don't update too
608
438
            # often
609
 
            rate = (self._bytes_since_update /
610
 
                    (now - self._transport_update_time))
 
439
            rate = (self._bytes_since_update
 
440
                    / (now - self._transport_update_time))
611
441
            # using base-10 units (see HACKING.txt).
612
 
            msg = ("%6dkB %5dkB/s " %
613
 
                   (self._total_byte_count / 1000, int(rate) / 1000,))
 
442
            msg = ("%6dkB %5dkB/s" %
 
443
                    (self._total_byte_count / 1000, int(rate) / 1000,))
614
444
            self._transport_update_time = now
615
445
            self._last_repaint = now
616
446
            self._bytes_since_update = 0
633
463
                  bps / 1000.,
634
464
                  self._bytes_by_direction['read'] / 1000.,
635
465
                  self._bytes_by_direction['write'] / 1000.,
636
 
                  ))
 
466
                 ))
637
467
        if self._bytes_by_direction['unknown'] > 0:
638
468
            msg += ' u:%.0fkB)' % (
639
469
                self._bytes_by_direction['unknown'] / 1000.
650
480
            self._term_file.write(msg + '\n')
651
481
 
652
482
 
653
 
def _get_stream_encoding(stream):
654
 
    encoding = config.GlobalStack().get('output_encoding')
655
 
    if encoding is None:
656
 
        encoding = getattr(stream, "encoding", None)
657
 
    if encoding is None:
658
 
        encoding = osutils.get_terminal_encoding(trace=True)
659
 
    return encoding
660
 
 
661
 
 
662
 
def _unwrap_stream(stream):
663
 
    inner = getattr(stream, "buffer", None)
664
 
    if inner is None:
665
 
        inner = getattr(stream, "stream", stream)
666
 
    return inner
667
 
 
668
 
 
669
 
def _wrap_in_stream(stream, encoding=None, errors='replace'):
670
 
    if encoding is None:
671
 
        encoding = _get_stream_encoding(stream)
672
 
    # Attempt to wrap using io.open if possible, since that can do
673
 
    # line-buffering.
674
 
    try:
675
 
        fileno = stream.fileno()
676
 
    except io.UnsupportedOperation:
677
 
        encoded_stream = codecs.getreader(encoding)(stream, errors=errors)
678
 
        encoded_stream.encoding = encoding
679
 
        return encoded_stream
680
 
    else:
681
 
        return io.open(fileno, encoding=encoding, errors=errors, mode='r', buffering=1)
682
 
 
683
 
 
684
 
def _wrap_out_stream(stream, encoding=None, errors='replace'):
685
 
    if encoding is None:
686
 
        encoding = _get_stream_encoding(stream)
687
 
    encoded_stream = codecs.getwriter(encoding)(stream, errors=errors)
688
 
    encoded_stream.encoding = encoding
689
 
    return encoded_stream
690
 
 
691
 
 
692
483
class TextUIOutputStream(object):
693
 
    """Decorates stream to interact better with progress and change encoding.
694
 
 
695
 
    Before writing to the wrapped stream, progress is cleared. Callers must
696
 
    ensure bulk output is terminated with a newline so progress won't overwrite
697
 
    partial lines.
698
 
 
699
 
    Additionally, the encoding and errors behaviour of the underlying stream
700
 
    can be changed at this point. If errors is set to 'exact' raw bytes may be
701
 
    written to the underlying stream.
 
484
    """Decorates an output stream so that the terminal is cleared before writing.
 
485
 
 
486
    This is supposed to ensure that the progress bar does not conflict with bulk
 
487
    text output.
702
488
    """
703
 
 
704
 
    def __init__(self, ui_factory, stream, encoding=None, errors='strict'):
 
489
    # XXX: this does not handle the case of writing part of a line, then doing
 
490
    # progress bar output: the progress bar will probably write over it.
 
491
    # one option is just to buffer that text until we have a full line;
 
492
    # another is to save and restore it
 
493
 
 
494
    # XXX: might need to wrap more methods
 
495
 
 
496
    def __init__(self, ui_factory, wrapped_stream):
705
497
        self.ui_factory = ui_factory
706
 
        # GZ 2017-05-21: Clean up semantics when callers are made saner.
707
 
        inner = _unwrap_stream(stream)
708
 
        self.raw_stream = None
709
 
        if errors == "exact":
710
 
            errors = "strict"
711
 
            self.raw_stream = inner
712
 
        if inner is None:
713
 
            self.wrapped_stream = stream
714
 
            if encoding is None:
715
 
                encoding = _get_stream_encoding(stream)
716
 
        else:
717
 
            self.wrapped_stream = _wrap_out_stream(inner, encoding, errors)
718
 
            if encoding is None:
719
 
                encoding = self.wrapped_stream.encoding
720
 
        self.encoding = encoding
721
 
        self.errors = errors
722
 
 
723
 
    def _write(self, to_write):
724
 
        if isinstance(to_write, bytes):
725
 
            try:
726
 
                to_write = to_write.decode(self.encoding, self.errors)
727
 
            except UnicodeDecodeError:
728
 
                self.raw_stream.write(to_write)
729
 
                return
730
 
        self.wrapped_stream.write(to_write)
 
498
        self.wrapped_stream = wrapped_stream
 
499
        # this does no transcoding, but it must expose the underlying encoding
 
500
        # because some callers need to know what can be written - see for
 
501
        # example unescape_for_display.
 
502
        self.encoding = getattr(wrapped_stream, 'encoding', None)
731
503
 
732
504
    def flush(self):
733
505
        self.ui_factory.clear_term()
735
507
 
736
508
    def write(self, to_write):
737
509
        self.ui_factory.clear_term()
738
 
        self._write(to_write)
 
510
        self.wrapped_stream.write(to_write)
739
511
 
740
512
    def writelines(self, lines):
741
513
        self.ui_factory.clear_term()
742
 
        for line in lines:
743
 
            self._write(line)
 
514
        self.wrapped_stream.writelines(lines)