← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/progress.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-03-20 10:33:11 UTC
  • mfrom: (1615.1.2 bzr.mbp.integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060320103311-a87ccd7ffe9ce14f
(mbp) pycurl bugfixes, robert's knit performance stuff

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/progress.py
142
142
        self.show_bar = show_bar
143
143
        self.show_count = show_count
144
144
        self._stack = _stack
 
145
        # seed throttler
 
146
        self.MIN_PAUSE = 0.1 # seconds
 
147
        now = time.clock()
 
148
        # starting now
 
149
        self.start_time = now
 
150
        # next update should not throttle
 
151
        self.last_update = now - self.MIN_PAUSE - 1
145
152
 
146
153
    def finished(self):
147
154
        """Return this bar to its progress stack."""
230
237
    The output file should be in line-buffered or unbuffered mode.
231
238
    """
232
239
    SPIN_CHARS = r'/-\|'
233
 
    MIN_PAUSE = 0.1 # seconds
234
240
 
235
241
 
236
242
    def __init__(self, **kwargs):
239
245
        self.spin_pos = 0
240
246
        self.width = terminal_width()
241
247
        self.start_time = None
242
 
        self.last_update = None
243
248
        self.last_updates = deque()
244
249
        self.child_fraction = 0
245
250
    
246
251
 
247
252
    def throttle(self):
248
253
        """Return True if the bar was updated too recently"""
249
 
        now = time.time()
250
 
        if self.start_time is None:
251
 
            self.start_time = self.last_update = now
252
 
            return False
253
 
        else:
254
 
            interval = now - self.last_update
255
 
            if interval > 0 and interval < self.MIN_PAUSE:
256
 
                return True
 
254
        # time.time consistently takes 40/4000 ms = 0.01 ms.
 
255
        # but every single update to the pb invokes it.
 
256
        # so we use time.clock which takes 20/4000 ms = 0.005ms
 
257
        # on the downside, time.clock() appears to have approximately
 
258
        # 10ms granularity, so we treat a zero-time change as 'throttled.'
 
259
        
 
260
        now = time.clock()
 
261
        interval = now - self.last_update
 
262
        # if interval > 0
 
263
        if interval < self.MIN_PAUSE:
 
264
            return True
257
265
 
258
266
        self.last_updates.append(now - self.last_update)
259
267
        self.last_update = now
281
289
    def update(self, msg, current_cnt=None, total_cnt=None, 
282
290
               child_fraction=0):
283
291
        """Update and redraw progress bar."""
284
 
        self.child_fraction = child_fraction
285
292
 
286
293
        if current_cnt < 0:
287
294
            current_cnt = 0
289
296
        if current_cnt > total_cnt:
290
297
            total_cnt = current_cnt
291
298
        
 
299
        ## # optional corner case optimisation 
 
300
        ## # currently does not seem to fire so costs more than saved.
 
301
        ## # trivial optimal case:
 
302
        ## # NB if callers are doing a clear and restore with
 
303
        ## # the saved values, this will prevent that:
 
304
        ## # in that case add a restore method that calls
 
305
        ## # _do_update or some such
 
306
        ## if (self.last_msg == msg and
 
307
        ##     self.last_cnt == current_cnt and
 
308
        ##     self.last_total == total_cnt and
 
309
        ##     self.child_fraction == child_fraction):
 
310
        ##     return
 
311
 
292
312
        old_msg = self.last_msg
293
313
        # save these for the tick() function
294
314
        self.last_msg = msg
295
315
        self.last_cnt = current_cnt
296
316
        self.last_total = total_cnt
297
 
            
 
317
        self.child_fraction = child_fraction
 
318
 
 
319
        # each function call takes 20ms/4000 = 0.005 ms, 
 
320
        # but multiple that by 4000 calls -> starts to cost.
 
321
        # so anything to make this function call faster
 
322
        # will improve base 'diff' time by up to 0.1 seconds.
298
323
        if old_msg == self.last_msg and self.throttle():
299
 
            return 
300
 
        
301
 
        if self.show_eta and self.start_time and total_cnt:
302
 
            eta = get_eta(self.start_time, current_cnt+child_fraction, 
303
 
                    total_cnt, last_updates = self.last_updates)
 
324
            return
 
325
 
 
326
        if self.show_eta and self.start_time and self.last_total:
 
327
            eta = get_eta(self.start_time, self.last_cnt + self.child_fraction, 
 
328
                    self.last_total, last_updates = self.last_updates)
304
329
            eta_str = " " + str_tdelta(eta)
305
330
        else:
306
331
            eta_str = ""
313
338
        # always update this; it's also used for the bar
314
339
        self.spin_pos += 1
315
340
 
316
 
        if self.show_pct and total_cnt and current_cnt:
317
 
            pct = 100.0 * ((current_cnt + child_fraction) / total_cnt)
 
341
        if self.show_pct and self.last_total and self.last_cnt:
 
342
            pct = 100.0 * ((self.last_cnt + self.child_fraction) / self.last_total)
318
343
            pct_str = ' (%5.1f%%)' % pct
319
344
        else:
320
345
            pct_str = ''
321
346
 
322
347
        if not self.show_count:
323
348
            count_str = ''
324
 
        elif current_cnt is None:
 
349
        elif self.last_cnt is None:
325
350
            count_str = ''
326
 
        elif total_cnt is None:
327
 
            count_str = ' %i' % (current_cnt)
 
351
        elif self.last_total is None:
 
352
            count_str = ' %i' % (self.last_cnt)
328
353
        else:
329
354
            # make both fields the same size
330
 
            t = '%i' % (total_cnt)
331
 
            c = '%*i' % (len(t), current_cnt)
 
355
            t = '%i' % (self.last_total)
 
356
            c = '%*i' % (len(t), self.last_cnt)
332
357
            count_str = ' ' + c + '/' + t 
333
358
 
334
359
        if self.show_bar:
335
360
            # progress bar, if present, soaks up all remaining space
336
 
            cols = self.width - 1 - len(msg) - len(spin_str) - len(pct_str) \
 
361
            cols = self.width - 1 - len(self.last_msg) - len(spin_str) - len(pct_str) \
337
362
                   - len(eta_str) - len(count_str) - 3
338
363
 
339
 
            if total_cnt:
 
364
            if self.last_total:
340
365
                # number of markers highlighted in bar
341
366
                markers = int(round(float(cols) * 
342
 
                              (current_cnt + child_fraction) / total_cnt))
 
367
                              (self.last_cnt + self.child_fraction) / self.last_total))
343
368
                bar_str = '[' + ('=' * markers).ljust(cols) + '] '
344
369
            elif False:
345
370
                # don't know total, so can't show completion.
353
378
        else:
354
379
            bar_str = ''
355
380
 
356
 
        m = spin_str + bar_str + msg + count_str + pct_str + eta_str
 
381
        m = spin_str + bar_str + self.last_msg + count_str + pct_str + eta_str
357
382
 
358
383
        assert len(m) < self.width
359
384
        self.to_file.write('\r' + m.ljust(self.width - 1))
394
419
        else:
395
420
            count = self.current+self.child_fraction
396
421
            if count > self.total:
397
 
                mutter('clamping count of %d to %d' % (count, self.total))
 
422
                if __debug__:
 
423
                    mutter('clamping count of %d to %d' % (count, self.total))
398
424
                count = self.total
399
425
        self.parent.child_update(self.message, count, self.total)
400
426
 
424
450
    if current > total:
425
451
        return None                     # wtf?
426
452
 
427
 
    elapsed = time.time() - start_time
 
453
    elapsed = time.clock() - start_time
428
454
 
429
455
    if elapsed < 2.0:                   # not enough time to estimate
430
456
        return None