/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: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2018-11-16 18:26:22 UTC
  • mfrom: (7167.1.4 run-flake8)
  • Revision ID: breezy.the.bot@gmail.com-20181116182622-qw3gan3hz78a2imw
Add a flake8 test.

Merged from https://code.launchpad.net/~jelmer/brz/run-flake8/+merge/358902

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 == getattr(sys.stdin, 'buffer', 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)
 
335
        self.stderr.flush()
211
336
 
212
337
    def report_transport_activity(self, transport, byte_count, direction):
213
338
        """Called by transports as they do IO.
262
387
        # be easier to test; that has a lot of test fallout so for now just
263
388
        # new code can call this
264
389
        if warning_id not in self.suppressed_warnings:
265
 
            self.stderr.write(self.format_user_warning(warning_id, message_args) +
266
 
                '\n')
 
390
            warning = self.format_user_warning(warning_id, message_args)
 
391
            self.stderr.write(warning + '\n')
 
392
 
 
393
 
 
394
def pad_to_width(line, width, encoding_hint='ascii'):
 
395
    """Truncate or pad unicode line to width.
 
396
 
 
397
    This is best-effort for now, and strings containing control codes or
 
398
    non-ascii text may be cut and padded incorrectly.
 
399
    """
 
400
    s = line.encode(encoding_hint, 'replace')
 
401
    return (b'%-*.*s' % (width, width, s)).decode(encoding_hint)
267
402
 
268
403
 
269
404
class TextProgressView(object):
270
405
    """Display of progress bar and other information on a tty.
271
406
 
272
 
    This shows one line of text, including possibly a network indicator, spinner,
273
 
    progress bar, message, etc.
 
407
    This shows one line of text, including possibly a network indicator,
 
408
    spinner, progress bar, message, etc.
274
409
 
275
410
    One instance of this is created and held by the UI, and fed updates when a
276
411
    task wants to be painted.
281
416
    this only prints the stack from the nominated current task up to the root.
282
417
    """
283
418
 
284
 
    def __init__(self, term_file):
 
419
    def __init__(self, term_file, encoding=None, errors=None):
285
420
        self._term_file = term_file
 
421
        if encoding is None:
 
422
            self._encoding = getattr(term_file, "encoding", None) or "ascii"
 
423
        else:
 
424
            self._encoding = encoding
286
425
        # true when there's output on the screen we may need to clear
287
426
        self._have_output = False
288
427
        self._last_transport_msg = ''
297
436
        self._bytes_by_direction = {'unknown': 0, 'read': 0, 'write': 0}
298
437
        self._first_byte_time = None
299
438
        self._fraction = 0
300
 
        # force the progress bar to be off, as at the moment it doesn't 
 
439
        # force the progress bar to be off, as at the moment it doesn't
301
440
        # correspond reliably to overall command progress
302
441
        self.enable_bar = False
303
442
 
304
 
    def _show_line(self, s):
305
 
        # sys.stderr.write("progress %r\n" % s)
306
 
        width = osutils.terminal_width()
 
443
    def _avail_width(self):
 
444
        # we need one extra space for terminals that wrap on last char
 
445
        w = osutils.terminal_width()
 
446
        if w is None:
 
447
            return None
 
448
        else:
 
449
            return w - 1
 
450
 
 
451
    def _show_line(self, u):
 
452
        width = self._avail_width()
307
453
        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')
 
454
            u = pad_to_width(u, width, encoding_hint=self._encoding)
 
455
        self._term_file.write('\r' + u + '\r')
312
456
 
313
457
    def clear(self):
314
458
        if self._have_output:
335
479
                    self._last_task._overall_completion_fraction() or 0
336
480
            if (completion_fraction < self._fraction and 'progress' in
337
481
                debug.debug_flags):
338
 
                import pdb;pdb.set_trace()
 
482
                debug.set_trace()
339
483
            self._fraction = completion_fraction
340
484
            markers = int(round(float(cols) * completion_fraction)) - 1
341
485
            bar_str = '[' + ('#' * markers + spin_str).ljust(cols) + '] '
349
493
            return ''
350
494
 
351
495
    def _format_task(self, task):
 
496
        """Format task-specific parts of progress bar.
 
497
 
 
498
        :returns: (text_part, counter_part) both unicode strings.
 
499
        """
352
500
        if not task.show_count:
353
501
            s = ''
354
502
        elif task.current_cnt is not None and task.total_cnt is not None:
364
512
            t = t._parent_task
365
513
            if t.msg:
366
514
                m = t.msg + ':' + m
367
 
        return m + s
 
515
        return m, s
368
516
 
369
517
    def _render_line(self):
370
518
        bar_string = self._render_bar()
371
519
        if self._last_task:
372
 
            task_msg = self._format_task(self._last_task)
 
520
            task_part, counter_part = self._format_task(self._last_task)
373
521
        else:
374
 
            task_msg = ''
 
522
            task_part = counter_part = ''
375
523
        if self._last_task and not self._last_task.show_transport_activity:
376
524
            trans = ''
377
525
        else:
378
526
            trans = self._last_transport_msg
379
 
            if trans:
380
 
                trans += ' | '
381
 
        return (bar_string + trans + task_msg)
 
527
        # the bar separates the transport activity from the message, so even
 
528
        # if there's no bar or spinner, we must show something if both those
 
529
        # fields are present
 
530
        if (task_part or trans) and not bar_string:
 
531
            bar_string = '| '
 
532
        # preferentially truncate the task message if we don't have enough
 
533
        # space
 
534
        avail_width = self._avail_width()
 
535
        if avail_width is not None:
 
536
            # if terminal avail_width is unknown, don't truncate
 
537
            current_len = len(bar_string) + len(trans) + len(task_part) + len(counter_part)
 
538
            # GZ 2017-04-22: Should measure and truncate task_part properly
 
539
            gap = current_len - avail_width
 
540
            if gap > 0:
 
541
                task_part = task_part[:-gap-2] + '..'
 
542
        s = trans + bar_string + task_part + counter_part
 
543
        if avail_width is not None:
 
544
            if len(s) < avail_width:
 
545
                s = s.ljust(avail_width)
 
546
            elif len(s) > avail_width:
 
547
                s = s[:avail_width]
 
548
        return s
382
549
 
383
550
    def _repaint(self):
384
551
        s = self._render_line()
387
554
 
388
555
    def show_progress(self, task):
389
556
        """Called by the task object when it has changed.
390
 
        
391
 
        :param task: The top task object; its parents are also included 
 
557
 
 
558
        :param task: The top task object; its parents are also included
392
559
            by following links.
393
560
        """
394
561
        must_update = task is not self._last_task
440
607
            rate = (self._bytes_since_update
441
608
                    / (now - self._transport_update_time))
442
609
            # using base-10 units (see HACKING.txt).
443
 
            msg = ("%6dkB %5dkB/s" %
 
610
            msg = ("%6dkB %5dkB/s " %
444
611
                    (self._total_byte_count / 1000, int(rate) / 1000,))
445
612
            self._transport_update_time = now
446
613
            self._last_repaint = now
481
648
            self._term_file.write(msg + '\n')
482
649
 
483
650
 
 
651
def _get_stream_encoding(stream):
 
652
    encoding = config.GlobalStack().get('output_encoding')
 
653
    if encoding is None:
 
654
        encoding = getattr(stream, "encoding", None)
 
655
    if encoding is None:
 
656
        encoding = osutils.get_terminal_encoding(trace=True)
 
657
    return encoding
 
658
 
 
659
 
 
660
def _unwrap_stream(stream):
 
661
    inner = getattr(stream, "buffer", None)
 
662
    if inner is None:
 
663
        inner = getattr(stream, "stream", stream)
 
664
    return inner
 
665
 
 
666
 
 
667
def _wrap_in_stream(stream, encoding=None, errors='replace'):
 
668
    if encoding is None:
 
669
        encoding = _get_stream_encoding(stream)
 
670
    encoded_stream = codecs.getreader(encoding)(stream, errors=errors)
 
671
    encoded_stream.encoding = encoding
 
672
    return encoded_stream
 
673
 
 
674
 
 
675
def _wrap_out_stream(stream, encoding=None, errors='replace'):
 
676
    if encoding is None:
 
677
        encoding = _get_stream_encoding(stream)
 
678
    encoded_stream = codecs.getwriter(encoding)(stream, errors=errors)
 
679
    encoded_stream.encoding = encoding
 
680
    return encoded_stream
 
681
 
 
682
 
484
683
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.
 
684
    """Decorates stream to interact better with progress and change encoding.
 
685
 
 
686
    Before writing to the wrapped stream, progress is cleared. Callers must
 
687
    ensure bulk output is terminated with a newline so progress won't overwrite
 
688
    partial lines.
 
689
 
 
690
    Additionally, the encoding and errors behaviour of the underlying stream
 
691
    can be changed at this point. If errors is set to 'exact' raw bytes may be
 
692
    written to the underlying stream.
489
693
    """
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):
 
694
 
 
695
    def __init__(self, ui_factory, stream, encoding=None, errors='strict'):
498
696
        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)
 
697
        # GZ 2017-05-21: Clean up semantics when callers are made saner.
 
698
        inner = _unwrap_stream(stream)
 
699
        self.raw_stream = None
 
700
        if errors == "exact":
 
701
            errors = "strict"
 
702
            self.raw_stream = inner
 
703
        if inner is None:
 
704
            self.wrapped_stream = stream
 
705
            if encoding is None:
 
706
                encoding = _get_stream_encoding(stream)
 
707
        else:
 
708
            self.wrapped_stream = _wrap_out_stream(inner, encoding, errors)
 
709
            if encoding is None:
 
710
                encoding = self.wrapped_stream.encoding
 
711
        self.encoding = encoding
 
712
        self.errors = errors
 
713
 
 
714
    def _write(self, to_write):
 
715
        if isinstance(to_write, bytes):
 
716
            try:
 
717
                to_write = to_write.decode(self.encoding, self.errors)
 
718
            except UnicodeDecodeError:
 
719
                self.raw_stream.write(to_write)
 
720
                return
 
721
        self.wrapped_stream.write(to_write)
504
722
 
505
723
    def flush(self):
506
724
        self.ui_factory.clear_term()
508
726
 
509
727
    def write(self, to_write):
510
728
        self.ui_factory.clear_term()
511
 
        self.wrapped_stream.write(to_write)
 
729
        self._write(to_write)
512
730
 
513
731
    def writelines(self, lines):
514
732
        self.ui_factory.clear_term()
515
 
        self.wrapped_stream.writelines(lines)
 
733
        for line in lines:
 
734
            self._write(line)