/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 breezy/progress.py

  • Committer: Jelmer Vernooij
  • Date: 2020-09-02 16:35:18 UTC
  • mto: (7490.40.109 work)
  • mto: This revision was merged to the branch mainline in revision 7526.
  • Revision ID: jelmer@jelmer.uk-20200902163518-sy9f4unbboljphgu
Handle duplicate directories entries for git.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/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
"""Progress indicators.
 
18
 
 
19
The usual way to use this is via breezy.ui.ui_factory.nested_progress_bar which
 
20
will manage a conceptual stack of nested activities.
 
21
"""
 
22
 
 
23
from __future__ import absolute_import
 
24
 
 
25
import time
 
26
import os
 
27
 
 
28
 
 
29
def _supports_progress(f):
 
30
    """Detect if we can use pretty progress bars on file F.
 
31
 
 
32
    If this returns true we expect that a human may be looking at that
 
33
    output, and that we can repaint a line to update it.
 
34
 
 
35
    This doesn't check the policy for whether we *should* use them.
 
36
    """
 
37
    isatty = getattr(f, 'isatty', None)
 
38
    if isatty is None:
 
39
        return False
 
40
    if not isatty():
 
41
        return False
 
42
    # The following case also handles Win32 - on that platform $TERM is
 
43
    # typically never set, so the case None is treated as a smart terminal,
 
44
    # not dumb.  <https://bugs.launchpad.net/bugs/334808>  win32 files do have
 
45
    # isatty methods that return true.
 
46
    if os.environ.get('TERM') == 'dumb':
 
47
        # e.g. emacs compile window
 
48
        return False
 
49
    return True
 
50
 
 
51
 
 
52
class ProgressTask(object):
 
53
    """Model component of a progress indicator.
 
54
 
 
55
    Most code that needs to indicate progress should update one of these,
 
56
    and it will in turn update the display, if one is present.
 
57
 
 
58
    Code updating the task may also set fields as hints about how to display
 
59
    it: show_pct, show_spinner, show_eta, show_count, show_bar.  UIs
 
60
    will not necessarily respect all these fields.
 
61
 
 
62
    The message given when updating a task must be unicode, not bytes.
 
63
 
 
64
    :ivar update_latency: The interval (in seconds) at which the PB should be
 
65
        updated.  Setting this to zero suggests every update should be shown
 
66
        synchronously.
 
67
 
 
68
    :ivar show_transport_activity: If true (default), transport activity
 
69
        will be shown when this task is drawn.  Disable it if you're sure
 
70
        that only irrelevant or uninteresting transport activity can occur
 
71
        during this task.
 
72
    """
 
73
 
 
74
    def __init__(self, parent_task=None, ui_factory=None, progress_view=None):
 
75
        """Construct a new progress task.
 
76
 
 
77
        :param parent_task: Enclosing ProgressTask or None.
 
78
 
 
79
        :param progress_view: ProgressView to display this ProgressTask.
 
80
 
 
81
        :param ui_factory: The UI factory that will display updates;
 
82
            deprecated in favor of passing progress_view directly.
 
83
 
 
84
        Normally you should not call this directly but rather through
 
85
        `ui_factory.nested_progress_bar`.
 
86
        """
 
87
        self._parent_task = parent_task
 
88
        self._last_update = 0
 
89
        self.total_cnt = None
 
90
        self.current_cnt = None
 
91
        self.msg = ''
 
92
        # TODO: deprecate passing ui_factory
 
93
        self.ui_factory = ui_factory
 
94
        self.progress_view = progress_view
 
95
        self.show_pct = False
 
96
        self.show_spinner = True
 
97
        self.show_eta = False,
 
98
        self.show_count = True
 
99
        self.show_bar = True
 
100
        self.update_latency = 0.1
 
101
        self.show_transport_activity = True
 
102
 
 
103
    def __repr__(self):
 
104
        return '%s(%r/%r, msg=%r)' % (
 
105
            self.__class__.__name__,
 
106
            self.current_cnt,
 
107
            self.total_cnt,
 
108
            self.msg)
 
109
 
 
110
    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
        self.msg = msg
 
116
        self.current_cnt = current_cnt
 
117
        if total_cnt:
 
118
            self.total_cnt = total_cnt
 
119
        if self.progress_view:
 
120
            self.progress_view.show_progress(self)
 
121
        else:
 
122
            self.ui_factory._progress_updated(self)
 
123
 
 
124
    def tick(self):
 
125
        self.update(self.msg)
 
126
 
 
127
    def finished(self):
 
128
        if self.progress_view:
 
129
            self.progress_view.task_finished(self)
 
130
        else:
 
131
            self.ui_factory._progress_finished(self)
 
132
 
 
133
    def make_sub_task(self):
 
134
        return ProgressTask(self, ui_factory=self.ui_factory,
 
135
                            progress_view=self.progress_view)
 
136
 
 
137
    def _overall_completion_fraction(self, child_fraction=0.0):
 
138
        """Return fractional completion of this task and its parents
 
139
 
 
140
        Returns None if no completion can be computed."""
 
141
        if self.current_cnt is not None and self.total_cnt:
 
142
            own_fraction = (float(self.current_cnt) +
 
143
                            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
    def __enter__(self):
 
169
        return self
 
170
 
 
171
    def __exit__(self, exc_type, exc_val, exc_tb):
 
172
        self.finished()
 
173
        return False
 
174
 
 
175
 
 
176
class DummyProgress(object):
 
177
    """Progress-bar standin that does nothing.
 
178
 
 
179
    This was previously often constructed by application code if no progress
 
180
    bar was explicitly passed in.  That's no longer recommended: instead, just
 
181
    create a progress task from the ui_factory.  This class can be used in
 
182
    test code that needs to fake a progress task for some reason.
 
183
    """
 
184
 
 
185
    def tick(self):
 
186
        pass
 
187
 
 
188
    def update(self, msg=None, current=None, total=None):
 
189
        pass
 
190
 
 
191
    def child_update(self, message, current, total):
 
192
        pass
 
193
 
 
194
    def clear(self):
 
195
        pass
 
196
 
 
197
    def child_progress(self, **kwargs):
 
198
        return DummyProgress(**kwargs)
 
199
 
 
200
 
 
201
def str_tdelta(delt):
 
202
    if delt is None:
 
203
        return "-:--:--"
 
204
    delt = int(round(delt))
 
205
    return '%d:%02d:%02d' % (delt / 3600,
 
206
                             (delt / 60) % 60,
 
207
                             delt % 60)
 
208
 
 
209
 
 
210
def get_eta(start_time, current, total, enough_samples=3, last_updates=None,
 
211
            n_recent=10):
 
212
    if start_time is None:
 
213
        return None
 
214
 
 
215
    if not total:
 
216
        return None
 
217
 
 
218
    if current < enough_samples:
 
219
        return None
 
220
 
 
221
    if current > total:
 
222
        return None                     # wtf?
 
223
 
 
224
    elapsed = time.time() - start_time
 
225
 
 
226
    if elapsed < 2.0:                   # not enough time to estimate
 
227
        return None
 
228
 
 
229
    total_duration = float(elapsed) * float(total) / float(current)
 
230
 
 
231
    if last_updates and len(last_updates) >= n_recent:
 
232
        avg = sum(last_updates) / float(len(last_updates))
 
233
        time_left = avg * (total - current)
 
234
 
 
235
        old_time_left = total_duration - elapsed
 
236
 
 
237
        # We could return the average, or some other value here
 
238
        return (time_left + old_time_left) / 2
 
239
 
 
240
    return total_duration - elapsed
 
241
 
 
242
 
 
243
class ProgressPhase(object):
 
244
    """Update progress object with the current phase"""
 
245
 
 
246
    def __init__(self, message, total, pb):
 
247
        object.__init__(self)
 
248
        self.pb = pb
 
249
        self.message = message
 
250
        self.total = total
 
251
        self.cur_phase = None
 
252
 
 
253
    def next_phase(self):
 
254
        if self.cur_phase is None:
 
255
            self.cur_phase = 0
 
256
        else:
 
257
            self.cur_phase += 1
 
258
        self.pb.update(self.message, self.cur_phase, self.total)