← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/progress.py

  • Committer: John Arbash Meinel
  • Date: 2011-05-11 11:35:28 UTC
  • mto: This revision was merged to the branch mainline in revision 5851.
  • Revision ID: john@arbash-meinel.com-20110511113528-qepibuwxicjrbb2h
Break compatibility with python <2.6.

This includes auditing the code for places where we were doing
explicit 'sys.version' checks and removing them as appropriate.

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)