~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/progress.py

  • Committer: Martin Pool
  • Date: 2006-01-13 09:57:13 UTC
  • mto: This revision was merged to the branch mainline in revision 1611.
  • Revision ID: mbp@sourcefrog.net-20060113095713-1fa5912229a3898e
Review updates of pycurl transport

Split them out into 

  bzrlib.transport.http             common base
  bzrlib.transport.http._urllib     pure python
  bzrlib.transport.http._pycurl     calls pycurl

Update to work with robert's nice transport test multiplexer.

Add PyCurlTransport.has() which does just a HEAD request; should be faster.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 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
 
"""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: If not on a tty perhaps just print '......' for the benefit of IDEs, etc
 
34
 
 
35
# TODO: Optionally show elapsed time instead/as well as ETA; nicer
 
36
# when the rate is unpredictable
 
37
 
24
38
 
25
39
import sys
26
40
import time
27
41
import os
28
 
 
29
 
 
30
 
from bzrlib import (
31
 
    errors,
32
 
    )
33
 
from bzrlib.trace import mutter
34
 
from bzrlib.symbol_versioning import (
35
 
    deprecated_function,
36
 
    deprecated_in,
37
 
    )
 
42
from collections import deque
38
43
 
39
44
 
40
45
def _supports_progress(f):
41
 
    """Detect if we can use pretty progress bars on file F.
42
 
 
43
 
    If this returns true we expect that a human may be looking at that
44
 
    output, and that we can repaint a line to update it.
45
 
 
46
 
    This doesn't check the policy for whether we *should* use them.
47
 
    """
48
 
    isatty = getattr(f, 'isatty', None)
49
 
    if isatty is None:
50
 
        return False
51
 
    if not isatty():
52
 
        return False
53
 
    # The following case also handles Win32 - on that platform $TERM is
54
 
    # typically never set, so the case None is treated as a smart terminal,
55
 
    # not dumb.  <https://bugs.launchpad.net/bugs/334808>  win32 files do have
56
 
    # isatty methods that return true.
 
46
    if not hasattr(f, 'isatty'):
 
47
        return False
 
48
    if not f.isatty():
 
49
        return False
57
50
    if os.environ.get('TERM') == 'dumb':
58
51
        # e.g. emacs compile window
59
52
        return False
60
53
    return True
61
54
 
62
55
 
63
 
class ProgressTask(object):
64
 
    """Model component of a progress indicator.
65
 
 
66
 
    Most code that needs to indicate progress should update one of these,
67
 
    and it will in turn update the display, if one is present.
68
 
 
69
 
    Code updating the task may also set fields as hints about how to display
70
 
    it: show_pct, show_spinner, show_eta, show_count, show_bar.  UIs
71
 
    will not necessarily respect all these fields.
72
 
    
73
 
    :ivar update_latency: The interval (in seconds) at which the PB should be
74
 
        updated.  Setting this to zero suggests every update should be shown
75
 
        synchronously.
76
 
 
77
 
    :ivar show_transport_activity: If true (default), transport activity
78
 
        will be shown when this task is drawn.  Disable it if you're sure 
79
 
        that only irrelevant or uninteresting transport activity can occur
80
 
        during this task.
81
 
    """
82
 
 
83
 
    def __init__(self, parent_task=None, ui_factory=None, progress_view=None):
84
 
        """Construct a new progress task.
85
 
 
86
 
        :param parent_task: Enclosing ProgressTask or None.
87
 
 
88
 
        :param progress_view: ProgressView to display this ProgressTask.
89
 
 
90
 
        :param ui_factory: The UI factory that will display updates; 
91
 
            deprecated in favor of passing progress_view directly.
92
 
 
93
 
        Normally you should not call this directly but rather through
94
 
        `ui_factory.nested_progress_bar`.
95
 
        """
96
 
        self._parent_task = parent_task
97
 
        self._last_update = 0
98
 
        self.total_cnt = None
99
 
        self.current_cnt = None
100
 
        self.msg = ''
101
 
        # TODO: deprecate passing ui_factory
102
 
        self.ui_factory = ui_factory
103
 
        self.progress_view = progress_view
104
 
        self.show_pct = False
105
 
        self.show_spinner = True
106
 
        self.show_eta = False,
107
 
        self.show_count = True
108
 
        self.show_bar = True
109
 
        self.update_latency = 0.1
110
 
        self.show_transport_activity = True
111
 
 
112
 
    def __repr__(self):
113
 
        return '%s(%r/%r, msg=%r)' % (
114
 
            self.__class__.__name__,
115
 
            self.current_cnt,
116
 
            self.total_cnt,
117
 
            self.msg)
118
 
 
119
 
    def update(self, msg, current_cnt=None, total_cnt=None):
120
 
        self.msg = msg
121
 
        self.current_cnt = current_cnt
122
 
        if total_cnt:
123
 
            self.total_cnt = total_cnt
124
 
        if self.progress_view:
125
 
            self.progress_view.show_progress(self)
126
 
        else:
127
 
            self.ui_factory._progress_updated(self)
128
 
 
129
 
    def tick(self):
130
 
        self.update(self.msg)
131
 
 
132
 
    def finished(self):
133
 
        if self.progress_view:
134
 
            self.progress_view.task_finished(self)
135
 
        else:
136
 
            self.ui_factory._progress_finished(self)
137
 
 
138
 
    def make_sub_task(self):
139
 
        return ProgressTask(self, ui_factory=self.ui_factory,
140
 
            progress_view=self.progress_view)
141
 
 
142
 
    def _overall_completion_fraction(self, child_fraction=0.0):
143
 
        """Return fractional completion of this task and its parents
144
 
 
145
 
        Returns None if no completion can be computed."""
146
 
        if self.current_cnt is not None and self.total_cnt:
147
 
            own_fraction = (float(self.current_cnt) + child_fraction) / self.total_cnt
148
 
        else:
149
 
            # if this task has no estimation, it just passes on directly
150
 
            # whatever the child has measured...
151
 
            own_fraction = child_fraction
152
 
        if self._parent_task is None:
153
 
            return own_fraction
154
 
        else:
155
 
            if own_fraction is None:
156
 
                own_fraction = 0.0
157
 
            return self._parent_task._overall_completion_fraction(own_fraction)
158
 
 
159
 
    def note(self, fmt_string, *args):
160
 
        """Record a note without disrupting the progress bar."""
161
 
        # XXX: shouldn't be here; put it in mutter or the ui instead
162
 
        if args:
163
 
            self.ui_factory.note(fmt_string % args)
164
 
        else:
165
 
            self.ui_factory.note(fmt_string)
166
 
 
167
 
    def clear(self):
168
 
        # XXX: shouldn't be here; put it in mutter or the ui instead
169
 
        if self.progress_view:
170
 
            self.progress_view.clear()
171
 
        else:
172
 
            self.ui_factory.clear_term()
173
 
 
174
 
 
175
 
@deprecated_function(deprecated_in((1, 16, 0)))
176
 
def ProgressBar(to_file=None, **kwargs):
177
 
    """Construct a progress bar.
178
 
 
179
 
    Deprecated; ask the ui_factory for a progress task instead.
180
 
    """
181
 
    if to_file is None:
182
 
        to_file = sys.stderr
183
 
    requested_bar_type = os.environ.get('BZR_PROGRESS_BAR')
184
 
    # An value of '' or not set reverts to standard processing
185
 
    if requested_bar_type in (None, ''):
186
 
        if _supports_progress(to_file):
187
 
            return TTYProgressBar(to_file=to_file, **kwargs)
188
 
        else:
189
 
            return DummyProgress(to_file=to_file, **kwargs)
 
56
 
 
57
def ProgressBar(to_file=sys.stderr, **kwargs):
 
58
    """Abstract factory"""
 
59
    if _supports_progress(to_file):
 
60
        return TTYProgressBar(to_file=to_file, **kwargs)
190
61
    else:
191
 
        # Minor sanitation to prevent spurious errors
192
 
        requested_bar_type = requested_bar_type.lower().strip()
193
 
        # TODO: jam 20060710 Arguably we shouldn't raise an exception
194
 
        #       but should instead just disable progress bars if we
195
 
        #       don't recognize the type
196
 
        if requested_bar_type not in _progress_bar_types:
197
 
            raise errors.InvalidProgressBarType(requested_bar_type,
198
 
                                                _progress_bar_types.keys())
199
 
        return _progress_bar_types[requested_bar_type](to_file=to_file, **kwargs)
200
 
 
201
 
 
202
 
# NOTE: This is also deprecated; you should provide a ProgressView instead.
 
62
        return DotsProgressBar(to_file=to_file, **kwargs)
 
63
    
 
64
    
203
65
class _BaseProgressBar(object):
204
 
 
205
66
    def __init__(self,
206
 
                 to_file=None,
 
67
                 to_file=sys.stderr,
207
68
                 show_pct=False,
208
69
                 show_spinner=False,
209
 
                 show_eta=False,
 
70
                 show_eta=True,
210
71
                 show_bar=True,
211
 
                 show_count=True,
212
 
                 to_messages_file=None,
213
 
                 _stack=None):
 
72
                 show_count=True):
214
73
        object.__init__(self)
215
 
        if to_file is None:
216
 
            to_file = sys.stderr
217
 
        if to_messages_file is None:
218
 
            to_messages_file = sys.stdout
219
74
        self.to_file = to_file
220
 
        self.to_messages_file = to_messages_file
 
75
 
221
76
        self.last_msg = None
222
77
        self.last_cnt = None
223
78
        self.last_total = None
226
81
        self.show_eta = show_eta
227
82
        self.show_bar = show_bar
228
83
        self.show_count = show_count
229
 
        self._stack = _stack
230
 
        # seed throttler
231
 
        self.MIN_PAUSE = 0.1 # seconds
232
 
        now = time.time()
233
 
        # starting now
234
 
        self.start_time = now
235
 
        # next update should not throttle
236
 
        self.last_update = now - self.MIN_PAUSE - 1
237
 
 
238
 
    def finished(self):
239
 
        """Return this bar to its progress stack."""
240
 
        self.clear()
241
 
        self._stack.return_pb(self)
242
 
 
243
 
    def note(self, fmt_string, *args, **kwargs):
244
 
        """Record a note without disrupting the progress bar."""
245
 
        self.clear()
246
 
        self.to_messages_file.write(fmt_string % args)
247
 
        self.to_messages_file.write('\n')
248
 
 
249
 
    @deprecated_function(deprecated_in((1, 16, 0)))
250
 
    def child_progress(self, **kwargs):
251
 
        return ChildProgress(**kwargs)
 
84
 
252
85
 
253
86
 
254
87
class DummyProgress(_BaseProgressBar):
256
89
 
257
90
    This can be used as the default argument for methods that
258
91
    take an optional progress indicator."""
259
 
 
260
92
    def tick(self):
261
93
        pass
262
94
 
263
95
    def update(self, msg=None, current=None, total=None):
264
96
        pass
265
97
 
266
 
    def child_update(self, message, current, total):
267
 
        pass
268
 
 
269
98
    def clear(self):
270
99
        pass
271
 
 
272
 
    def note(self, fmt_string, *args, **kwargs):
273
 
        """See _BaseProgressBar.note()."""
274
 
 
275
 
    def child_progress(self, **kwargs):
276
 
        return DummyProgress(**kwargs)
277
 
 
278
 
 
 
100
        
 
101
    
279
102
class DotsProgressBar(_BaseProgressBar):
280
 
 
281
 
    @deprecated_function(deprecated_in((1, 16, 0)))
282
103
    def __init__(self, **kwargs):
283
104
        _BaseProgressBar.__init__(self, **kwargs)
284
105
        self.last_msg = None
285
106
        self.need_nl = False
286
 
 
 
107
        
287
108
    def tick(self):
288
109
        self.update()
289
 
 
 
110
        
290
111
    def update(self, msg=None, current_cnt=None, total_cnt=None):
291
112
        if msg and msg != self.last_msg:
292
113
            if self.need_nl:
293
114
                self.to_file.write('\n')
 
115
            
294
116
            self.to_file.write(msg + ': ')
295
117
            self.last_msg = msg
296
118
        self.need_nl = True
297
119
        self.to_file.write('.')
298
 
 
 
120
        
299
121
    def clear(self):
300
122
        if self.need_nl:
301
123
            self.to_file.write('\n')
302
 
        self.need_nl = False
303
 
 
304
 
    def child_update(self, message, current, total):
305
 
        self.tick()
306
 
 
307
 
 
 
124
        
 
125
    
308
126
class TTYProgressBar(_BaseProgressBar):
309
127
    """Progress bar display object.
310
128
 
326
144
    The output file should be in line-buffered or unbuffered mode.
327
145
    """
328
146
    SPIN_CHARS = r'/-\|'
329
 
 
330
 
    @deprecated_function(deprecated_in((1, 16, 0)))
 
147
    MIN_PAUSE = 0.1 # seconds
 
148
 
 
149
 
331
150
    def __init__(self, **kwargs):
332
151
        from bzrlib.osutils import terminal_width
333
152
        _BaseProgressBar.__init__(self, **kwargs)
334
153
        self.spin_pos = 0
335
154
        self.width = terminal_width()
336
 
        self.last_updates = []
337
 
        self._max_last_updates = 10
338
 
        self.child_fraction = 0
339
 
        self._have_output = False
 
155
        self.start_time = None
 
156
        self.last_update = None
 
157
        self.last_updates = deque()
 
158
    
340
159
 
341
 
    def throttle(self, old_msg):
 
160
    def throttle(self):
342
161
        """Return True if the bar was updated too recently"""
343
 
        # time.time consistently takes 40/4000 ms = 0.01 ms.
344
 
        # time.clock() is faster, but gives us CPU time, not wall-clock time
345
162
        now = time.time()
346
 
        if self.start_time is not None and (now - self.start_time) < 1:
347
 
            return True
348
 
        if old_msg != self.last_msg:
 
163
        if self.start_time is None:
 
164
            self.start_time = self.last_update = now
349
165
            return False
350
 
        interval = now - self.last_update
351
 
        # if interval > 0
352
 
        if interval < self.MIN_PAUSE:
353
 
            return True
 
166
        else:
 
167
            interval = now - self.last_update
 
168
            if interval > 0 and interval < self.MIN_PAUSE:
 
169
                return True
354
170
 
355
171
        self.last_updates.append(now - self.last_update)
356
 
        # Don't let the queue grow without bound
357
 
        self.last_updates = self.last_updates[-self._max_last_updates:]
358
172
        self.last_update = now
359
173
        return False
 
174
        
360
175
 
361
176
    def tick(self):
362
 
        self.update(self.last_msg, self.last_cnt, self.last_total,
363
 
                    self.child_fraction)
364
 
 
365
 
    def child_update(self, message, current, total):
366
 
        if current is not None and total != 0:
367
 
            child_fraction = float(current) / total
368
 
            if self.last_cnt is None:
369
 
                pass
370
 
            elif self.last_cnt + child_fraction <= self.last_total:
371
 
                self.child_fraction = child_fraction
372
 
        if self.last_msg is None:
373
 
            self.last_msg = ''
374
 
        self.tick()
375
 
 
376
 
    def update(self, msg, current_cnt=None, total_cnt=None,
377
 
            child_fraction=0):
378
 
        """Update and redraw progress bar.
379
 
        """
380
 
        if msg is None:
381
 
            msg = self.last_msg
382
 
 
383
 
        if total_cnt is None:
384
 
            total_cnt = self.last_total
 
177
        self.update(self.last_msg, self.last_cnt, self.last_total)
 
178
                 
 
179
 
 
180
 
 
181
    def update(self, msg, current_cnt=None, total_cnt=None):
 
182
        """Update and redraw progress bar."""
385
183
 
386
184
        if current_cnt < 0:
387
185
            current_cnt = 0
388
 
 
 
186
            
389
187
        if current_cnt > total_cnt:
390
188
            total_cnt = current_cnt
391
189
 
392
 
        ## # optional corner case optimisation
393
 
        ## # currently does not seem to fire so costs more than saved.
394
 
        ## # trivial optimal case:
395
 
        ## # NB if callers are doing a clear and restore with
396
 
        ## # the saved values, this will prevent that:
397
 
        ## # in that case add a restore method that calls
398
 
        ## # _do_update or some such
399
 
        ## if (self.last_msg == msg and
400
 
        ##     self.last_cnt == current_cnt and
401
 
        ##     self.last_total == total_cnt and
402
 
        ##     self.child_fraction == child_fraction):
403
 
        ##     return
404
 
 
405
 
        if msg is None:
406
 
            msg = ''
407
 
 
408
 
        old_msg = self.last_msg
409
190
        # save these for the tick() function
410
191
        self.last_msg = msg
411
192
        self.last_cnt = current_cnt
412
193
        self.last_total = total_cnt
413
 
        self.child_fraction = child_fraction
414
 
 
415
 
        # each function call takes 20ms/4000 = 0.005 ms,
416
 
        # but multiple that by 4000 calls -> starts to cost.
417
 
        # so anything to make this function call faster
418
 
        # will improve base 'diff' time by up to 0.1 seconds.
419
 
        if self.throttle(old_msg):
420
 
            return
421
 
 
422
 
        if self.show_eta and self.start_time and self.last_total:
423
 
            eta = get_eta(self.start_time, self.last_cnt + self.child_fraction,
424
 
                    self.last_total, last_updates = self.last_updates)
 
194
            
 
195
        if self.throttle():
 
196
            return 
 
197
        
 
198
        if self.show_eta and self.start_time and total_cnt:
 
199
            eta = get_eta(self.start_time, current_cnt, total_cnt,
 
200
                    last_updates = self.last_updates)
425
201
            eta_str = " " + str_tdelta(eta)
426
202
        else:
427
203
            eta_str = ""
428
204
 
429
205
        if self.show_spinner:
430
 
            spin_str = self.SPIN_CHARS[self.spin_pos % 4] + ' '
 
206
            spin_str = self.SPIN_CHARS[self.spin_pos % 4] + ' '            
431
207
        else:
432
208
            spin_str = ''
433
209
 
434
210
        # always update this; it's also used for the bar
435
211
        self.spin_pos += 1
436
212
 
437
 
        if self.show_pct and self.last_total and self.last_cnt:
438
 
            pct = 100.0 * ((self.last_cnt + self.child_fraction) / self.last_total)
 
213
        if self.show_pct and total_cnt and current_cnt:
 
214
            pct = 100.0 * current_cnt / total_cnt
439
215
            pct_str = ' (%5.1f%%)' % pct
440
216
        else:
441
217
            pct_str = ''
442
218
 
443
219
        if not self.show_count:
444
220
            count_str = ''
445
 
        elif self.last_cnt is None:
 
221
        elif current_cnt is None:
446
222
            count_str = ''
447
 
        elif self.last_total is None:
448
 
            count_str = ' %i' % (self.last_cnt)
 
223
        elif total_cnt is None:
 
224
            count_str = ' %i' % (current_cnt)
449
225
        else:
450
226
            # make both fields the same size
451
 
            t = '%i' % (self.last_total)
452
 
            c = '%*i' % (len(t), self.last_cnt)
453
 
            count_str = ' ' + c + '/' + t
 
227
            t = '%i' % (total_cnt)
 
228
            c = '%*i' % (len(t), current_cnt)
 
229
            count_str = ' ' + c + '/' + t 
454
230
 
455
231
        if self.show_bar:
456
232
            # progress bar, if present, soaks up all remaining space
457
 
            cols = self.width - 1 - len(self.last_msg) - len(spin_str) - len(pct_str) \
 
233
            cols = self.width - 1 - len(msg) - len(spin_str) - len(pct_str) \
458
234
                   - len(eta_str) - len(count_str) - 3
459
235
 
460
 
            if self.last_total:
 
236
            if total_cnt:
461
237
                # number of markers highlighted in bar
462
 
                markers = int(round(float(cols) *
463
 
                              (self.last_cnt + self.child_fraction) / self.last_total))
 
238
                markers = int(round(float(cols) * current_cnt / total_cnt))
464
239
                bar_str = '[' + ('=' * markers).ljust(cols) + '] '
465
240
            elif False:
466
241
                # don't know total, so can't show completion.
467
242
                # so just show an expanded spinning thingy
468
243
                m = self.spin_pos % cols
469
244
                ms = (' ' * m + '*').ljust(cols)
470
 
 
 
245
                
471
246
                bar_str = '[' + ms + '] '
472
247
            else:
473
248
                bar_str = ''
474
249
        else:
475
250
            bar_str = ''
476
251
 
477
 
        m = spin_str + bar_str + self.last_msg + count_str \
478
 
            + pct_str + eta_str
479
 
        self.to_file.write('\r%-*.*s' % (self.width - 1, self.width - 1, m))
480
 
        self._have_output = True
481
 
        #self.to_file.flush()
482
 
 
483
 
    def clear(self):
484
 
        if self._have_output:
485
 
            self.to_file.write('\r%s\r' % (' ' * (self.width - 1)))
486
 
        self._have_output = False
487
 
        #self.to_file.flush()
488
 
 
489
 
 
490
 
 
491
 
# DEPRECATED
492
 
class ChildProgress(_BaseProgressBar):
493
 
    """A progress indicator that pushes its data to the parent"""
494
 
 
495
 
    @deprecated_function(deprecated_in((1, 16, 0)))
496
 
    def __init__(self, _stack, **kwargs):
497
 
        _BaseProgressBar.__init__(self, _stack=_stack, **kwargs)
498
 
        self.parent = _stack.top()
499
 
        self.current = None
500
 
        self.total = None
501
 
        self.child_fraction = 0
502
 
        self.message = None
503
 
 
504
 
    def update(self, msg, current_cnt=None, total_cnt=None):
505
 
        self.current = current_cnt
506
 
        if total_cnt is not None:
507
 
            self.total = total_cnt
508
 
        self.message = msg
509
 
        self.child_fraction = 0
510
 
        self.tick()
511
 
 
512
 
    def child_update(self, message, current, total):
513
 
        if current is None or total == 0:
514
 
            self.child_fraction = 0
515
 
        else:
516
 
            self.child_fraction = float(current) / total
517
 
        self.tick()
518
 
 
519
 
    def tick(self):
520
 
        if self.current is None:
521
 
            count = None
522
 
        else:
523
 
            count = self.current+self.child_fraction
524
 
            if count > self.total:
525
 
                if __debug__:
526
 
                    mutter('clamping count of %d to %d' % (count, self.total))
527
 
                count = self.total
528
 
        self.parent.child_update(self.message, count, self.total)
529
 
 
530
 
    def clear(self):
531
 
        pass
532
 
 
533
 
    def note(self, *args, **kwargs):
534
 
        self.parent.note(*args, **kwargs)
535
 
 
536
 
 
 
252
        m = spin_str + bar_str + msg + count_str + pct_str + eta_str
 
253
 
 
254
        assert len(m) < self.width
 
255
        self.to_file.write('\r' + m.ljust(self.width - 1))
 
256
        #self.to_file.flush()
 
257
            
 
258
 
 
259
    def clear(self):        
 
260
        self.to_file.write('\r%s\r' % (' ' * (self.width - 1)))
 
261
        #self.to_file.flush()        
 
262
    
 
263
 
 
264
        
537
265
def str_tdelta(delt):
538
266
    if delt is None:
539
267
        return "-:--:--"
560
288
 
561
289
    if elapsed < 2.0:                   # not enough time to estimate
562
290
        return None
563
 
 
 
291
    
564
292
    total_duration = float(elapsed) * float(total) / float(current)
565
293
 
 
294
    assert total_duration >= elapsed
 
295
 
566
296
    if last_updates and len(last_updates) >= n_recent:
 
297
        while len(last_updates) > n_recent:
 
298
            last_updates.popleft()
567
299
        avg = sum(last_updates) / float(len(last_updates))
568
300
        time_left = avg * (total - current)
569
301
 
575
307
    return total_duration - elapsed
576
308
 
577
309
 
578
 
class ProgressPhase(object):
579
 
    """Update progress object with the current phase"""
580
 
    def __init__(self, message, total, pb):
581
 
        object.__init__(self)
582
 
        self.pb = pb
583
 
        self.message = message
584
 
        self.total = total
585
 
        self.cur_phase = None
586
 
 
587
 
    def next_phase(self):
588
 
        if self.cur_phase is None:
589
 
            self.cur_phase = 0
590
 
        else:
591
 
            self.cur_phase += 1
592
 
        self.pb.update(self.message, self.cur_phase, self.total)
593
 
 
594
 
 
595
 
_progress_bar_types = {}
596
 
_progress_bar_types['dummy'] = DummyProgress
597
 
_progress_bar_types['none'] = DummyProgress
598
 
_progress_bar_types['tty'] = TTYProgressBar
599
 
_progress_bar_types['dots'] = DotsProgressBar
 
310
def run_tests():
 
311
    import doctest
 
312
    result = doctest.testmod()
 
313
    if result[1] > 0:
 
314
        if result[0] == 0:
 
315
            print "All tests passed"
 
316
    else:
 
317
        print "No tests to run"
 
318
 
 
319
 
 
320
def demo():
 
321
    sleep = time.sleep
 
322
    
 
323
    print 'dumb-terminal test:'
 
324
    pb = DotsProgressBar()
 
325
    for i in range(100):
 
326
        pb.update('Leoparden', i, 99)
 
327
        sleep(0.1)
 
328
    sleep(1.5)
 
329
    pb.clear()
 
330
    sleep(1.5)
 
331
    
 
332
    print 'smart-terminal test:'
 
333
    pb = ProgressBar(show_pct=True, show_bar=True, show_spinner=False)
 
334
    for i in range(100):
 
335
        pb.update('Elephanten', i, 99)
 
336
        sleep(0.1)
 
337
    sleep(2)
 
338
    pb.clear()
 
339
    sleep(1)
 
340
 
 
341
    print 'done!'
 
342
 
 
343
if __name__ == "__main__":
 
344
    demo()