← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/progress.py

Add a group cache to decompression, 5 times faster than knit at decompression when accessing everything in a group.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/progress.py
1
 
# Copyright (C) 2005-2010 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.
22
 
"""
23
 
 
24
 
 
25
 
import sys
26
 
import time
27
 
import os
28
 
 
29
 
 
30
 
from bzrlib.symbol_versioning import (
31
 
    deprecated_in,
32
 
    deprecated_method,
33
 
    )
34
 
 
35
 
 
36
 
def _supports_progress(f):
37
 
    """Detect if we can use pretty progress bars on file F.
38
 
 
39
 
    If this returns true we expect that a human may be looking at that
40
 
    output, and that we can repaint a line to update it.
41
 
 
42
 
    This doesn't check the policy for whether we *should* use them.
43
 
    """
44
 
    isatty = getattr(f, 'isatty', None)
45
 
    if isatty is None:
46
 
        return False
47
 
    if not isatty():
48
 
        return False
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.
53
 
    if os.environ.get('TERM') == 'dumb':
54
 
        # e.g. emacs compile window
55
 
        return False
56
 
    return True
57
 
 
58
 
 
59
 
class ProgressTask(object):
60
 
    """Model component of a progress indicator.
61
 
 
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.
64
 
 
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.
68
 
    
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
71
 
        synchronously.
72
 
 
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
76
 
        during this task.
77
 
    """
78
 
 
79
 
    def __init__(self, parent_task=None, ui_factory=None, progress_view=None):
80
 
        """Construct a new progress task.
81
 
 
82
 
        :param parent_task: Enclosing ProgressTask or None.
83
 
 
84
 
        :param progress_view: ProgressView to display this ProgressTask.
85
 
 
86
 
        :param ui_factory: The UI factory that will display updates; 
87
 
            deprecated in favor of passing progress_view directly.
88
 
 
89
 
        Normally you should not call this directly but rather through
90
 
        `ui_factory.nested_progress_bar`.
91
 
        """
92
 
        self._parent_task = parent_task
93
 
        self._last_update = 0
94
 
        self.total_cnt = None
95
 
        self.current_cnt = None
96
 
        self.msg = ''
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
104
 
        self.show_bar = True
105
 
        self.update_latency = 0.1
106
 
        self.show_transport_activity = True
107
 
 
108
 
    def __repr__(self):
109
 
        return '%s(%r/%r, msg=%r)' % (
110
 
            self.__class__.__name__,
111
 
            self.current_cnt,
112
 
            self.total_cnt,
113
 
            self.msg)
114
 
 
115
 
    def update(self, msg, current_cnt=None, total_cnt=None):
116
 
        self.msg = msg
117
 
        self.current_cnt = current_cnt
118
 
        if total_cnt:
119
 
            self.total_cnt = total_cnt
120
 
        if self.progress_view:
121
 
            self.progress_view.show_progress(self)
122
 
        else:
123
 
            self.ui_factory._progress_updated(self)
124
 
 
125
 
    def tick(self):
126
 
        self.update(self.msg)
127
 
 
128
 
    def finished(self):
129
 
        if self.progress_view:
130
 
            self.progress_view.task_finished(self)
131
 
        else:
132
 
            self.ui_factory._progress_finished(self)
133
 
 
134
 
    def make_sub_task(self):
135
 
        return ProgressTask(self, ui_factory=self.ui_factory,
136
 
            progress_view=self.progress_view)
137
 
 
138
 
    def _overall_completion_fraction(self, child_fraction=0.0):
139
 
        """Return fractional completion of this task and its parents
140
 
 
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
144
 
        else:
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:
149
 
            return own_fraction
150
 
        else:
151
 
            if own_fraction is None:
152
 
                own_fraction = 0.0
153
 
            return self._parent_task._overall_completion_fraction(own_fraction)
154
 
 
155
 
    def clear(self):
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. --
162
 
        # mbp 20090623
163
 
        if self.progress_view:
164
 
            self.progress_view.clear()
165
 
        else:
166
 
            self.ui_factory.clear_term()
167
 
 
168
 
 
169
 
class DummyProgress(object):
170
 
    """Progress-bar standin that does nothing.
171
 
 
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.
176
 
    """
177
 
 
178
 
    def tick(self):
179
 
        pass
180
 
 
181
 
    def update(self, msg=None, current=None, total=None):
182
 
        pass
183
 
 
184
 
    def child_update(self, message, current, total):
185
 
        pass
186
 
 
187
 
    def clear(self):
188
 
        pass
189
 
 
190
 
    def child_progress(self, **kwargs):
191
 
        return DummyProgress(**kwargs)
192
 
 
193
 
 
194
 
def str_tdelta(delt):
195
 
    if delt is None:
196
 
        return "-:--:--"
197
 
    delt = int(round(delt))
198
 
    return '%d:%02d:%02d' % (delt/3600,
199
 
                             (delt/60) % 60,
200
 
                             delt % 60)
201
 
 
202
 
 
203
 
def get_eta(start_time, current, total, enough_samples=3, last_updates=None, n_recent=10):
204
 
    if start_time is None:
205
 
        return None
206
 
 
207
 
    if not total:
208
 
        return None
209
 
 
210
 
    if current < enough_samples:
211
 
        return None
212
 
 
213
 
    if current > total:
214
 
        return None                     # wtf?
215
 
 
216
 
    elapsed = time.time() - start_time
217
 
 
218
 
    if elapsed < 2.0:                   # not enough time to estimate
219
 
        return None
220
 
 
221
 
    total_duration = float(elapsed) * float(total) / float(current)
222
 
 
223
 
    if last_updates and len(last_updates) >= n_recent:
224
 
        avg = sum(last_updates) / float(len(last_updates))
225
 
        time_left = avg * (total - current)
226
 
 
227
 
        old_time_left = total_duration - elapsed
228
 
 
229
 
        # We could return the average, or some other value here
230
 
        return (time_left + old_time_left) / 2
231
 
 
232
 
    return total_duration - elapsed
233
 
 
234
 
 
235
 
class ProgressPhase(object):
236
 
    """Update progress object with the current phase"""
237
 
    def __init__(self, message, total, pb):
238
 
        object.__init__(self)
239
 
        self.pb = pb
240
 
        self.message = message
241
 
        self.total = total
242
 
        self.cur_phase = None
243
 
 
244
 
    def next_phase(self):
245
 
        if self.cur_phase is None:
246
 
            self.cur_phase = 0
247
 
        else:
248
 
            self.cur_phase += 1
249
 
        self.pb.update(self.message, self.cur_phase, self.total)