/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 breezy/ui/text.py

  • Committer: Martin
  • Date: 2018-06-30 23:39:17 UTC
  • mto: This revision was merged to the branch mainline in revision 7013.
  • Revision ID: gzlist@googlemail.com-20180630233917-4lh8na2wist64hab
Make replacement for lazy import tests less dodgy

Should fix tests that fail under CI but seem to pass locally by not
doing an unsafe replacement of the __import__ builtin. Instead alias
it at the module level for replacement in testing.

Show diffs side-by-side

added added

removed removed

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