/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: Canonical.com Patch Queue Manager
  • Date: 2010-02-11 04:02:41 UTC
  • mfrom: (5017.2.2 tariff)
  • Revision ID: pqm@pqm.ubuntu.com-20100211040241-w6n021dz0uus341n
(mbp) add import-tariff tests

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:
220
66
            self.clear_term()
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):
297
153
        """Construct and return a new ProgressView subclass for this UI.
298
154
        """
299
155
        # with --quiet, never any progress view
300
 
        # <https://bugs.launchpad.net/bzr/+bug/320035>.  Otherwise if the
 
156
        # <https://bugs.edge.launchpad.net/bzr/+bug/320035>.  Otherwise if the
301
157
        # user specifically requests either text or no progress bars, always
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()"""
366
236
        """
367
237
        if not self._task_stack:
368
238
            warnings.warn("%r updated but no tasks are active" %
369
 
                          (task,))
 
239
                (task,))
370
240
        elif task != self._task_stack[-1]:
371
241
            # We used to check it was the top task, but it's hard to always
372
242
            # get this right and it's not necessarily useful: any actual
373
243
            # problems will be evident in use
374
 
            # warnings.warn("%r is not the top progress task %r" %
 
244
            #warnings.warn("%r is not the top progress task %r" %
375
245
            #     (task, self._task_stack[-1]))
376
246
            pass
377
247
        self._progress_view.show_progress(task)
379
249
    def _progress_all_finished(self):
380
250
        self._progress_view.clear()
381
251
 
382
 
    def show_user_warning(self, warning_id, **message_args):
383
 
        """Show a text message to the user.
384
 
 
385
 
        Explicitly not for warnings about bzr apis, deprecations or internals.
386
 
        """
387
 
        # eventually trace.warning should migrate here, to avoid logging and
388
 
        # be easier to test; that has a lot of test fallout so for now just
389
 
        # new code can call this
390
 
        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)
403
 
 
404
252
 
405
253
class TextProgressView(object):
406
254
    """Display of progress bar and other information on a tty.
407
255
 
408
 
    This shows one line of text, including possibly a network indicator,
409
 
    spinner, progress bar, message, etc.
 
256
    This shows one line of text, including possibly a network indicator, spinner,
 
257
    progress bar, message, etc.
410
258
 
411
259
    One instance of this is created and held by the UI, and fed updates when a
412
260
    task wants to be painted.
417
265
    this only prints the stack from the nominated current task up to the root.
418
266
    """
419
267
 
420
 
    def __init__(self, term_file, encoding=None, errors=None):
 
268
    def __init__(self, term_file):
421
269
        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
270
        # true when there's output on the screen we may need to clear
427
271
        self._have_output = False
428
272
        self._last_transport_msg = ''
437
281
        self._bytes_by_direction = {'unknown': 0, 'read': 0, 'write': 0}
438
282
        self._first_byte_time = None
439
283
        self._fraction = 0
440
 
        # force the progress bar to be off, as at the moment it doesn't
 
284
        # force the progress bar to be off, as at the moment it doesn't 
441
285
        # correspond reliably to overall command progress
442
286
        self.enable_bar = False
443
287
 
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()
 
288
    def _show_line(self, s):
 
289
        # sys.stderr.write("progress %r\n" % s)
 
290
        width = osutils.terminal_width()
454
291
        if width is not None:
455
 
            u = pad_to_width(u, width, encoding_hint=self._encoding)
456
 
        self._term_file.write('\r' + u + '\r')
 
292
            # we need one extra space for terminals that wrap on last char
 
293
            width = width - 1
 
294
            s = '%-*.*s' % (width, width, s)
 
295
        self._term_file.write('\r' + s + '\r')
457
296
 
458
297
    def clear(self):
459
298
        if self._have_output:
463
302
    def _render_bar(self):
464
303
        # return a string for the progress bar itself
465
304
        if self.enable_bar and (
466
 
                (self._last_task is None) or self._last_task.show_bar):
 
305
            (self._last_task is None) or self._last_task.show_bar):
467
306
            # If there's no task object, we show space for the bar anyhow.
468
307
            # That's because most invocations of bzr will end showing progress
469
308
            # at some point, though perhaps only after doing some initial IO.
470
309
            # It looks better to draw the progress bar initially rather than
471
310
            # to have what looks like an incomplete progress bar.
472
 
            spin_str = r'/-\|'[self._spin_pos % 4]
 
311
            spin_str =  r'/-\|'[self._spin_pos % 4]
473
312
            self._spin_pos += 1
474
313
            cols = 20
475
314
            if self._last_task is None:
479
318
                completion_fraction = \
480
319
                    self._last_task._overall_completion_fraction() or 0
481
320
            if (completion_fraction < self._fraction and 'progress' in
482
 
                    debug.debug_flags):
483
 
                debug.set_trace()
 
321
                debug.debug_flags):
 
322
                import pdb;pdb.set_trace()
484
323
            self._fraction = completion_fraction
485
324
            markers = int(round(float(cols) * completion_fraction)) - 1
486
325
            bar_str = '[' + ('#' * markers + spin_str).ljust(cols) + '] '
487
326
            return bar_str
488
327
        elif (self._last_task is None) or self._last_task.show_spinner:
489
328
            # The last task wanted just a spinner, no bar
490
 
            spin_str = r'/-\|'[self._spin_pos % 4]
 
329
            spin_str =  r'/-\|'[self._spin_pos % 4]
491
330
            self._spin_pos += 1
492
331
            return spin_str + ' '
493
332
        else:
494
333
            return ''
495
334
 
496
335
    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
336
        if not task.show_count:
502
337
            s = ''
503
338
        elif task.current_cnt is not None and task.total_cnt is not None:
513
348
            t = t._parent_task
514
349
            if t.msg:
515
350
                m = t.msg + ':' + m
516
 
        return m, s
 
351
        return m + s
517
352
 
518
353
    def _render_line(self):
519
354
        bar_string = self._render_bar()
520
355
        if self._last_task:
521
 
            task_part, counter_part = self._format_task(self._last_task)
 
356
            task_msg = self._format_task(self._last_task)
522
357
        else:
523
 
            task_part = counter_part = ''
 
358
            task_msg = ''
524
359
        if self._last_task and not self._last_task.show_transport_activity:
525
360
            trans = ''
526
361
        else:
527
362
            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
 
363
            if trans:
 
364
                trans += ' | '
 
365
        return (bar_string + trans + task_msg)
551
366
 
552
367
    def _repaint(self):
553
368
        s = self._render_line()
556
371
 
557
372
    def show_progress(self, task):
558
373
        """Called by the task object when it has changed.
559
 
 
560
 
        :param task: The top task object; its parents are also included
 
374
        
 
375
        :param task: The top task object; its parents are also included 
561
376
            by following links.
562
377
        """
563
378
        must_update = task is not self._last_task
606
421
        elif now >= (self._transport_update_time + 0.5):
607
422
            # guard against clock stepping backwards, and don't update too
608
423
            # often
609
 
            rate = (self._bytes_since_update /
610
 
                    (now - self._transport_update_time))
 
424
            rate = (self._bytes_since_update
 
425
                    / (now - self._transport_update_time))
611
426
            # using base-10 units (see HACKING.txt).
612
 
            msg = ("%6dkB %5dkB/s " %
613
 
                   (self._total_byte_count / 1000, int(rate) / 1000,))
 
427
            msg = ("%6dkB %5dkB/s" %
 
428
                    (self._total_byte_count / 1000, int(rate) / 1000,))
614
429
            self._transport_update_time = now
615
430
            self._last_repaint = now
616
431
            self._bytes_since_update = 0
633
448
                  bps / 1000.,
634
449
                  self._bytes_by_direction['read'] / 1000.,
635
450
                  self._bytes_by_direction['write'] / 1000.,
636
 
                  ))
 
451
                 ))
637
452
        if self._bytes_by_direction['unknown'] > 0:
638
453
            msg += ' u:%.0fkB)' % (
639
454
                self._bytes_by_direction['unknown'] / 1000.
650
465
            self._term_file.write(msg + '\n')
651
466
 
652
467
 
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
468
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.
 
469
    """Decorates an output stream so that the terminal is cleared before writing.
 
470
 
 
471
    This is supposed to ensure that the progress bar does not conflict with bulk
 
472
    text output.
702
473
    """
703
 
 
704
 
    def __init__(self, ui_factory, stream, encoding=None, errors='strict'):
 
474
    # XXX: this does not handle the case of writing part of a line, then doing
 
475
    # progress bar output: the progress bar will probably write over it.
 
476
    # one option is just to buffer that text until we have a full line;
 
477
    # another is to save and restore it
 
478
 
 
479
    # XXX: might need to wrap more methods
 
480
 
 
481
    def __init__(self, ui_factory, wrapped_stream):
705
482
        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)
 
483
        self.wrapped_stream = wrapped_stream
 
484
        # this does no transcoding, but it must expose the underlying encoding
 
485
        # because some callers need to know what can be written - see for
 
486
        # example unescape_for_display.
 
487
        self.encoding = getattr(wrapped_stream, 'encoding', None)
731
488
 
732
489
    def flush(self):
733
490
        self.ui_factory.clear_term()
735
492
 
736
493
    def write(self, to_write):
737
494
        self.ui_factory.clear_term()
738
 
        self._write(to_write)
 
495
        self.wrapped_stream.write(to_write)
739
496
 
740
497
    def writelines(self, lines):
741
498
        self.ui_factory.clear_term()
742
 
        for line in lines:
743
 
            self._write(line)
 
499
        self.wrapped_stream.writelines(lines)