/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/progress.py

  • Committer: Martin Pool
  • Date: 2005-09-06 02:26:28 UTC
  • Revision ID: mbp@sourcefrog.net-20050906022628-66d65f0feb4a9e80
- implement version 5 xml storage, and tests

  This stores files identified by the version that introduced the 
  text, and the version that introduced the name.  Entry kinds are
  given by the xml tag not an explicit kind field.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/progress.py
 
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.
 
27
"""
 
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
 
 
38
 
 
39
import sys
 
40
import time
 
41
import os
 
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
    try:
 
53
        return int(os.environ['COLUMNS'])
 
54
    except (IndexError, KeyError, ValueError):
 
55
        return 80
 
56
 
 
57
 
 
58
def _supports_progress(f):
 
59
    if not hasattr(f, 'isatty'):
 
60
        return False
 
61
    if not f.isatty():
 
62
        return False
 
63
    if os.environ.get('TERM') == 'dumb':
 
64
        # e.g. emacs compile window
 
65
        return False
 
66
    return True
 
67
 
 
68
 
 
69
 
 
70
def ProgressBar(to_file=sys.stderr, **kwargs):
 
71
    """Abstract factory"""
 
72
    if _supports_progress(to_file):
 
73
        return TTYProgressBar(to_file=to_file, **kwargs)
 
74
    else:
 
75
        return DotsProgressBar(to_file=to_file, **kwargs)
 
76
    
 
77
    
 
78
class _BaseProgressBar(object):
 
79
    def __init__(self,
 
80
                 to_file=sys.stderr,
 
81
                 show_pct=False,
 
82
                 show_spinner=False,
 
83
                 show_eta=True,
 
84
                 show_bar=True,
 
85
                 show_count=True):
 
86
        object.__init__(self)
 
87
        self.to_file = to_file
 
88
 
 
89
        self.last_msg = None
 
90
        self.last_cnt = None
 
91
        self.last_total = None
 
92
        self.show_pct = show_pct
 
93
        self.show_spinner = show_spinner
 
94
        self.show_eta = show_eta
 
95
        self.show_bar = show_bar
 
96
        self.show_count = show_count
 
97
 
 
98
 
 
99
 
 
100
class DummyProgress(_BaseProgressBar):
 
101
    """Progress-bar standin that does nothing.
 
102
 
 
103
    This can be used as the default argument for methods that
 
104
    take an optional progress indicator."""
 
105
    def tick(self):
 
106
        pass
 
107
 
 
108
    def update(self, msg=None, current=None, total=None):
 
109
        pass
 
110
 
 
111
    def clear(self):
 
112
        pass
 
113
        
 
114
    
 
115
class DotsProgressBar(_BaseProgressBar):
 
116
    def __init__(self, **kwargs):
 
117
        _BaseProgressBar.__init__(self, **kwargs)
 
118
        self.last_msg = None
 
119
        self.need_nl = False
 
120
        
 
121
    def tick(self):
 
122
        self.update()
 
123
        
 
124
    def update(self, msg=None, current_cnt=None, total_cnt=None):
 
125
        if msg and msg != self.last_msg:
 
126
            if self.need_nl:
 
127
                self.to_file.write('\n')
 
128
            
 
129
            self.to_file.write(msg + ': ')
 
130
            self.last_msg = msg
 
131
        self.need_nl = True
 
132
        self.to_file.write('.')
 
133
        
 
134
    def clear(self):
 
135
        if self.need_nl:
 
136
            self.to_file.write('\n')
 
137
        
 
138
    
 
139
class TTYProgressBar(_BaseProgressBar):
 
140
    """Progress bar display object.
 
141
 
 
142
    Several options are available to control the display.  These can
 
143
    be passed as parameters to the constructor or assigned at any time:
 
144
 
 
145
    show_pct
 
146
        Show percentage complete.
 
147
    show_spinner
 
148
        Show rotating baton.  This ticks over on every update even
 
149
        if the values don't change.
 
150
    show_eta
 
151
        Show predicted time-to-completion.
 
152
    show_bar
 
153
        Show bar graph.
 
154
    show_count
 
155
        Show numerical counts.
 
156
 
 
157
    The output file should be in line-buffered or unbuffered mode.
 
158
    """
 
159
    SPIN_CHARS = r'/-\|'
 
160
    MIN_PAUSE = 0.1 # seconds
 
161
 
 
162
 
 
163
    def __init__(self, **kwargs):
 
164
        _BaseProgressBar.__init__(self, **kwargs)
 
165
        self.spin_pos = 0
 
166
        self.width = _width()
 
167
        self.start_time = None
 
168
        self.last_update = None
 
169
    
 
170
 
 
171
    def throttle(self):
 
172
        """Return True if the bar was updated too recently"""
 
173
        now = time.time()
 
174
        if self.start_time is None:
 
175
            self.start_time = self.last_update = now
 
176
            return False
 
177
        else:
 
178
            interval = now - self.last_update
 
179
            if interval > 0 and interval < self.MIN_PAUSE:
 
180
                return True
 
181
 
 
182
        self.last_update = now
 
183
        return False
 
184
        
 
185
 
 
186
    def tick(self):
 
187
        self.update(self.last_msg, self.last_cnt, self.last_total)
 
188
                 
 
189
 
 
190
 
 
191
    def update(self, msg, current_cnt=None, total_cnt=None):
 
192
        """Update and redraw progress bar."""
 
193
 
 
194
        # save these for the tick() function
 
195
        self.last_msg = msg
 
196
        self.last_cnt = current_cnt
 
197
        self.last_total = total_cnt
 
198
            
 
199
        if self.throttle():
 
200
            return 
 
201
        
 
202
        if total_cnt:
 
203
            assert current_cnt <= total_cnt
 
204
        if current_cnt:
 
205
            assert current_cnt >= 0
 
206
        
 
207
        if self.show_eta and self.start_time and total_cnt:
 
208
            eta = get_eta(self.start_time, current_cnt, total_cnt)
 
209
            eta_str = " " + str_tdelta(eta)
 
210
        else:
 
211
            eta_str = ""
 
212
 
 
213
        if self.show_spinner:
 
214
            spin_str = self.SPIN_CHARS[self.spin_pos % 4] + ' '            
 
215
        else:
 
216
            spin_str = ''
 
217
 
 
218
        # always update this; it's also used for the bar
 
219
        self.spin_pos += 1
 
220
 
 
221
        if self.show_pct and total_cnt and current_cnt:
 
222
            pct = 100.0 * current_cnt / total_cnt
 
223
            pct_str = ' (%5.1f%%)' % pct
 
224
        else:
 
225
            pct_str = ''
 
226
 
 
227
        if not self.show_count:
 
228
            count_str = ''
 
229
        elif current_cnt is None:
 
230
            count_str = ''
 
231
        elif total_cnt is None:
 
232
            count_str = ' %i' % (current_cnt)
 
233
        else:
 
234
            # make both fields the same size
 
235
            t = '%i' % (total_cnt)
 
236
            c = '%*i' % (len(t), current_cnt)
 
237
            count_str = ' ' + c + '/' + t 
 
238
 
 
239
        if self.show_bar:
 
240
            # progress bar, if present, soaks up all remaining space
 
241
            cols = self.width - 1 - len(msg) - len(spin_str) - len(pct_str) \
 
242
                   - len(eta_str) - len(count_str) - 3
 
243
 
 
244
            if total_cnt:
 
245
                # number of markers highlighted in bar
 
246
                markers = int(round(float(cols) * current_cnt / total_cnt))
 
247
                bar_str = '[' + ('=' * markers).ljust(cols) + '] '
 
248
            elif False:
 
249
                # don't know total, so can't show completion.
 
250
                # so just show an expanded spinning thingy
 
251
                m = self.spin_pos % cols
 
252
                ms = (' ' * m + '*').ljust(cols)
 
253
                
 
254
                bar_str = '[' + ms + '] '
 
255
            else:
 
256
                bar_str = ''
 
257
        else:
 
258
            bar_str = ''
 
259
 
 
260
        m = spin_str + bar_str + msg + count_str + pct_str + eta_str
 
261
 
 
262
        assert len(m) < self.width
 
263
        self.to_file.write('\r' + m.ljust(self.width - 1))
 
264
        #self.to_file.flush()
 
265
            
 
266
 
 
267
    def clear(self):        
 
268
        self.to_file.write('\r%s\r' % (' ' * (self.width - 1)))
 
269
        #self.to_file.flush()        
 
270
    
 
271
 
 
272
        
 
273
def str_tdelta(delt):
 
274
    if delt is None:
 
275
        return "-:--:--"
 
276
    delt = int(round(delt))
 
277
    return '%d:%02d:%02d' % (delt/3600,
 
278
                             (delt/60) % 60,
 
279
                             delt % 60)
 
280
 
 
281
 
 
282
def get_eta(start_time, current, total, enough_samples=3):
 
283
    if start_time is None:
 
284
        return None
 
285
 
 
286
    if not total:
 
287
        return None
 
288
 
 
289
    if current < enough_samples:
 
290
        return None
 
291
 
 
292
    if current > total:
 
293
        return None                     # wtf?
 
294
 
 
295
    elapsed = time.time() - start_time
 
296
 
 
297
    if elapsed < 2.0:                   # not enough time to estimate
 
298
        return None
 
299
    
 
300
    total_duration = float(elapsed) * float(total) / float(current)
 
301
 
 
302
    assert total_duration >= elapsed
 
303
 
 
304
    return total_duration - elapsed
 
305
 
 
306
 
 
307
def run_tests():
 
308
    import doctest
 
309
    result = doctest.testmod()
 
310
    if result[1] > 0:
 
311
        if result[0] == 0:
 
312
            print "All tests passed"
 
313
    else:
 
314
        print "No tests to run"
 
315
 
 
316
 
 
317
def demo():
 
318
    sleep = time.sleep
 
319
    
 
320
    print 'dumb-terminal test:'
 
321
    pb = DotsProgressBar()
 
322
    for i in range(100):
 
323
        pb.update('Leoparden', i, 99)
 
324
        sleep(0.1)
 
325
    sleep(1.5)
 
326
    pb.clear()
 
327
    sleep(1.5)
 
328
    
 
329
    print 'smart-terminal test:'
 
330
    pb = ProgressBar(show_pct=True, show_bar=True, show_spinner=False)
 
331
    for i in range(100):
 
332
        pb.update('Elephanten', i, 99)
 
333
        sleep(0.1)
 
334
    sleep(2)
 
335
    pb.clear()
 
336
    sleep(1)
 
337
 
 
338
    print 'done!'
 
339
 
 
340
if __name__ == "__main__":
 
341
    demo()