← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/progress.py

  • Committer: Vincent Ladeuil
  • Date: 2008-08-26 08:25:27 UTC
  • mto: (3668.1.1 trunk) (3703.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 3669.
  • Revision ID: v.ladeuil+lp@free.fr-20080826082527-109yyxzc0u24oeel
Fix all calls to tempfile.mkdtemp to osutils.mkdtemp.

* bzrlib/transform.py:
(TransformPreview.__init__): Use osutils.mkdtemp instead of
tempfile.mkdtemp.

* bzrlib/tests/test_whitebox.py:
(MoreTests.test_relpath): Use osutils.mkdtemp instead of
tempfile.mkdtemp.

* bzrlib/tests/test_setup.py:
(TestSetup.test_build_and_install): Use osutils.mkdtemp instead of
tempfile.mkdtemp.

* bzrlib/tests/test_bundle.py:
(BundleTester.get_checkout): Use osutils.mkdtemp instead of
tempfile.mkdtemp.

* bzrlib/tests/blackbox/test_outside_wt.py:
(TestOutsideWT.test_cwd_log,
TestOutsideWT.test_diff_outside_tree): Use osutils.mkdtemp instead
of tempfile.mkdtemp.

* bzrlib/smart/repository.py:
(SmartServerRepositoryTarball._copy_to_tempdir): Use
osutils.mkdtemp instead of tempfile.mkdtemp.
(SmartServerRepositoryTarball._tarfile_response): Line too long.

* bzrlib/remote.py:
(RemoteRepository._copy_repository_tarball): Use osutils.mkdtemp
instead of tempfile.mkdtemp.

* bzrlib/osutils.py:
(_mac_mkdtemp): Add docstring.

* bzrlib/mail_client.py:
(ExternalMailClient.compose): Use osutils.mkdtemp instead of
tempfile.mkdtemp.

* bzrlib/diff.py:
(DiffFromTool.__init__): Use osutils.mkdtemp instead of
tempfile.mkdtemp.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/progress.py
1
1
# Copyright (C) 2005 Aaron Bentley <aaron.bentley@utoronto.ca>
2
 
# Copyright (C) 2005, 2006 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.
 
2
# Copyright (C) 2005, 2006 Canonical Ltd
 
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
"""Progress indicators.
 
20
 
 
21
The usual way to use this is via bzrlib.ui.ui_factory.nested_progress_bar which
 
22
will maintain a ProgressBarStack for you.
 
23
 
 
24
For direct use, the factory ProgressBar will return an auto-detected progress
 
25
bar that should match your terminal type. You can manually create a
 
26
ProgressBarStack too if you need multiple levels of cooperating progress bars.
 
27
Note that bzrlib's internal functions use the ui module, so if you are using
 
28
bzrlib it really is best to use bzrlib.ui.ui_factory.
27
29
"""
28
30
 
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
31
# TODO: Optionally show elapsed time instead/as well as ETA; nicer
36
32
# when the rate is unpredictable
37
33
 
38
 
 
39
34
import sys
40
35
import time
41
36
import os
42
37
 
43
 
import bzrlib.errors as errors
 
38
from bzrlib.lazy_import import lazy_import
 
39
lazy_import(globals(), """
 
40
from bzrlib import (
 
41
    errors,
 
42
    )
 
43
""")
 
44
 
44
45
from bzrlib.trace import mutter
45
46
 
46
47
 
47
48
def _supports_progress(f):
 
49
    """Detect if we can use pretty progress bars on the output stream f.
 
50
 
 
51
    If this returns true we expect that a human may be looking at that 
 
52
    output, and that we can repaint a line to update it.
 
53
    """
48
54
    isatty = getattr(f, 'isatty', None)
49
55
    if isatty is None:
50
56
        return False
69
75
        if _supports_progress(to_file):
70
76
            return TTYProgressBar(to_file=to_file, **kwargs)
71
77
        else:
72
 
            return DotsProgressBar(to_file=to_file, **kwargs)
 
78
            return DummyProgress(to_file=to_file, **kwargs)
73
79
    else:
74
80
        # Minor sanitation to prevent spurious errors
75
81
        requested_bar_type = requested_bar_type.lower().strip()
174
180
        self._stack = _stack
175
181
        # seed throttler
176
182
        self.MIN_PAUSE = 0.1 # seconds
177
 
        now = time.clock()
 
183
        now = time.time()
178
184
        # starting now
179
185
        self.start_time = now
180
186
        # next update should not throttle
183
189
    def finished(self):
184
190
        """Return this bar to its progress stack."""
185
191
        self.clear()
186
 
        assert self._stack is not None
187
192
        self._stack.return_pb(self)
188
193
 
189
194
    def note(self, fmt_string, *args, **kwargs):
288
293
        self.child_fraction = 0
289
294
        self._have_output = False
290
295
    
291
 
 
292
296
    def throttle(self, old_msg):
293
297
        """Return True if the bar was updated too recently"""
294
298
        # time.time consistently takes 40/4000 ms = 0.01 ms.
295
 
        # but every single update to the pb invokes it.
296
 
        # so we use time.clock which takes 20/4000 ms = 0.005ms
297
 
        # on the downside, time.clock() appears to have approximately
298
 
        # 10ms granularity, so we treat a zero-time change as 'throttled.'
299
 
        now = time.clock()
 
299
        # time.clock() is faster, but gives us CPU time, not wall-clock time
 
300
        now = time.time()
300
301
        if self.start_time is not None and (now - self.start_time) < 1:
301
302
            return True
302
303
        if old_msg != self.last_msg:
313
314
        return False
314
315
        
315
316
    def tick(self):
316
 
        self.update(self.last_msg, self.last_cnt, self.last_total, 
 
317
        self.update(self.last_msg, self.last_cnt, self.last_total,
317
318
                    self.child_fraction)
318
319
 
319
320
    def child_update(self, message, current, total):
323
324
                pass
324
325
            elif self.last_cnt + child_fraction <= self.last_total:
325
326
                self.child_fraction = child_fraction
326
 
            else:
327
 
                mutter('not updating child fraction')
328
327
        if self.last_msg is None:
329
328
            self.last_msg = ''
330
329
        self.tick()
331
330
 
332
 
    def update(self, msg, current_cnt=None, total_cnt=None, 
 
331
    def update(self, msg, current_cnt=None, total_cnt=None,
333
332
               child_fraction=0):
334
333
        """Update and redraw progress bar."""
335
334
        if msg is None:
427
426
            bar_str = ''
428
427
 
429
428
        m = spin_str + bar_str + self.last_msg + count_str + pct_str + eta_str
430
 
 
431
 
        assert len(m) < self.width
432
 
        self.to_file.write('\r' + m.ljust(self.width - 1))
 
429
        self.to_file.write('\r%-*.*s' % (self.width - 1, self.width - 1, m))
433
430
        self._have_output = True
434
431
        #self.to_file.flush()
435
432
            
436
 
    def clear(self):        
 
433
    def clear(self):
437
434
        if self._have_output:
438
435
            self.to_file.write('\r%s\r' % (' ' * (self.width - 1)))
439
436
        self._have_output = False
456
453
 
457
454
    def update(self, msg, current_cnt=None, total_cnt=None):
458
455
        self.current = current_cnt
459
 
        self.total = total_cnt
 
456
        if total_cnt is not None:
 
457
            self.total = total_cnt
460
458
        self.message = msg
461
459
        self.child_fraction = 0
462
460
        self.tick()
485
483
    def note(self, *args, **kwargs):
486
484
        self.parent.note(*args, **kwargs)
487
485
 
488
 
 
 
486
 
 
487
class InstrumentedProgress(TTYProgressBar):
 
488
    """TTYProgress variant that tracks outcomes"""
 
489
 
 
490
    def __init__(self, *args, **kwargs):
 
491
        self.always_throttled = True
 
492
        self.never_throttle = False
 
493
        TTYProgressBar.__init__(self, *args, **kwargs)
 
494
 
 
495
    def throttle(self, old_message):
 
496
        if self.never_throttle:
 
497
            result =  False
 
498
        else:
 
499
            result = TTYProgressBar.throttle(self, old_message)
 
500
        if result is False:
 
501
            self.always_throttled = False
 
502
 
 
503
 
489
504
def str_tdelta(delt):
490
505
    if delt is None:
491
506
        return "-:--:--"
508
523
    if current > total:
509
524
        return None                     # wtf?
510
525
 
511
 
    elapsed = time.clock() - start_time
 
526
    elapsed = time.time() - start_time
512
527
 
513
528
    if elapsed < 2.0:                   # not enough time to estimate
514
529
        return None
515
530
    
516
531
    total_duration = float(elapsed) * float(total) / float(current)
517
532
 
518
 
    assert total_duration >= elapsed
519
 
 
520
533
    if last_updates and len(last_updates) >= n_recent:
521
534
        avg = sum(last_updates) / float(len(last_updates))
522
535
        time_left = avg * (total - current)
543
556
            self.cur_phase = 0
544
557
        else:
545
558
            self.cur_phase += 1
546
 
        assert self.cur_phase < self.total 
547
559
        self.pb.update(self.message, self.cur_phase, self.total)
548
 
 
549
 
 
550
 
def run_tests():
551
 
    import doctest
552
 
    result = doctest.testmod()
553
 
    if result[1] > 0:
554
 
        if result[0] == 0:
555
 
            print "All tests passed"
556
 
    else:
557
 
        print "No tests to run"
558
 
 
559
 
 
560
 
def demo():
561
 
    sleep = time.sleep
562
 
    
563
 
    print 'dumb-terminal test:'
564
 
    pb = DotsProgressBar()
565
 
    for i in range(100):
566
 
        pb.update('Leoparden', i, 99)
567
 
        sleep(0.1)
568
 
    sleep(1.5)
569
 
    pb.clear()
570
 
    sleep(1.5)
571
 
    
572
 
    print 'smart-terminal test:'
573
 
    pb = ProgressBar(show_pct=True, show_bar=True, show_spinner=False)
574
 
    for i in range(100):
575
 
        pb.update('Elephanten', i, 99)
576
 
        sleep(0.1)
577
 
    sleep(2)
578
 
    pb.clear()
579
 
    sleep(1)
580
 
 
581
 
    print 'done!'
582
 
 
583
 
if __name__ == "__main__":
584
 
    demo()