~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/ui/text.py

merge 2.0 branch rev 4647

Show diffs side-by-side

added added

removed removed

Lines of Context:
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
 
18
 
 
19
18
"""Text UI, write output to the console.
20
19
"""
21
20
 
 
21
import getpass
 
22
import os
22
23
import sys
23
24
import time
24
25
import warnings
26
27
from bzrlib.lazy_import import lazy_import
27
28
lazy_import(globals(), """
28
29
from bzrlib import (
 
30
    debug,
29
31
    progress,
30
32
    osutils,
31
33
    symbol_versioning,
33
35
 
34
36
""")
35
37
 
36
 
from bzrlib.ui import CLIUIFactory
37
 
 
38
 
 
39
 
class TextUIFactory(CLIUIFactory):
 
38
from bzrlib.ui import (
 
39
    UIFactory,
 
40
    NullProgressView,
 
41
    )
 
42
 
 
43
 
 
44
class TextUIFactory(UIFactory):
40
45
    """A UI factory for Text user interefaces."""
41
46
 
42
47
    def __init__(self,
43
 
                 bar_type=None,
44
48
                 stdin=None,
45
49
                 stdout=None,
46
50
                 stderr=None):
47
51
        """Create a TextUIFactory.
48
52
 
49
 
        :param bar_type: The type of progress bar to create. It defaults to
50
 
                         letting the bzrlib.progress.ProgressBar factory auto
51
 
                         select.   Deprecated.
 
53
        :param bar_type: The type of progress bar to create.  Deprecated
 
54
            and ignored; a TextProgressView is always used.
52
55
        """
53
 
        super(TextUIFactory, self).__init__(stdin=stdin,
54
 
                stdout=stdout, stderr=stderr)
55
 
        if bar_type:
56
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 11, 0))
57
 
                % "bar_type parameter")
 
56
        super(TextUIFactory, self).__init__()
 
57
        # TODO: there's no good reason not to pass all three streams, maybe we
 
58
        # should deprecate the default values...
 
59
        self.stdin = stdin
 
60
        self.stdout = stdout
 
61
        self.stderr = stderr
58
62
        # paints progress, network activity, etc
59
 
        self._progress_view = TextProgressView(self.stderr)
60
 
 
 
63
        self._progress_view = self.make_progress_view()
 
64
        
61
65
    def clear_term(self):
62
66
        """Prepare the terminal for output.
63
67
 
69
73
        # to clear it.  We might need to separately check for the case of
70
74
        self._progress_view.clear()
71
75
 
 
76
    def get_boolean(self, prompt):
 
77
        while True:
 
78
            self.prompt(prompt + "? [y/n]: ")
 
79
            line = self.stdin.readline().lower()
 
80
            if line in ('y\n', 'yes\n'):
 
81
                return True
 
82
            elif line in ('n\n', 'no\n'):
 
83
                return False
 
84
            elif line in ('', None):
 
85
                # end-of-file; possibly should raise an error here instead
 
86
                return None
 
87
 
 
88
    def get_non_echoed_password(self):
 
89
        isatty = getattr(self.stdin, 'isatty', None)
 
90
        if isatty is not None and isatty():
 
91
            # getpass() ensure the password is not echoed and other
 
92
            # cross-platform niceties
 
93
            password = getpass.getpass('')
 
94
        else:
 
95
            # echo doesn't make sense without a terminal
 
96
            password = self.stdin.readline()
 
97
            if not password:
 
98
                password = None
 
99
            elif password[-1] == '\n':
 
100
                password = password[:-1]
 
101
        return password
 
102
 
 
103
    def get_password(self, prompt='', **kwargs):
 
104
        """Prompt the user for a password.
 
105
 
 
106
        :param prompt: The prompt to present the user
 
107
        :param kwargs: Arguments which will be expanded into the prompt.
 
108
                       This lets front ends display different things if
 
109
                       they so choose.
 
110
        :return: The password string, return None if the user
 
111
                 canceled the request.
 
112
        """
 
113
        prompt += ': '
 
114
        self.prompt(prompt, **kwargs)
 
115
        # There's currently no way to say 'i decline to enter a password'
 
116
        # as opposed to 'my password is empty' -- does it matter?
 
117
        return self.get_non_echoed_password()
 
118
 
 
119
    def get_username(self, prompt, **kwargs):
 
120
        """Prompt the user for a username.
 
121
 
 
122
        :param prompt: The prompt to present the user
 
123
        :param kwargs: Arguments which will be expanded into the prompt.
 
124
                       This lets front ends display different things if
 
125
                       they so choose.
 
126
        :return: The username string, return None if the user
 
127
                 canceled the request.
 
128
        """
 
129
        prompt += ': '
 
130
        self.prompt(prompt, **kwargs)
 
131
        username = self.stdin.readline()
 
132
        if not username:
 
133
            username = None
 
134
        elif username[-1] == '\n':
 
135
            username = username[:-1]
 
136
        return username
 
137
 
 
138
    def make_progress_view(self):
 
139
        """Construct and return a new ProgressView subclass for this UI.
 
140
        """
 
141
        # if the user specifically requests either text or no progress bars,
 
142
        # always do that.  otherwise, guess based on $TERM and tty presence.
 
143
        if os.environ.get('BZR_PROGRESS_BAR') == 'text':
 
144
            return TextProgressView(self.stderr)
 
145
        elif os.environ.get('BZR_PROGRESS_BAR') == 'none':
 
146
            return NullProgressView()
 
147
        elif progress._supports_progress(self.stderr):
 
148
            return TextProgressView(self.stderr)
 
149
        else:
 
150
            return NullProgressView()
 
151
 
72
152
    def note(self, msg):
73
153
        """Write an already-formatted message, clearing the progress bar if necessary."""
74
154
        self.clear_term()
75
155
        self.stdout.write(msg + '\n')
76
156
 
 
157
    def prompt(self, prompt, **kwargs):
 
158
        """Emit prompt on the CLI.
 
159
        
 
160
        :param kwargs: Dictionary of arguments to insert into the prompt,
 
161
            to allow UIs to reformat the prompt.
 
162
        """
 
163
        if kwargs:
 
164
            # See <https://launchpad.net/bugs/365891>
 
165
            prompt = prompt % kwargs
 
166
        prompt = prompt.encode(osutils.get_terminal_encoding(), 'replace')
 
167
        self.clear_term()
 
168
        self.stderr.write(prompt)
 
169
 
77
170
    def report_transport_activity(self, transport, byte_count, direction):
78
171
        """Called by transports as they do IO.
79
172
 
80
173
        This may update a progress bar, spinner, or similar display.
81
174
        By default it does nothing.
82
175
        """
83
 
        self._progress_view._show_transport_activity(transport,
 
176
        self._progress_view.show_transport_activity(transport,
84
177
            direction, byte_count)
85
178
 
86
179
    def _progress_updated(self, task):
118
211
        # true when there's output on the screen we may need to clear
119
212
        self._have_output = False
120
213
        # XXX: We could listen for SIGWINCH and update the terminal width...
 
214
        # https://launchpad.net/bugs/316357
121
215
        self._width = osutils.terminal_width()
122
216
        self._last_transport_msg = ''
123
217
        self._spin_pos = 0
128
222
        self._last_task = None
129
223
        self._total_byte_count = 0
130
224
        self._bytes_since_update = 0
 
225
        self._fraction = 0
131
226
 
132
227
    def _show_line(self, s):
 
228
        # sys.stderr.write("progress %r\n" % s)
133
229
        n = self._width - 1
134
230
        self._term_file.write('\r%-*.*s\r' % (n, n, s))
135
231
 
151
247
            cols = 20
152
248
            if self._last_task is None:
153
249
                completion_fraction = 0
 
250
                self._fraction = 0
154
251
            else:
155
252
                completion_fraction = \
156
253
                    self._last_task._overall_completion_fraction() or 0
 
254
            if (completion_fraction < self._fraction and 'progress' in
 
255
                debug.debug_flags):
 
256
                import pdb;pdb.set_trace()
 
257
            self._fraction = completion_fraction
157
258
            markers = int(round(float(cols) * completion_fraction)) - 1
158
259
            bar_str = '[' + ('#' * markers + spin_str).ljust(cols) + '] '
159
260
            return bar_str
189
290
            task_msg = self._format_task(self._last_task)
190
291
        else:
191
292
            task_msg = ''
192
 
        trans = self._last_transport_msg
193
 
        if trans:
194
 
            trans += ' | '
 
293
        if self._last_task and not self._last_task.show_transport_activity:
 
294
            trans = ''
 
295
        else:
 
296
            trans = self._last_transport_msg
 
297
            if trans:
 
298
                trans += ' | '
195
299
        return (bar_string + trans + task_msg)
196
300
 
197
301
    def _repaint(self):
208
312
        must_update = task is not self._last_task
209
313
        self._last_task = task
210
314
        now = time.time()
211
 
        if (not must_update) and (now < self._last_repaint + 0.1):
 
315
        if (not must_update) and (now < self._last_repaint + task.update_latency):
212
316
            return
213
317
        if now > self._transport_update_time + 10:
214
318
            # no recent activity; expire it
216
320
        self._last_repaint = now
217
321
        self._repaint()
218
322
 
219
 
    def _show_transport_activity(self, transport, direction, byte_count):
 
323
    def show_transport_activity(self, transport, direction, byte_count):
220
324
        """Called by transports via the ui_factory, as they do IO.
221
325
 
222
326
        This may update a progress bar, spinner, or similar display.
225
329
        # XXX: Probably there should be a transport activity model, and that
226
330
        # too should be seen by the progress view, rather than being poked in
227
331
        # here.
 
332
        if not self._have_output:
 
333
            # As a workaround for <https://launchpad.net/bugs/321935> we only
 
334
            # show transport activity when there's already a progress bar
 
335
            # shown, which time the application code is expected to know to
 
336
            # clear off the progress bar when it's going to send some other
 
337
            # output.  Eventually it would be nice to have that automatically
 
338
            # synchronized.
 
339
            return
228
340
        self._total_byte_count += byte_count
229
341
        self._bytes_since_update += byte_count
230
342
        now = time.time()
 
343
        if self._total_byte_count < 2000:
 
344
            # a little resistance at first, so it doesn't stay stuck at 0
 
345
            # while connecting...
 
346
            return
231
347
        if self._transport_update_time is None:
232
348
            self._transport_update_time = now
233
349
        elif now >= (self._transport_update_time + 0.5):
234
350
            # guard against clock stepping backwards, and don't update too
235
351
            # often
236
352
            rate = self._bytes_since_update / (now - self._transport_update_time)
237
 
            scheme = getattr(transport, '_scheme', None) or repr(transport)
238
 
            if direction == 'read':
239
 
                dir_char = '>'
240
 
            elif direction == 'write':
241
 
                dir_char = '<'
242
 
            else:
243
 
                dir_char = ' '
244
 
            msg = ("%.7s %s %6dKB %5dKB/s" %
245
 
                    (scheme, dir_char, self._total_byte_count>>10, int(rate)>>10,))
 
353
            msg = ("%6dKB %5dKB/s" %
 
354
                    (self._total_byte_count>>10, int(rate)>>10,))
246
355
            self._transport_update_time = now
247
356
            self._last_repaint = now
248
357
            self._bytes_since_update = 0
249
358
            self._last_transport_msg = msg
250
359
            self._repaint()
251
 
 
252