~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/progress.py

  • Committer: Martin Pool
  • Date: 2005-07-22 18:49:46 UTC
  • Revision ID: mbp@sourcefrog.net-20050722184946-4bd334f8c0d75957
- separate out code that just scans the hash cache to find files that are possibly
  changed; don't actually re-read them unless the content has changed

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2010 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
 
"""Progress indicators.
19
 
 
20
 
The usual way to use this is via bzrlib.ui.ui_factory.nested_progress_bar which
21
 
will manage a conceptual stack of nested activities.
 
1
# Copyright (C) 2005 Aaron Bentley <aaron.bentley@utoronto.ca>
 
2
# Copyright (C) 2005 Canonical <canonical.com>
 
3
#
 
4
#    This program is free software; you can redistribute it and/or modify
 
5
#    it under the terms of the GNU General Public License as published by
 
6
#    the Free Software Foundation; either version 2 of the License, or
 
7
#    (at your option) any later version.
 
8
#
 
9
#    This program is distributed in the hope that it will be useful,
 
10
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
#    GNU General Public License for more details.
 
13
#
 
14
#    You should have received a copy of the GNU General Public License
 
15
#    along with this program; if not, write to the Free Software
 
16
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
17
 
 
18
 
 
19
"""Simple text-mode progress indicator.
 
20
 
 
21
To display an indicator, create a ProgressBar object.  Call it,
 
22
passing Progress objects indicating the current state.  When done,
 
23
call clear().
 
24
 
 
25
Progress is suppressed when output is not sent to a terminal, so as
 
26
not to clutter log files.
22
27
"""
23
28
 
 
29
# TODO: should be a global option e.g. --silent that disables progress
 
30
# indicators, preferably without needing to adjust all code that
 
31
# potentially calls them.
 
32
 
 
33
# TODO: Perhaps don't write updates faster than a certain rate, say
 
34
# 5/second.
 
35
 
 
36
# TODO: Optionally show elapsed time instead/as well as ETA; nicer
 
37
# when the rate is unpredictable
 
38
 
24
39
 
25
40
import sys
26
41
import time
27
 
import os
28
 
 
29
 
 
30
 
from bzrlib.symbol_versioning import (
31
 
    deprecated_in,
32
 
    deprecated_method,
33
 
    )
 
42
 
 
43
 
 
44
def _width():
 
45
    """Return estimated terminal width.
 
46
 
 
47
    TODO: Do something smart on Windows?
 
48
 
 
49
    TODO: Is there anything that gets a better update when the window
 
50
          is resized while the program is running?
 
51
    """
 
52
    import os
 
53
    try:
 
54
        return int(os.environ['COLUMNS'])
 
55
    except (IndexError, KeyError, ValueError):
 
56
        return 80
34
57
 
35
58
 
36
59
def _supports_progress(f):
37
 
    """Detect if we can use pretty progress bars on file F.
38
 
 
39
 
    If this returns true we expect that a human may be looking at that
40
 
    output, and that we can repaint a line to update it.
41
 
 
42
 
    This doesn't check the policy for whether we *should* use them.
43
 
    """
44
 
    isatty = getattr(f, 'isatty', None)
45
 
    if isatty is None:
46
 
        return False
47
 
    if not isatty():
48
 
        return False
49
 
    # The following case also handles Win32 - on that platform $TERM is
50
 
    # typically never set, so the case None is treated as a smart terminal,
51
 
    # not dumb.  <https://bugs.launchpad.net/bugs/334808>  win32 files do have
52
 
    # isatty methods that return true.
 
60
    if not hasattr(f, 'isatty'):
 
61
        return False
 
62
    if not f.isatty():
 
63
        return False
 
64
    import os
53
65
    if os.environ.get('TERM') == 'dumb':
54
66
        # e.g. emacs compile window
55
67
        return False
56
68
    return True
57
69
 
58
70
 
59
 
class ProgressTask(object):
60
 
    """Model component of a progress indicator.
61
 
 
62
 
    Most code that needs to indicate progress should update one of these,
63
 
    and it will in turn update the display, if one is present.
64
 
 
65
 
    Code updating the task may also set fields as hints about how to display
66
 
    it: show_pct, show_spinner, show_eta, show_count, show_bar.  UIs
67
 
    will not necessarily respect all these fields.
 
71
 
 
72
class ProgressBar(object):
 
73
    """Progress bar display object.
 
74
 
 
75
    Several options are available to control the display.  These can
 
76
    be passed as parameters to the constructor or assigned at any time:
 
77
 
 
78
    show_pct
 
79
        Show percentage complete.
 
80
    show_spinner
 
81
        Show rotating baton.  This ticks over on every update even
 
82
        if the values don't change.
 
83
    show_eta
 
84
        Show predicted time-to-completion.
 
85
    show_bar
 
86
        Show bar graph.
 
87
    show_count
 
88
        Show numerical counts.
 
89
 
 
90
    The output file should be in line-buffered or unbuffered mode.
 
91
    """
 
92
    SPIN_CHARS = r'/-\|'
 
93
    MIN_PAUSE = 0.1 # seconds
 
94
 
 
95
    start_time = None
 
96
    last_update = None
68
97
    
69
 
    :ivar update_latency: The interval (in seconds) at which the PB should be
70
 
        updated.  Setting this to zero suggests every update should be shown
71
 
        synchronously.
72
 
 
73
 
    :ivar show_transport_activity: If true (default), transport activity
74
 
        will be shown when this task is drawn.  Disable it if you're sure 
75
 
        that only irrelevant or uninteresting transport activity can occur
76
 
        during this task.
77
 
    """
78
 
 
79
 
    def __init__(self, parent_task=None, ui_factory=None, progress_view=None):
80
 
        """Construct a new progress task.
81
 
 
82
 
        :param parent_task: Enclosing ProgressTask or None.
83
 
 
84
 
        :param progress_view: ProgressView to display this ProgressTask.
85
 
 
86
 
        :param ui_factory: The UI factory that will display updates; 
87
 
            deprecated in favor of passing progress_view directly.
88
 
 
89
 
        Normally you should not call this directly but rather through
90
 
        `ui_factory.nested_progress_bar`.
91
 
        """
92
 
        self._parent_task = parent_task
93
 
        self._last_update = 0
94
 
        self.total_cnt = None
95
 
        self.current_cnt = None
96
 
        self.msg = ''
97
 
        # TODO: deprecate passing ui_factory
98
 
        self.ui_factory = ui_factory
99
 
        self.progress_view = progress_view
100
 
        self.show_pct = False
101
 
        self.show_spinner = True
102
 
        self.show_eta = False,
103
 
        self.show_count = True
104
 
        self.show_bar = True
105
 
        self.update_latency = 0.1
106
 
        self.show_transport_activity = True
107
 
 
108
 
    def __repr__(self):
109
 
        return '%s(%r/%r, msg=%r)' % (
110
 
            self.__class__.__name__,
111
 
            self.current_cnt,
112
 
            self.total_cnt,
113
 
            self.msg)
114
 
 
115
 
    def update(self, msg, current_cnt=None, total_cnt=None):
116
 
        self.msg = msg
117
 
        self.current_cnt = current_cnt
118
 
        if total_cnt:
119
 
            self.total_cnt = total_cnt
120
 
        if self.progress_view:
121
 
            self.progress_view.show_progress(self)
122
 
        else:
123
 
            self.ui_factory._progress_updated(self)
124
 
 
125
 
    def tick(self):
126
 
        self.update(self.msg)
127
 
 
128
 
    def finished(self):
129
 
        if self.progress_view:
130
 
            self.progress_view.task_finished(self)
131
 
        else:
132
 
            self.ui_factory._progress_finished(self)
133
 
 
134
 
    def make_sub_task(self):
135
 
        return ProgressTask(self, ui_factory=self.ui_factory,
136
 
            progress_view=self.progress_view)
137
 
 
138
 
    def _overall_completion_fraction(self, child_fraction=0.0):
139
 
        """Return fractional completion of this task and its parents
140
 
 
141
 
        Returns None if no completion can be computed."""
142
 
        if self.current_cnt is not None and self.total_cnt:
143
 
            own_fraction = (float(self.current_cnt) + child_fraction) / self.total_cnt
144
 
        else:
145
 
            # if this task has no estimation, it just passes on directly
146
 
            # whatever the child has measured...
147
 
            own_fraction = child_fraction
148
 
        if self._parent_task is None:
149
 
            return own_fraction
150
 
        else:
151
 
            if own_fraction is None:
152
 
                own_fraction = 0.0
153
 
            return self._parent_task._overall_completion_fraction(own_fraction)
154
 
 
155
 
    @deprecated_method(deprecated_in((2, 1, 0)))
156
 
    def note(self, fmt_string, *args):
157
 
        """Record a note without disrupting the progress bar.
158
 
        
159
 
        Deprecated: use ui_factory.note() instead or bzrlib.trace.  Note that
160
 
        ui_factory.note takes just one string as the argument, not a format
161
 
        string and arguments.
162
 
        """
163
 
        if args:
164
 
            self.ui_factory.note(fmt_string % args)
165
 
        else:
166
 
            self.ui_factory.note(fmt_string)
167
 
 
168
 
    def clear(self):
169
 
        # TODO: deprecate this method; the model object shouldn't be concerned
170
 
        # with whether it's shown or not.  Most callers use this because they
171
 
        # want to write some different non-progress output to the screen, but
172
 
        # they should probably instead use a stream that's synchronized with
173
 
        # the progress output.  It may be there is a model-level use for
174
 
        # saying "this task's not active at the moment" but I don't see it. --
175
 
        # mbp 20090623
176
 
        if self.progress_view:
177
 
            self.progress_view.clear()
178
 
        else:
179
 
            self.ui_factory.clear_term()
180
 
 
181
 
 
182
 
# NOTE: This is also deprecated; you should provide a ProgressView instead.
183
 
class _BaseProgressBar(object):
184
 
 
185
98
    def __init__(self,
186
 
                 to_file=None,
 
99
                 to_file=sys.stderr,
187
100
                 show_pct=False,
188
101
                 show_spinner=False,
189
 
                 show_eta=False,
 
102
                 show_eta=True,
190
103
                 show_bar=True,
191
 
                 show_count=True,
192
 
                 to_messages_file=None,
193
 
                 _stack=None):
 
104
                 show_count=True):
194
105
        object.__init__(self)
195
 
        if to_file is None:
196
 
            to_file = sys.stderr
197
 
        if to_messages_file is None:
198
 
            to_messages_file = sys.stdout
199
106
        self.to_file = to_file
200
 
        self.to_messages_file = to_messages_file
 
107
        self.suppressed = not _supports_progress(self.to_file)
 
108
        self.spin_pos = 0
 
109
 
201
110
        self.last_msg = None
202
111
        self.last_cnt = None
203
112
        self.last_total = None
206
115
        self.show_eta = show_eta
207
116
        self.show_bar = show_bar
208
117
        self.show_count = show_count
209
 
        self._stack = _stack
210
 
        # seed throttler
211
 
        self.MIN_PAUSE = 0.1 # seconds
 
118
 
 
119
        self.width = _width()
 
120
        
 
121
 
 
122
    def tick(self):
 
123
        self.update(self.last_msg, self.last_cnt, self.last_total)
 
124
                 
 
125
 
 
126
 
 
127
    def update(self, msg, current_cnt=None, total_cnt=None):
 
128
        """Update and redraw progress bar."""
 
129
        if self.suppressed:
 
130
            return
 
131
 
 
132
        # save these for the tick() function
 
133
        self.last_msg = msg
 
134
        self.last_cnt = current_cnt
 
135
        self.last_total = total_cnt
 
136
            
212
137
        now = time.time()
213
 
        # starting now
214
 
        self.start_time = now
215
 
        # next update should not throttle
216
 
        self.last_update = now - self.MIN_PAUSE - 1
217
 
 
218
 
    def finished(self):
219
 
        """Return this bar to its progress stack."""
220
 
        self.clear()
221
 
        self._stack.return_pb(self)
222
 
 
223
 
    def note(self, fmt_string, *args, **kwargs):
224
 
        """Record a note without disrupting the progress bar."""
225
 
        self.clear()
226
 
        self.to_messages_file.write(fmt_string % args)
227
 
        self.to_messages_file.write('\n')
228
 
 
229
 
 
230
 
class DummyProgress(object):
231
 
    """Progress-bar standin that does nothing.
232
 
 
233
 
    This was previously often constructed by application code if no progress
234
 
    bar was explicitly passed in.  That's no longer recommended: instead, just
235
 
    create a progress task from the ui_factory.  This class can be used in
236
 
    test code that needs to fake a progress task for some reason.
237
 
    """
238
 
 
239
 
    def tick(self):
240
 
        pass
241
 
 
242
 
    def update(self, msg=None, current=None, total=None):
243
 
        pass
244
 
 
245
 
    def child_update(self, message, current, total):
246
 
        pass
 
138
        if self.start_time is None:
 
139
            self.start_time = now
 
140
        else:
 
141
            interval = now - self.last_update
 
142
            if interval > 0 and interval < self.MIN_PAUSE:
 
143
                return
 
144
 
 
145
        self.last_update = now
 
146
        
 
147
        if total_cnt:
 
148
            assert current_cnt <= total_cnt
 
149
        if current_cnt:
 
150
            assert current_cnt >= 0
 
151
        
 
152
        if self.show_eta and self.start_time and total_cnt:
 
153
            eta = get_eta(self.start_time, current_cnt, total_cnt)
 
154
            eta_str = " " + str_tdelta(eta)
 
155
        else:
 
156
            eta_str = ""
 
157
 
 
158
        if self.show_spinner:
 
159
            spin_str = self.SPIN_CHARS[self.spin_pos % 4] + ' '            
 
160
        else:
 
161
            spin_str = ''
 
162
 
 
163
        # always update this; it's also used for the bar
 
164
        self.spin_pos += 1
 
165
 
 
166
        if self.show_pct and total_cnt and current_cnt:
 
167
            pct = 100.0 * current_cnt / total_cnt
 
168
            pct_str = ' (%5.1f%%)' % pct
 
169
        else:
 
170
            pct_str = ''
 
171
 
 
172
        if not self.show_count:
 
173
            count_str = ''
 
174
        elif current_cnt is None:
 
175
            count_str = ''
 
176
        elif total_cnt is None:
 
177
            count_str = ' %i' % (current_cnt)
 
178
        else:
 
179
            # make both fields the same size
 
180
            t = '%i' % (total_cnt)
 
181
            c = '%*i' % (len(t), current_cnt)
 
182
            count_str = ' ' + c + '/' + t 
 
183
 
 
184
        if self.show_bar:
 
185
            # progress bar, if present, soaks up all remaining space
 
186
            cols = self.width - 1 - len(msg) - len(spin_str) - len(pct_str) \
 
187
                   - len(eta_str) - len(count_str) - 3
 
188
 
 
189
            if total_cnt:
 
190
                # number of markers highlighted in bar
 
191
                markers = int(round(float(cols) * current_cnt / total_cnt))
 
192
                bar_str = '[' + ('=' * markers).ljust(cols) + '] '
 
193
            elif False:
 
194
                # don't know total, so can't show completion.
 
195
                # so just show an expanded spinning thingy
 
196
                m = self.spin_pos % cols
 
197
                ms = (' ' * m + '*').ljust(cols)
 
198
                
 
199
                bar_str = '[' + ms + '] '
 
200
            else:
 
201
                bar_str = ''
 
202
        else:
 
203
            bar_str = ''
 
204
 
 
205
        m = spin_str + bar_str + msg + count_str + pct_str + eta_str
 
206
 
 
207
        assert len(m) < self.width
 
208
        self.to_file.write('\r' + m.ljust(self.width - 1))
 
209
        #self.to_file.flush()
 
210
            
247
211
 
248
212
    def clear(self):
249
 
        pass
250
 
 
251
 
    def note(self, fmt_string, *args, **kwargs):
252
 
        """See _BaseProgressBar.note()."""
253
 
 
254
 
    def child_progress(self, **kwargs):
255
 
        return DummyProgress(**kwargs)
256
 
 
257
 
 
 
213
        if self.suppressed:
 
214
            return
 
215
        
 
216
        self.to_file.write('\r%s\r' % (' ' * (self.width - 1)))
 
217
        #self.to_file.flush()        
 
218
    
 
219
 
 
220
        
258
221
def str_tdelta(delt):
259
222
    if delt is None:
260
223
        return "-:--:--"
264
227
                             delt % 60)
265
228
 
266
229
 
267
 
def get_eta(start_time, current, total, enough_samples=3, last_updates=None, n_recent=10):
 
230
def get_eta(start_time, current, total, enough_samples=3):
268
231
    if start_time is None:
269
232
        return None
270
233
 
281
244
 
282
245
    if elapsed < 2.0:                   # not enough time to estimate
283
246
        return None
284
 
 
 
247
    
285
248
    total_duration = float(elapsed) * float(total) / float(current)
286
249
 
287
 
    if last_updates and len(last_updates) >= n_recent:
288
 
        avg = sum(last_updates) / float(len(last_updates))
289
 
        time_left = avg * (total - current)
290
 
 
291
 
        old_time_left = total_duration - elapsed
292
 
 
293
 
        # We could return the average, or some other value here
294
 
        return (time_left + old_time_left) / 2
 
250
    assert total_duration >= elapsed
295
251
 
296
252
    return total_duration - elapsed
297
253
 
298
254
 
299
 
class ProgressPhase(object):
300
 
    """Update progress object with the current phase"""
301
 
    def __init__(self, message, total, pb):
302
 
        object.__init__(self)
303
 
        self.pb = pb
304
 
        self.message = message
305
 
        self.total = total
306
 
        self.cur_phase = None
307
 
 
308
 
    def next_phase(self):
309
 
        if self.cur_phase is None:
310
 
            self.cur_phase = 0
311
 
        else:
312
 
            self.cur_phase += 1
313
 
        self.pb.update(self.message, self.cur_phase, self.total)
 
255
def run_tests():
 
256
    import doctest
 
257
    result = doctest.testmod()
 
258
    if result[1] > 0:
 
259
        if result[0] == 0:
 
260
            print "All tests passed"
 
261
    else:
 
262
        print "No tests to run"
 
263
 
 
264
 
 
265
def demo():
 
266
    from time import sleep
 
267
    pb = ProgressBar(show_pct=True, show_bar=True, show_spinner=False)
 
268
    for i in range(100):
 
269
        pb.update('Elephanten', i, 99)
 
270
        sleep(0.1)
 
271
    sleep(2)
 
272
    pb.clear()
 
273
    sleep(1)
 
274
    print 'done!'
 
275
 
 
276
if __name__ == "__main__":
 
277
    demo()