/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: Robert Collins
  • Date: 2010-05-06 23:41:35 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506234135-yivbzczw1sejxnxc
Lock methods on ``Tree``, ``Branch`` and ``Repository`` are now
expected to return an object which can be used to unlock them. This reduces
duplicate code when using cleanups. The previous 'tokens's returned by
``Branch.lock_write`` and ``Repository.lock_write`` are now attributes
on the result of the lock_write. ``repository.RepositoryWriteLockResult``
and ``branch.BranchWriteLockResult`` document this. (Robert Collins)

``log._get_info_for_log_files`` now takes an add_cleanup callable.
(Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/progress.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
 
17
18
"""Progress indicators.
18
19
 
19
 
The usual way to use this is via breezy.ui.ui_factory.nested_progress_bar which
 
20
The usual way to use this is via bzrlib.ui.ui_factory.nested_progress_bar which
20
21
will manage a conceptual stack of nested activities.
21
22
"""
22
23
 
23
 
from __future__ import absolute_import
24
24
 
 
25
import sys
25
26
import time
26
27
import os
27
28
 
28
29
 
 
30
from bzrlib.symbol_versioning import (
 
31
    deprecated_in,
 
32
    deprecated_method,
 
33
    )
 
34
 
 
35
 
29
36
def _supports_progress(f):
30
37
    """Detect if we can use pretty progress bars on file F.
31
38
 
58
65
    Code updating the task may also set fields as hints about how to display
59
66
    it: show_pct, show_spinner, show_eta, show_count, show_bar.  UIs
60
67
    will not necessarily respect all these fields.
61
 
 
62
 
    The message given when updating a task must be unicode, not bytes.
63
 
 
 
68
    
64
69
    :ivar update_latency: The interval (in seconds) at which the PB should be
65
70
        updated.  Setting this to zero suggests every update should be shown
66
71
        synchronously.
67
72
 
68
73
    :ivar show_transport_activity: If true (default), transport activity
69
 
        will be shown when this task is drawn.  Disable it if you're sure
 
74
        will be shown when this task is drawn.  Disable it if you're sure 
70
75
        that only irrelevant or uninteresting transport activity can occur
71
76
        during this task.
72
77
    """
78
83
 
79
84
        :param progress_view: ProgressView to display this ProgressTask.
80
85
 
81
 
        :param ui_factory: The UI factory that will display updates;
 
86
        :param ui_factory: The UI factory that will display updates; 
82
87
            deprecated in favor of passing progress_view directly.
83
88
 
84
89
        Normally you should not call this directly but rather through
108
113
            self.msg)
109
114
 
110
115
    def update(self, msg, current_cnt=None, total_cnt=None):
111
 
        """Report updated task message and if relevent progress counters
112
 
 
113
 
        The message given must be unicode, not a byte string.
114
 
        """
115
116
        self.msg = msg
116
117
        self.current_cnt = current_cnt
117
118
        if total_cnt:
132
133
 
133
134
    def make_sub_task(self):
134
135
        return ProgressTask(self, ui_factory=self.ui_factory,
135
 
                            progress_view=self.progress_view)
 
136
            progress_view=self.progress_view)
136
137
 
137
138
    def _overall_completion_fraction(self, child_fraction=0.0):
138
139
        """Return fractional completion of this task and its parents
139
140
 
140
141
        Returns None if no completion can be computed."""
141
142
        if self.current_cnt is not None and self.total_cnt:
142
 
            own_fraction = (float(self.current_cnt) +
143
 
                            child_fraction) / self.total_cnt
 
143
            own_fraction = (float(self.current_cnt) + child_fraction) / self.total_cnt
144
144
        else:
145
145
            # if this task has no estimation, it just passes on directly
146
146
            # whatever the child has measured...
152
152
                own_fraction = 0.0
153
153
            return self._parent_task._overall_completion_fraction(own_fraction)
154
154
 
 
155
    @deprecated_method(deprecated_in((2, 1, 0)))
 
156
    def note(self, fmt_string, *args):
 
157
        """Record a note without disrupting the progress bar.
 
158
        
 
159
        Deprecated: use ui_factory.note() instead or bzrlib.trace.  Note that
 
160
        ui_factory.note takes just one string as the argument, not a format
 
161
        string and arguments.
 
162
        """
 
163
        if args:
 
164
            self.ui_factory.note(fmt_string % args)
 
165
        else:
 
166
            self.ui_factory.note(fmt_string)
 
167
 
155
168
    def clear(self):
156
169
        # TODO: deprecate this method; the model object shouldn't be concerned
157
170
        # with whether it's shown or not.  Most callers use this because they
165
178
        else:
166
179
            self.ui_factory.clear_term()
167
180
 
168
 
    def __enter__(self):
169
 
        return self
170
 
 
171
 
    def __exit__(self, exc_type, exc_val, exc_tb):
172
 
        self.finished()
173
 
        return False
 
181
 
 
182
# NOTE: This is also deprecated; you should provide a ProgressView instead.
 
183
class _BaseProgressBar(object):
 
184
 
 
185
    def __init__(self,
 
186
                 to_file=None,
 
187
                 show_pct=False,
 
188
                 show_spinner=False,
 
189
                 show_eta=False,
 
190
                 show_bar=True,
 
191
                 show_count=True,
 
192
                 to_messages_file=None,
 
193
                 _stack=None):
 
194
        object.__init__(self)
 
195
        if to_file is None:
 
196
            to_file = sys.stderr
 
197
        if to_messages_file is None:
 
198
            to_messages_file = sys.stdout
 
199
        self.to_file = to_file
 
200
        self.to_messages_file = to_messages_file
 
201
        self.last_msg = None
 
202
        self.last_cnt = None
 
203
        self.last_total = None
 
204
        self.show_pct = show_pct
 
205
        self.show_spinner = show_spinner
 
206
        self.show_eta = show_eta
 
207
        self.show_bar = show_bar
 
208
        self.show_count = show_count
 
209
        self._stack = _stack
 
210
        # seed throttler
 
211
        self.MIN_PAUSE = 0.1 # seconds
 
212
        now = time.time()
 
213
        # starting now
 
214
        self.start_time = now
 
215
        # next update should not throttle
 
216
        self.last_update = now - self.MIN_PAUSE - 1
 
217
 
 
218
    def finished(self):
 
219
        """Return this bar to its progress stack."""
 
220
        self.clear()
 
221
        self._stack.return_pb(self)
 
222
 
 
223
    def note(self, fmt_string, *args, **kwargs):
 
224
        """Record a note without disrupting the progress bar."""
 
225
        self.clear()
 
226
        self.to_messages_file.write(fmt_string % args)
 
227
        self.to_messages_file.write('\n')
174
228
 
175
229
 
176
230
class DummyProgress(object):
194
248
    def clear(self):
195
249
        pass
196
250
 
 
251
    def note(self, fmt_string, *args, **kwargs):
 
252
        """See _BaseProgressBar.note()."""
 
253
 
197
254
    def child_progress(self, **kwargs):
198
255
        return DummyProgress(**kwargs)
199
256
 
202
259
    if delt is None:
203
260
        return "-:--:--"
204
261
    delt = int(round(delt))
205
 
    return '%d:%02d:%02d' % (delt / 3600,
206
 
                             (delt / 60) % 60,
 
262
    return '%d:%02d:%02d' % (delt/3600,
 
263
                             (delt/60) % 60,
207
264
                             delt % 60)
208
265
 
209
266
 
210
 
def get_eta(start_time, current, total, enough_samples=3, last_updates=None,
211
 
            n_recent=10):
 
267
def get_eta(start_time, current, total, enough_samples=3, last_updates=None, n_recent=10):
212
268
    if start_time is None:
213
269
        return None
214
270
 
242
298
 
243
299
class ProgressPhase(object):
244
300
    """Update progress object with the current phase"""
245
 
 
246
301
    def __init__(self, message, total, pb):
247
302
        object.__init__(self)
248
303
        self.pb = pb