14
13
# You should have received a copy of the GNU General Public License
15
14
# along with this program; if not, write to the Free Software
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19
"""Simple text-mode progress indicator.
21
To display an indicator, create a ProgressBar object. Call it,
22
passing Progress objects indicating the current state. When done,
25
Progress is suppressed when output is not sent to a terminal, so as
26
not to clutter log files.
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
"""Progress indicators.
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.
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.
33
# TODO: If not on a tty perhaps just print '......' for the benefit of IDEs, etc
35
# TODO: Optionally show elapsed time instead/as well as ETA; nicer
36
# when the rate is unpredictable
42
from bzrlib.lazy_import import lazy_import
43
lazy_import(globals(), """
30
from bzrlib.symbol_versioning import (
49
from bzrlib.trace import mutter
52
36
def _supports_progress(f):
53
"""Detect if we can use pretty progress bars on the output stream f.
37
"""Detect if we can use pretty progress bars on file F.
55
If this returns true we expect that a human may be looking at that
39
If this returns true we expect that a human may be looking at that
56
40
output, and that we can repaint a line to update it.
42
This doesn't check the policy for whether we *should* use them.
58
44
isatty = getattr(f, 'isatty', None)
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.
63
53
if os.environ.get('TERM') == 'dumb':
64
54
# e.g. emacs compile window
69
_progress_bar_types = {}
72
def ProgressBar(to_file=None, **kwargs):
73
"""Abstract factory"""
76
requested_bar_type = os.environ.get('BZR_PROGRESS_BAR')
77
# An value of '' or not set reverts to standard processing
78
if requested_bar_type in (None, ''):
79
if _supports_progress(to_file):
80
return TTYProgressBar(to_file=to_file, **kwargs)
82
return DummyProgress(to_file=to_file, **kwargs)
84
# Minor sanitation to prevent spurious errors
85
requested_bar_type = requested_bar_type.lower().strip()
86
# TODO: jam 20060710 Arguably we shouldn't raise an exception
87
# but should instead just disable progress bars if we
88
# don't recognize the type
89
if requested_bar_type not in _progress_bar_types:
90
raise errors.InvalidProgressBarType(requested_bar_type,
91
_progress_bar_types.keys())
92
return _progress_bar_types[requested_bar_type](to_file=to_file, **kwargs)
95
class ProgressBarStack(object):
96
"""A stack of progress bars."""
105
to_messages_file=None,
107
"""Setup the stack with the parameters the progress bars should have."""
110
if to_messages_file is None:
111
to_messages_file = sys.stdout
112
self._to_file = to_file
113
self._show_pct = show_pct
114
self._show_spinner = show_spinner
115
self._show_eta = show_eta
116
self._show_bar = show_bar
117
self._show_count = show_count
118
self._to_messages_file = to_messages_file
120
self._klass = klass or ProgressBar
123
if len(self._stack) != 0:
124
return self._stack[-1]
129
if len(self._stack) != 0:
130
return self._stack[0]
134
def get_nested(self):
135
"""Return a nested progress bar."""
136
if len(self._stack) == 0:
139
func = self.top().child_progress
140
new_bar = func(to_file=self._to_file,
141
show_pct=self._show_pct,
142
show_spinner=self._show_spinner,
143
show_eta=self._show_eta,
144
show_bar=self._show_bar,
145
show_count=self._show_count,
146
to_messages_file=self._to_messages_file,
148
self._stack.append(new_bar)
151
def return_pb(self, bar):
152
"""Return bar after its been used."""
153
if bar is not self._stack[-1]:
154
raise errors.MissingProgressBarFinish()
158
class _BaseProgressBar(object):
167
to_messages_file=None,
169
object.__init__(self)
172
if to_messages_file is None:
173
to_messages_file = sys.stdout
174
self.to_file = to_file
175
self.to_messages_file = to_messages_file
178
self.last_total = None
179
self.show_pct = show_pct
180
self.show_spinner = show_spinner
181
self.show_eta = show_eta
182
self.show_bar = show_bar
183
self.show_count = show_count
186
self.MIN_PAUSE = 0.1 # seconds
189
self.start_time = now
190
# next update should not throttle
191
self.last_update = now - self.MIN_PAUSE - 1
59
class ProgressTask(object):
60
"""Model component of a progress indicator.
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.
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.
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
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
79
def __init__(self, parent_task=None, ui_factory=None, progress_view=None):
80
"""Construct a new progress task.
82
:param parent_task: Enclosing ProgressTask or None.
84
:param progress_view: ProgressView to display this ProgressTask.
86
:param ui_factory: The UI factory that will display updates;
87
deprecated in favor of passing progress_view directly.
89
Normally you should not call this directly but rather through
90
`ui_factory.nested_progress_bar`.
92
self._parent_task = parent_task
95
self.current_cnt = None
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
105
self.update_latency = 0.1
106
self.show_transport_activity = True
109
return '%s(%r/%r, msg=%r)' % (
110
self.__class__.__name__,
115
def update(self, msg, current_cnt=None, total_cnt=None):
117
self.current_cnt = current_cnt
119
self.total_cnt = total_cnt
120
if self.progress_view:
121
self.progress_view.show_progress(self)
123
self.ui_factory._progress_updated(self)
126
self.update(self.msg)
193
128
def finished(self):
194
"""Return this bar to its progress stack."""
196
assert self._stack is not None
197
self._stack.return_pb(self)
199
def note(self, fmt_string, *args, **kwargs):
200
"""Record a note without disrupting the progress bar."""
202
self.to_messages_file.write(fmt_string % args)
203
self.to_messages_file.write('\n')
205
def child_progress(self, **kwargs):
206
return ChildProgress(**kwargs)
209
class DummyProgress(_BaseProgressBar):
129
if self.progress_view:
130
self.progress_view.task_finished(self)
132
self.ui_factory._progress_finished(self)
134
def make_sub_task(self):
135
return ProgressTask(self, ui_factory=self.ui_factory,
136
progress_view=self.progress_view)
138
def _overall_completion_fraction(self, child_fraction=0.0):
139
"""Return fractional completion of this task and its parents
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
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:
151
if own_fraction is None:
153
return self._parent_task._overall_completion_fraction(own_fraction)
156
# TODO: deprecate this method; the model object shouldn't be concerned
157
# with whether it's shown or not. Most callers use this because they
158
# want to write some different non-progress output to the screen, but
159
# they should probably instead use a stream that's synchronized with
160
# the progress output. It may be there is a model-level use for
161
# saying "this task's not active at the moment" but I don't see it. --
163
if self.progress_view:
164
self.progress_view.clear()
166
self.ui_factory.clear_term()
169
class DummyProgress(object):
210
170
"""Progress-bar standin that does nothing.
212
This can be used as the default argument for methods that
213
take an optional progress indicator."""
172
This was previously often constructed by application code if no progress
173
bar was explicitly passed in. That's no longer recommended: instead, just
174
create a progress task from the ui_factory. This class can be used in
175
test code that needs to fake a progress task for some reason.
226
def note(self, fmt_string, *args, **kwargs):
227
"""See _BaseProgressBar.note()."""
229
190
def child_progress(self, **kwargs):
230
191
return DummyProgress(**kwargs)
233
_progress_bar_types['dummy'] = DummyProgress
234
_progress_bar_types['none'] = DummyProgress
237
class DotsProgressBar(_BaseProgressBar):
239
def __init__(self, **kwargs):
240
_BaseProgressBar.__init__(self, **kwargs)
247
def update(self, msg=None, current_cnt=None, total_cnt=None):
248
if msg and msg != self.last_msg:
250
self.to_file.write('\n')
251
self.to_file.write(msg + ': ')
254
self.to_file.write('.')
258
self.to_file.write('\n')
261
def child_update(self, message, current, total):
265
_progress_bar_types['dots'] = DotsProgressBar
268
class TTYProgressBar(_BaseProgressBar):
269
"""Progress bar display object.
271
Several options are available to control the display. These can
272
be passed as parameters to the constructor or assigned at any time:
275
Show percentage complete.
277
Show rotating baton. This ticks over on every update even
278
if the values don't change.
280
Show predicted time-to-completion.
284
Show numerical counts.
286
The output file should be in line-buffered or unbuffered mode.
291
def __init__(self, **kwargs):
292
from bzrlib.osutils import terminal_width
293
_BaseProgressBar.__init__(self, **kwargs)
295
self.width = terminal_width()
296
self.last_updates = []
297
self._max_last_updates = 10
298
self.child_fraction = 0
299
self._have_output = False
302
def throttle(self, old_msg):
303
"""Return True if the bar was updated too recently"""
304
# time.time consistently takes 40/4000 ms = 0.01 ms.
305
# time.clock() is faster, but gives us CPU time, not wall-clock time
307
if self.start_time is not None and (now - self.start_time) < 1:
309
if old_msg != self.last_msg:
311
interval = now - self.last_update
313
if interval < self.MIN_PAUSE:
316
self.last_updates.append(now - self.last_update)
317
# Don't let the queue grow without bound
318
self.last_updates = self.last_updates[-self._max_last_updates:]
319
self.last_update = now
323
self.update(self.last_msg, self.last_cnt, self.last_total,
326
def child_update(self, message, current, total):
327
if current is not None and total != 0:
328
child_fraction = float(current) / total
329
if self.last_cnt is None:
331
elif self.last_cnt + child_fraction <= self.last_total:
332
self.child_fraction = child_fraction
334
mutter('not updating child fraction')
335
if self.last_msg is None:
339
def update(self, msg, current_cnt=None, total_cnt=None,
341
"""Update and redraw progress bar."""
345
if total_cnt is None:
346
total_cnt = self.last_total
351
if current_cnt > total_cnt:
352
total_cnt = current_cnt
354
## # optional corner case optimisation
355
## # currently does not seem to fire so costs more than saved.
356
## # trivial optimal case:
357
## # NB if callers are doing a clear and restore with
358
## # the saved values, this will prevent that:
359
## # in that case add a restore method that calls
360
## # _do_update or some such
361
## if (self.last_msg == msg and
362
## self.last_cnt == current_cnt and
363
## self.last_total == total_cnt and
364
## self.child_fraction == child_fraction):
367
old_msg = self.last_msg
368
# save these for the tick() function
370
self.last_cnt = current_cnt
371
self.last_total = total_cnt
372
self.child_fraction = child_fraction
374
# each function call takes 20ms/4000 = 0.005 ms,
375
# but multiple that by 4000 calls -> starts to cost.
376
# so anything to make this function call faster
377
# will improve base 'diff' time by up to 0.1 seconds.
378
if self.throttle(old_msg):
381
if self.show_eta and self.start_time and self.last_total:
382
eta = get_eta(self.start_time, self.last_cnt + self.child_fraction,
383
self.last_total, last_updates = self.last_updates)
384
eta_str = " " + str_tdelta(eta)
388
if self.show_spinner:
389
spin_str = self.SPIN_CHARS[self.spin_pos % 4] + ' '
393
# always update this; it's also used for the bar
396
if self.show_pct and self.last_total and self.last_cnt:
397
pct = 100.0 * ((self.last_cnt + self.child_fraction) / self.last_total)
398
pct_str = ' (%5.1f%%)' % pct
402
if not self.show_count:
404
elif self.last_cnt is None:
406
elif self.last_total is None:
407
count_str = ' %i' % (self.last_cnt)
409
# make both fields the same size
410
t = '%i' % (self.last_total)
411
c = '%*i' % (len(t), self.last_cnt)
412
count_str = ' ' + c + '/' + t
415
# progress bar, if present, soaks up all remaining space
416
cols = self.width - 1 - len(self.last_msg) - len(spin_str) - len(pct_str) \
417
- len(eta_str) - len(count_str) - 3
420
# number of markers highlighted in bar
421
markers = int(round(float(cols) *
422
(self.last_cnt + self.child_fraction) / self.last_total))
423
bar_str = '[' + ('=' * markers).ljust(cols) + '] '
425
# don't know total, so can't show completion.
426
# so just show an expanded spinning thingy
427
m = self.spin_pos % cols
428
ms = (' ' * m + '*').ljust(cols)
430
bar_str = '[' + ms + '] '
436
m = spin_str + bar_str + self.last_msg + count_str + pct_str + eta_str
437
self.to_file.write('\r%-*.*s' % (self.width - 1, self.width - 1, m))
438
self._have_output = True
439
#self.to_file.flush()
442
if self._have_output:
443
self.to_file.write('\r%s\r' % (' ' * (self.width - 1)))
444
self._have_output = False
445
#self.to_file.flush()
448
_progress_bar_types['tty'] = TTYProgressBar
451
class ChildProgress(_BaseProgressBar):
452
"""A progress indicator that pushes its data to the parent"""
454
def __init__(self, _stack, **kwargs):
455
_BaseProgressBar.__init__(self, _stack=_stack, **kwargs)
456
self.parent = _stack.top()
459
self.child_fraction = 0
462
def update(self, msg, current_cnt=None, total_cnt=None):
463
self.current = current_cnt
464
self.total = total_cnt
466
self.child_fraction = 0
469
def child_update(self, message, current, total):
470
if current is None or total == 0:
471
self.child_fraction = 0
473
self.child_fraction = float(current) / total
477
if self.current is None:
480
count = self.current+self.child_fraction
481
if count > self.total:
483
mutter('clamping count of %d to %d' % (count, self.total))
485
self.parent.child_update(self.message, count, self.total)
490
def note(self, *args, **kwargs):
491
self.parent.note(*args, **kwargs)
494
194
def str_tdelta(delt):
added
removed
bzrlib/progress.py
