/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: Martin Pool
  • Date: 2009-11-16 02:56:34 UTC
  • mto: This revision was merged to the branch mainline in revision 4880.
  • Revision ID: mbp@sourcefrog.net-20091116025634-lxfe18oxvti3qe6e
Add TextUIOutputStream.flush

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/ui/text.py
 
1
# Copyright (C) 2005, 2008, 2009 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
 
 
18
"""Text UI, write output to the console.
 
19
"""
 
20
 
 
21
import codecs
 
22
import getpass
 
23
import os
 
24
import sys
 
25
import time
 
26
import warnings
 
27
 
 
28
from bzrlib.lazy_import import lazy_import
 
29
lazy_import(globals(), """
 
30
from bzrlib import (
 
31
    debug,
 
32
    progress,
 
33
    osutils,
 
34
    symbol_versioning,
 
35
    )
 
36
 
 
37
""")
 
38
 
 
39
from bzrlib.ui import (
 
40
    UIFactory,
 
41
    NullProgressView,
 
42
    )
 
43
 
 
44
 
 
45
class TextUIFactory(UIFactory):
 
46
    """A UI factory for Text user interefaces."""
 
47
 
 
48
    def __init__(self,
 
49
                 stdin=None,
 
50
                 stdout=None,
 
51
                 stderr=None):
 
52
        """Create a TextUIFactory.
 
53
        """
 
54
        super(TextUIFactory, self).__init__()
 
55
        # TODO: there's no good reason not to pass all three streams, maybe we
 
56
        # should deprecate the default values...
 
57
        self.stdin = stdin
 
58
        self.stdout = stdout
 
59
        self.stderr = stderr
 
60
        # paints progress, network activity, etc
 
61
        self._progress_view = self.make_progress_view()
 
62
        
 
63
    def clear_term(self):
 
64
        """Prepare the terminal for output.
 
65
 
 
66
        This will, clear any progress bars, and leave the cursor at the
 
67
        leftmost position."""
 
68
        # XXX: If this is preparing to write to stdout, but that's for example
 
69
        # directed into a file rather than to the terminal, and the progress
 
70
        # bar _is_ going to the terminal, we shouldn't need
 
71
        # to clear it.  We might need to separately check for the case of
 
72
        self._progress_view.clear()
 
73
 
 
74
    def get_boolean(self, prompt):
 
75
        while True:
 
76
            self.prompt(prompt + "? [y/n]: ")
 
77
            line = self.stdin.readline().lower()
 
78
            if line in ('y\n', 'yes\n'):
 
79
                return True
 
80
            elif line in ('n\n', 'no\n'):
 
81
                return False
 
82
            elif line in ('', None):
 
83
                # end-of-file; possibly should raise an error here instead
 
84
                return None
 
85
 
 
86
    def get_non_echoed_password(self):
 
87
        isatty = getattr(self.stdin, 'isatty', None)
 
88
        if isatty is not None and isatty():
 
89
            # getpass() ensure the password is not echoed and other
 
90
            # cross-platform niceties
 
91
            password = getpass.getpass('')
 
92
        else:
 
93
            # echo doesn't make sense without a terminal
 
94
            password = self.stdin.readline()
 
95
            if not password:
 
96
                password = None
 
97
            elif password[-1] == '\n':
 
98
                password = password[:-1]
 
99
        return password
 
100
 
 
101
    def get_password(self, prompt='', **kwargs):
 
102
        """Prompt the user for a password.
 
103
 
 
104
        :param prompt: The prompt to present the user
 
105
        :param kwargs: Arguments which will be expanded into the prompt.
 
106
                       This lets front ends display different things if
 
107
                       they so choose.
 
108
        :return: The password string, return None if the user
 
109
                 canceled the request.
 
110
        """
 
111
        prompt += ': '
 
112
        self.prompt(prompt, **kwargs)
 
113
        # There's currently no way to say 'i decline to enter a password'
 
114
        # as opposed to 'my password is empty' -- does it matter?
 
115
        return self.get_non_echoed_password()
 
116
 
 
117
    def get_username(self, prompt, **kwargs):
 
118
        """Prompt the user for a username.
 
119
 
 
120
        :param prompt: The prompt to present the user
 
121
        :param kwargs: Arguments which will be expanded into the prompt.
 
122
                       This lets front ends display different things if
 
123
                       they so choose.
 
124
        :return: The username string, return None if the user
 
125
                 canceled the request.
 
126
        """
 
127
        prompt += ': '
 
128
        self.prompt(prompt, **kwargs)
 
129
        username = self.stdin.readline()
 
130
        if not username:
 
131
            username = None
 
132
        elif username[-1] == '\n':
 
133
            username = username[:-1]
 
134
        return username
 
135
 
 
136
    def make_progress_view(self):
 
137
        """Construct and return a new ProgressView subclass for this UI.
 
138
        """
 
139
        # if the user specifically requests either text or no progress bars,
 
140
        # always do that.  otherwise, guess based on $TERM and tty presence.
 
141
        if os.environ.get('BZR_PROGRESS_BAR') == 'text':
 
142
            return TextProgressView(self.stderr)
 
143
        elif os.environ.get('BZR_PROGRESS_BAR') == 'none':
 
144
            return NullProgressView()
 
145
        elif progress._supports_progress(self.stderr):
 
146
            return TextProgressView(self.stderr)
 
147
        else:
 
148
            return NullProgressView()
 
149
 
 
150
    def _make_output_stream_explicit(self, encoding, encoding_type):
 
151
        if encoding_type == 'exact':
 
152
            # force sys.stdout to be binary stream on win32; 
 
153
            # NB: this leaves the file set in that mode; may cause problems if
 
154
            # one process tries to do binary and then text output
 
155
            if sys.platform == 'win32':
 
156
                fileno = getattr(self.stdout, 'fileno', None)
 
157
                if fileno:
 
158
                    import msvcrt
 
159
                    msvcrt.setmode(fileno(), os.O_BINARY)
 
160
            return TextUIOutputStream(self, self.stdout)
 
161
        else:
 
162
            encoded_stdout = codecs.getwriter(encoding)(self.stdout,
 
163
                errors=encoding_type)
 
164
            return TextUIOutputStream(self, encoded_stdout)
 
165
 
 
166
    def note(self, msg):
 
167
        """Write an already-formatted message, clearing the progress bar if necessary."""
 
168
        self.clear_term()
 
169
        self.stdout.write(msg + '\n')
 
170
 
 
171
    def prompt(self, prompt, **kwargs):
 
172
        """Emit prompt on the CLI.
 
173
        
 
174
        :param kwargs: Dictionary of arguments to insert into the prompt,
 
175
            to allow UIs to reformat the prompt.
 
176
        """
 
177
        if kwargs:
 
178
            # See <https://launchpad.net/bugs/365891>
 
179
            prompt = prompt % kwargs
 
180
        prompt = prompt.encode(osutils.get_terminal_encoding(), 'replace')
 
181
        self.clear_term()
 
182
        self.stderr.write(prompt)
 
183
 
 
184
    def report_transport_activity(self, transport, byte_count, direction):
 
185
        """Called by transports as they do IO.
 
186
 
 
187
        This may update a progress bar, spinner, or similar display.
 
188
        By default it does nothing.
 
189
        """
 
190
        self._progress_view.show_transport_activity(transport,
 
191
            direction, byte_count)
 
192
 
 
193
    def show_error(self, msg):
 
194
        self.clear_term()
 
195
        self.stderr.write("bzr: error: %s\n" % msg)
 
196
 
 
197
    def show_message(self, msg):
 
198
        self.note(msg)
 
199
 
 
200
    def show_warning(self, msg):
 
201
        self.clear_term()
 
202
        self.stderr.write("bzr: warning: %s\n" % msg)
 
203
 
 
204
    def _progress_updated(self, task):
 
205
        """A task has been updated and wants to be displayed.
 
206
        """
 
207
        if not self._task_stack:
 
208
            warnings.warn("%r updated but no tasks are active" %
 
209
                (task,))
 
210
        elif task != self._task_stack[-1]:
 
211
            warnings.warn("%r is not the top progress task %r" %
 
212
                (task, self._task_stack[-1]))
 
213
        self._progress_view.show_progress(task)
 
214
 
 
215
    def _progress_all_finished(self):
 
216
        self._progress_view.clear()
 
217
 
 
218
 
 
219
class TextProgressView(object):
 
220
    """Display of progress bar and other information on a tty.
 
221
 
 
222
    This shows one line of text, including possibly a network indicator, spinner,
 
223
    progress bar, message, etc.
 
224
 
 
225
    One instance of this is created and held by the UI, and fed updates when a
 
226
    task wants to be painted.
 
227
 
 
228
    Transports feed data to this through the ui_factory object.
 
229
 
 
230
    The Progress views can comprise a tree with _parent_task pointers, but
 
231
    this only prints the stack from the nominated current task up to the root.
 
232
    """
 
233
 
 
234
    def __init__(self, term_file):
 
235
        self._term_file = term_file
 
236
        # true when there's output on the screen we may need to clear
 
237
        self._have_output = False
 
238
        # XXX: We could listen for SIGWINCH and update the terminal width...
 
239
        # https://launchpad.net/bugs/316357
 
240
        self._width = osutils.terminal_width()
 
241
        self._last_transport_msg = ''
 
242
        self._spin_pos = 0
 
243
        # time we last repainted the screen
 
244
        self._last_repaint = 0
 
245
        # time we last got information about transport activity
 
246
        self._transport_update_time = 0
 
247
        self._last_task = None
 
248
        self._total_byte_count = 0
 
249
        self._bytes_since_update = 0
 
250
        self._fraction = 0
 
251
 
 
252
    def _show_line(self, s):
 
253
        # sys.stderr.write("progress %r\n" % s)
 
254
        n = self._width - 1
 
255
        self._term_file.write('\r%-*.*s\r' % (n, n, s))
 
256
 
 
257
    def clear(self):
 
258
        if self._have_output:
 
259
            self._show_line('')
 
260
        self._have_output = False
 
261
 
 
262
    def _render_bar(self):
 
263
        # return a string for the progress bar itself
 
264
        if (self._last_task is None) or self._last_task.show_bar:
 
265
            # If there's no task object, we show space for the bar anyhow.
 
266
            # That's because most invocations of bzr will end showing progress
 
267
            # at some point, though perhaps only after doing some initial IO.
 
268
            # It looks better to draw the progress bar initially rather than
 
269
            # to have what looks like an incomplete progress bar.
 
270
            spin_str =  r'/-\|'[self._spin_pos % 4]
 
271
            self._spin_pos += 1
 
272
            cols = 20
 
273
            if self._last_task is None:
 
274
                completion_fraction = 0
 
275
                self._fraction = 0
 
276
            else:
 
277
                completion_fraction = \
 
278
                    self._last_task._overall_completion_fraction() or 0
 
279
            if (completion_fraction < self._fraction and 'progress' in
 
280
                debug.debug_flags):
 
281
                import pdb;pdb.set_trace()
 
282
            self._fraction = completion_fraction
 
283
            markers = int(round(float(cols) * completion_fraction)) - 1
 
284
            bar_str = '[' + ('#' * markers + spin_str).ljust(cols) + '] '
 
285
            return bar_str
 
286
        elif self._last_task.show_spinner:
 
287
            # The last task wanted just a spinner, no bar
 
288
            spin_str =  r'/-\|'[self._spin_pos % 4]
 
289
            self._spin_pos += 1
 
290
            return spin_str + ' '
 
291
        else:
 
292
            return ''
 
293
 
 
294
    def _format_task(self, task):
 
295
        if not task.show_count:
 
296
            s = ''
 
297
        elif task.current_cnt is not None and task.total_cnt is not None:
 
298
            s = ' %d/%d' % (task.current_cnt, task.total_cnt)
 
299
        elif task.current_cnt is not None:
 
300
            s = ' %d' % (task.current_cnt)
 
301
        else:
 
302
            s = ''
 
303
        # compose all the parent messages
 
304
        t = task
 
305
        m = task.msg
 
306
        while t._parent_task:
 
307
            t = t._parent_task
 
308
            if t.msg:
 
309
                m = t.msg + ':' + m
 
310
        return m + s
 
311
 
 
312
    def _render_line(self):
 
313
        bar_string = self._render_bar()
 
314
        if self._last_task:
 
315
            task_msg = self._format_task(self._last_task)
 
316
        else:
 
317
            task_msg = ''
 
318
        if self._last_task and not self._last_task.show_transport_activity:
 
319
            trans = ''
 
320
        else:
 
321
            trans = self._last_transport_msg
 
322
            if trans:
 
323
                trans += ' | '
 
324
        return (bar_string + trans + task_msg)
 
325
 
 
326
    def _repaint(self):
 
327
        s = self._render_line()
 
328
        self._show_line(s)
 
329
        self._have_output = True
 
330
 
 
331
    def show_progress(self, task):
 
332
        """Called by the task object when it has changed.
 
333
        
 
334
        :param task: The top task object; its parents are also included 
 
335
            by following links.
 
336
        """
 
337
        must_update = task is not self._last_task
 
338
        self._last_task = task
 
339
        now = time.time()
 
340
        if (not must_update) and (now < self._last_repaint + task.update_latency):
 
341
            return
 
342
        if now > self._transport_update_time + 10:
 
343
            # no recent activity; expire it
 
344
            self._last_transport_msg = ''
 
345
        self._last_repaint = now
 
346
        self._repaint()
 
347
 
 
348
    def show_transport_activity(self, transport, direction, byte_count):
 
349
        """Called by transports via the ui_factory, as they do IO.
 
350
 
 
351
        This may update a progress bar, spinner, or similar display.
 
352
        By default it does nothing.
 
353
        """
 
354
        # XXX: Probably there should be a transport activity model, and that
 
355
        # too should be seen by the progress view, rather than being poked in
 
356
        # here.
 
357
        if not self._have_output:
 
358
            # As a workaround for <https://launchpad.net/bugs/321935> we only
 
359
            # show transport activity when there's already a progress bar
 
360
            # shown, which time the application code is expected to know to
 
361
            # clear off the progress bar when it's going to send some other
 
362
            # output.  Eventually it would be nice to have that automatically
 
363
            # synchronized.
 
364
            return
 
365
        self._total_byte_count += byte_count
 
366
        self._bytes_since_update += byte_count
 
367
        now = time.time()
 
368
        if self._total_byte_count < 2000:
 
369
            # a little resistance at first, so it doesn't stay stuck at 0
 
370
            # while connecting...
 
371
            return
 
372
        if self._transport_update_time is None:
 
373
            self._transport_update_time = now
 
374
        elif now >= (self._transport_update_time + 0.5):
 
375
            # guard against clock stepping backwards, and don't update too
 
376
            # often
 
377
            rate = self._bytes_since_update / (now - self._transport_update_time)
 
378
            msg = ("%6dKB %5dKB/s" %
 
379
                    (self._total_byte_count>>10, int(rate)>>10,))
 
380
            self._transport_update_time = now
 
381
            self._last_repaint = now
 
382
            self._bytes_since_update = 0
 
383
            self._last_transport_msg = msg
 
384
            self._repaint()
 
385
 
 
386
 
 
387
class TextUIOutputStream(object):
 
388
    """Decorates an output stream so that the terminal is cleared before writing.
 
389
 
 
390
    This is supposed to ensure that the progress bar does not conflict with bulk
 
391
    text output.
 
392
    """
 
393
    # XXX: this does not handle the case of writing part of a line, then doing
 
394
    # progress bar output: the progress bar will probably write over it.
 
395
    # one option is just to buffer that text until we have a full line;
 
396
    # another is to save and restore it
 
397
 
 
398
    # XXX: might need to wrap more methods
 
399
 
 
400
    def __init__(self, ui_factory, wrapped_stream):
 
401
        self.ui_factory = ui_factory
 
402
        self.wrapped_stream = wrapped_stream
 
403
 
 
404
    def flush(self):
 
405
        self.ui_factory.clear_term()
 
406
        self.wrapped_stream.flush()
 
407
 
 
408
    def write(self, to_write):
 
409
        self.ui_factory.clear_term()
 
410
        self.wrapped_stream.write(to_write)
 
411
 
 
412
    def writelines(self, lines):
 
413
        self.ui_factory.clear_term()
 
414
        self.wrapped_stream.writelines(lines)