← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/progress.py

  • Committer: Matt Nordhoff
  • Date: 2009-06-23 05:12:07 UTC
  • mto: This revision was merged to the branch mainline in revision 4474.
  • Revision ID: mnordhoff@mattnordhoff.com-20090623051207-fksdtbzkwtnrw9dd
Update _add_text docstrings that still referred to add_text.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/progress.py
25
25
import sys
26
26
import time
27
27
import os
 
28
import warnings
28
29
 
29
30
 
30
31
from bzrlib import (
31
32
    errors,
 
33
    osutils,
 
34
    trace,
 
35
    ui,
32
36
    )
33
37
from bzrlib.trace import mutter
34
38
from bzrlib.symbol_versioning import (
35
 
    deprecated_function,
36
39
    deprecated_in,
 
40
    deprecated_method,
37
41
    )
38
42
 
39
43
 
40
44
def _supports_progress(f):
41
 
    """Detect if we can use pretty progress bars on file F.
 
45
    """Detect if we can use pretty progress bars on the output stream f.
42
46
 
43
47
    If this returns true we expect that a human may be looking at that
44
48
    output, and that we can repaint a line to update it.
45
 
 
46
 
    This doesn't check the policy for whether we *should* use them.
47
49
    """
48
50
    isatty = getattr(f, 'isatty', None)
49
51
    if isatty is None:
50
52
        return False
51
53
    if not isatty():
52
54
        return False
53
 
    # The following case also handles Win32 - on that platform $TERM is
54
 
    # typically never set, so the case None is treated as a smart terminal,
55
 
    # not dumb.  <https://bugs.launchpad.net/bugs/334808>  win32 files do have
56
 
    # isatty methods that return true.
57
55
    if os.environ.get('TERM') == 'dumb':
58
56
        # e.g. emacs compile window
59
57
        return False
69
67
    Code updating the task may also set fields as hints about how to display
70
68
    it: show_pct, show_spinner, show_eta, show_count, show_bar.  UIs
71
69
    will not necessarily respect all these fields.
72
 
    
73
 
    :ivar update_latency: The interval (in seconds) at which the PB should be
74
 
        updated.  Setting this to zero suggests every update should be shown
75
 
        synchronously.
76
 
 
77
 
    :ivar show_transport_activity: If true (default), transport activity
78
 
        will be shown when this task is drawn.  Disable it if you're sure 
79
 
        that only irrelevant or uninteresting transport activity can occur
80
 
        during this task.
81
70
    """
82
71
 
83
 
    def __init__(self, parent_task=None, ui_factory=None, progress_view=None):
 
72
    def __init__(self, parent_task=None, ui_factory=None):
84
73
        """Construct a new progress task.
85
74
 
86
 
        :param parent_task: Enclosing ProgressTask or None.
87
 
 
88
 
        :param progress_view: ProgressView to display this ProgressTask.
89
 
 
90
 
        :param ui_factory: The UI factory that will display updates; 
91
 
            deprecated in favor of passing progress_view directly.
92
 
 
93
75
        Normally you should not call this directly but rather through
94
76
        `ui_factory.nested_progress_bar`.
95
77
        """
98
80
        self.total_cnt = None
99
81
        self.current_cnt = None
100
82
        self.msg = ''
101
 
        # TODO: deprecate passing ui_factory
102
83
        self.ui_factory = ui_factory
103
 
        self.progress_view = progress_view
104
84
        self.show_pct = False
105
85
        self.show_spinner = True
106
86
        self.show_eta = False,
107
87
        self.show_count = True
108
88
        self.show_bar = True
109
 
        self.update_latency = 0.1
110
 
        self.show_transport_activity = True
111
89
 
112
90
    def __repr__(self):
113
91
        return '%s(%r/%r, msg=%r)' % (
121
99
        self.current_cnt = current_cnt
122
100
        if total_cnt:
123
101
            self.total_cnt = total_cnt
124
 
        if self.progress_view:
125
 
            self.progress_view.show_progress(self)
126
 
        else:
127
 
            self.ui_factory._progress_updated(self)
 
102
        self.ui_factory._progress_updated(self)
128
103
 
129
104
    def tick(self):
130
105
        self.update(self.msg)
131
106
 
132
107
    def finished(self):
133
 
        if self.progress_view:
134
 
            self.progress_view.task_finished(self)
135
 
        else:
136
 
            self.ui_factory._progress_finished(self)
 
108
        self.ui_factory._progress_finished(self)
137
109
 
138
110
    def make_sub_task(self):
139
 
        return ProgressTask(self, ui_factory=self.ui_factory,
140
 
            progress_view=self.progress_view)
 
111
        return ProgressTask(self, self.ui_factory)
141
112
 
142
113
    def _overall_completion_fraction(self, child_fraction=0.0):
143
114
        """Return fractional completion of this task and its parents
166
137
 
167
138
    def clear(self):
168
139
        # XXX: shouldn't be here; put it in mutter or the ui instead
169
 
        if self.progress_view:
170
 
            self.progress_view.clear()
171
 
        else:
172
 
            self.ui_factory.clear_term()
173
 
 
174
 
 
175
 
@deprecated_function(deprecated_in((1, 16, 0)))
 
140
        self.ui_factory.clear_term()
 
141
 
 
142
 
176
143
def ProgressBar(to_file=None, **kwargs):
177
 
    """Construct a progress bar.
178
 
 
179
 
    Deprecated; ask the ui_factory for a progress task instead.
180
 
    """
 
144
    """Abstract factory"""
181
145
    if to_file is None:
182
146
        to_file = sys.stderr
183
147
    requested_bar_type = os.environ.get('BZR_PROGRESS_BAR')
199
163
        return _progress_bar_types[requested_bar_type](to_file=to_file, **kwargs)
200
164
 
201
165
 
202
 
# NOTE: This is also deprecated; you should provide a ProgressView instead.
 
166
class ProgressBarStack(object):
 
167
    """A stack of progress bars.
 
168
 
 
169
    This class is deprecated: instead, ask the ui factory for a new progress
 
170
    task and finish it when it's done.
 
171
    """
 
172
 
 
173
    @deprecated_method(deprecated_in((1, 12, 0)))
 
174
    def __init__(self,
 
175
                 to_file=None,
 
176
                 show_pct=False,
 
177
                 show_spinner=True,
 
178
                 show_eta=False,
 
179
                 show_bar=True,
 
180
                 show_count=True,
 
181
                 to_messages_file=None,
 
182
                 klass=None):
 
183
        """Setup the stack with the parameters the progress bars should have."""
 
184
        if to_file is None:
 
185
            to_file = sys.stderr
 
186
        if to_messages_file is None:
 
187
            to_messages_file = sys.stdout
 
188
        self._to_file = to_file
 
189
        self._show_pct = show_pct
 
190
        self._show_spinner = show_spinner
 
191
        self._show_eta = show_eta
 
192
        self._show_bar = show_bar
 
193
        self._show_count = show_count
 
194
        self._to_messages_file = to_messages_file
 
195
        self._stack = []
 
196
        self._klass = klass or ProgressBar
 
197
 
 
198
    def top(self):
 
199
        if len(self._stack) != 0:
 
200
            return self._stack[-1]
 
201
        else:
 
202
            return None
 
203
 
 
204
    def bottom(self):
 
205
        if len(self._stack) != 0:
 
206
            return self._stack[0]
 
207
        else:
 
208
            return None
 
209
 
 
210
    def get_nested(self):
 
211
        """Return a nested progress bar."""
 
212
        if len(self._stack) == 0:
 
213
            func = self._klass
 
214
        else:
 
215
            func = self.top().child_progress
 
216
        new_bar = func(to_file=self._to_file,
 
217
                       show_pct=self._show_pct,
 
218
                       show_spinner=self._show_spinner,
 
219
                       show_eta=self._show_eta,
 
220
                       show_bar=self._show_bar,
 
221
                       show_count=self._show_count,
 
222
                       to_messages_file=self._to_messages_file,
 
223
                       _stack=self)
 
224
        self._stack.append(new_bar)
 
225
        return new_bar
 
226
 
 
227
    def return_pb(self, bar):
 
228
        """Return bar after its been used."""
 
229
        if bar is not self._stack[-1]:
 
230
            warnings.warn("%r is not currently active" % (bar,))
 
231
        else:
 
232
            self._stack.pop()
 
233
 
 
234
 
203
235
class _BaseProgressBar(object):
204
236
 
205
237
    def __init__(self,
246
278
        self.to_messages_file.write(fmt_string % args)
247
279
        self.to_messages_file.write('\n')
248
280
 
249
 
    @deprecated_function(deprecated_in((1, 16, 0)))
250
281
    def child_progress(self, **kwargs):
251
282
        return ChildProgress(**kwargs)
252
283
 
278
309
 
279
310
class DotsProgressBar(_BaseProgressBar):
280
311
 
281
 
    @deprecated_function(deprecated_in((1, 16, 0)))
282
312
    def __init__(self, **kwargs):
283
313
        _BaseProgressBar.__init__(self, **kwargs)
284
314
        self.last_msg = None
305
335
        self.tick()
306
336
 
307
337
 
 
338
 
 
339
 
308
340
class TTYProgressBar(_BaseProgressBar):
309
341
    """Progress bar display object.
310
342
 
327
359
    """
328
360
    SPIN_CHARS = r'/-\|'
329
361
 
330
 
    @deprecated_function(deprecated_in((1, 16, 0)))
 
362
 
331
363
    def __init__(self, **kwargs):
332
364
        from bzrlib.osutils import terminal_width
333
365
        _BaseProgressBar.__init__(self, **kwargs)
488
520
 
489
521
 
490
522
 
491
 
# DEPRECATED
 
523
 
492
524
class ChildProgress(_BaseProgressBar):
493
525
    """A progress indicator that pushes its data to the parent"""
494
526
 
495
 
    @deprecated_function(deprecated_in((1, 16, 0)))
496
527
    def __init__(self, _stack, **kwargs):
497
528
        _BaseProgressBar.__init__(self, _stack=_stack, **kwargs)
498
529
        self.parent = _stack.top()
534
565
        self.parent.note(*args, **kwargs)
535
566
 
536
567
 
 
568
class InstrumentedProgress(TTYProgressBar):
 
569
    """TTYProgress variant that tracks outcomes"""
 
570
 
 
571
    def __init__(self, *args, **kwargs):
 
572
        self.always_throttled = True
 
573
        self.never_throttle = False
 
574
        TTYProgressBar.__init__(self, *args, **kwargs)
 
575
 
 
576
    def throttle(self, old_message):
 
577
        if self.never_throttle:
 
578
            result =  False
 
579
        else:
 
580
            result = TTYProgressBar.throttle(self, old_message)
 
581
        if result is False:
 
582
            self.always_throttled = False
 
583
 
 
584
 
537
585
def str_tdelta(delt):
538
586
    if delt is None:
539
587
        return "-:--:--"