| # progress.py show progress bars for some actions |
| # |
| # Copyright (C) 2010 Augie Fackler <durin42@gmail.com> |
| # |
| # This software may be used and distributed according to the terms of the |
| # GNU General Public License version 2 or any later version. |
| |
| """show progress bars for some actions |
| |
| This extension uses the progress information logged by hg commands |
| to draw progress bars that are as informative as possible. Some progress |
| bars only offer indeterminate information, while others have a definite |
| end point. |
| |
| The following settings are available:: |
| |
| [progress] |
| delay = 3 # number of seconds (float) before showing the progress bar |
| changedelay = 1 # changedelay: minimum delay before showing a new topic. |
| # If set to less than 3 * refresh, that value will |
| # be used instead. |
| refresh = 0.1 # time in seconds between refreshes of the progress bar |
| format = topic bar number estimate # format of the progress bar |
| width = <none> # if set, the maximum width of the progress information |
| # (that is, min(width, term width) will be used) |
| clear-complete = True # clear the progress bar after it's done |
| disable = False # if true, don't show a progress bar |
| assume-tty = False # if true, ALWAYS show a progress bar, unless |
| # disable is given |
| |
| Valid entries for the format field are topic, bar, number, unit, |
| estimate, speed, and item. item defaults to the last 20 characters of |
| the item, but this can be changed by adding either ``-<num>`` which |
| would take the last num characters, or ``+<num>`` for the first num |
| characters. |
| """ |
| |
| import sys |
| import time |
| |
| from mercurial.i18n import _ |
| testedwith = 'internal' |
| |
| def spacejoin(*args): |
| return ' '.join(s for s in args if s) |
| |
| def shouldprint(ui): |
| return ui._isatty(sys.stderr) or ui.configbool('progress', 'assume-tty') |
| |
| def fmtremaining(seconds): |
| if seconds < 60: |
| # i18n: format XX seconds as "XXs" |
| return _("%02ds") % (seconds) |
| minutes = seconds // 60 |
| if minutes < 60: |
| seconds -= minutes * 60 |
| # i18n: format X minutes and YY seconds as "XmYYs" |
| return _("%dm%02ds") % (minutes, seconds) |
| # we're going to ignore seconds in this case |
| minutes += 1 |
| hours = minutes // 60 |
| minutes -= hours * 60 |
| if hours < 30: |
| # i18n: format X hours and YY minutes as "XhYYm" |
| return _("%dh%02dm") % (hours, minutes) |
| # we're going to ignore minutes in this case |
| hours += 1 |
| days = hours // 24 |
| hours -= days * 24 |
| if days < 15: |
| # i18n: format X days and YY hours as "XdYYh" |
| return _("%dd%02dh") % (days, hours) |
| # we're going to ignore hours in this case |
| days += 1 |
| weeks = days // 7 |
| days -= weeks * 7 |
| if weeks < 55: |
| # i18n: format X weeks and YY days as "XwYYd" |
| return _("%dw%02dd") % (weeks, days) |
| # we're going to ignore days and treat a year as 52 weeks |
| weeks += 1 |
| years = weeks // 52 |
| weeks -= years * 52 |
| # i18n: format X years and YY weeks as "XyYYw" |
| return _("%dy%02dw") % (years, weeks) |
| |
| class progbar(object): |
| def __init__(self, ui): |
| self.ui = ui |
| self.resetstate() |
| |
| def resetstate(self): |
| self.topics = [] |
| self.topicstates = {} |
| self.starttimes = {} |
| self.startvals = {} |
| self.printed = False |
| self.lastprint = time.time() + float(self.ui.config( |
| 'progress', 'delay', default=3)) |
| self.lasttopic = None |
| self.indetcount = 0 |
| self.refresh = float(self.ui.config( |
| 'progress', 'refresh', default=0.1)) |
| self.changedelay = max(3 * self.refresh, |
| float(self.ui.config( |
| 'progress', 'changedelay', default=1))) |
| self.order = self.ui.configlist( |
| 'progress', 'format', |
| default=['topic', 'bar', 'number', 'estimate']) |
| |
| def show(self, now, topic, pos, item, unit, total): |
| if not shouldprint(self.ui): |
| return |
| termwidth = self.width() |
| self.printed = True |
| head = '' |
| needprogress = False |
| tail = '' |
| for indicator in self.order: |
| add = '' |
| if indicator == 'topic': |
| add = topic |
| elif indicator == 'number': |
| if total: |
| add = ('% ' + str(len(str(total))) + |
| 's/%s') % (pos, total) |
| else: |
| add = str(pos) |
| elif indicator.startswith('item') and item: |
| slice = 'end' |
| if '-' in indicator: |
| wid = int(indicator.split('-')[1]) |
| elif '+' in indicator: |
| slice = 'beginning' |
| wid = int(indicator.split('+')[1]) |
| else: |
| wid = 20 |
| if slice == 'end': |
| add = item[-wid:] |
| else: |
| add = item[:wid] |
| add += (wid - len(add)) * ' ' |
| elif indicator == 'bar': |
| add = '' |
| needprogress = True |
| elif indicator == 'unit' and unit: |
| add = unit |
| elif indicator == 'estimate': |
| add = self.estimate(topic, pos, total, now) |
| elif indicator == 'speed': |
| add = self.speed(topic, pos, unit, now) |
| if not needprogress: |
| head = spacejoin(head, add) |
| else: |
| tail = spacejoin(tail, add) |
| if needprogress: |
| used = 0 |
| if head: |
| used += len(head) + 1 |
| if tail: |
| used += len(tail) + 1 |
| progwidth = termwidth - used - 3 |
| if total and pos <= total: |
| amt = pos * progwidth // total |
| bar = '=' * (amt - 1) |
| if amt > 0: |
| bar += '>' |
| bar += ' ' * (progwidth - amt) |
| else: |
| progwidth -= 3 |
| self.indetcount += 1 |
| # mod the count by twice the width so we can make the |
| # cursor bounce between the right and left sides |
| amt = self.indetcount % (2 * progwidth) |
| amt -= progwidth |
| bar = (' ' * int(progwidth - abs(amt)) + '<=>' + |
| ' ' * int(abs(amt))) |
| prog = ''.join(('[', bar , ']')) |
| out = spacejoin(head, prog, tail) |
| else: |
| out = spacejoin(head, tail) |
| sys.stderr.write('\r' + out[:termwidth]) |
| self.lasttopic = topic |
| sys.stderr.flush() |
| |
| def clear(self): |
| if not shouldprint(self.ui): |
| return |
| sys.stderr.write('\r%s\r' % (' ' * self.width())) |
| |
| def complete(self): |
| if not shouldprint(self.ui): |
| return |
| if self.ui.configbool('progress', 'clear-complete', default=True): |
| self.clear() |
| else: |
| sys.stderr.write('\n') |
| sys.stderr.flush() |
| |
| def width(self): |
| tw = self.ui.termwidth() |
| return min(int(self.ui.config('progress', 'width', default=tw)), tw) |
| |
| def estimate(self, topic, pos, total, now): |
| if total is None: |
| return '' |
| initialpos = self.startvals[topic] |
| target = total - initialpos |
| delta = pos - initialpos |
| if delta > 0: |
| elapsed = now - self.starttimes[topic] |
| if elapsed > float( |
| self.ui.config('progress', 'estimate', default=2)): |
| seconds = (elapsed * (target - delta)) // delta + 1 |
| return fmtremaining(seconds) |
| return '' |
| |
| def speed(self, topic, pos, unit, now): |
| initialpos = self.startvals[topic] |
| delta = pos - initialpos |
| elapsed = now - self.starttimes[topic] |
| if elapsed > float( |
| self.ui.config('progress', 'estimate', default=2)): |
| return _('%d %s/sec') % (delta / elapsed, unit) |
| return '' |
| |
| def progress(self, topic, pos, item='', unit='', total=None): |
| now = time.time() |
| if pos is None: |
| self.starttimes.pop(topic, None) |
| self.startvals.pop(topic, None) |
| self.topicstates.pop(topic, None) |
| # reset the progress bar if this is the outermost topic |
| if self.topics and self.topics[0] == topic and self.printed: |
| self.complete() |
| self.resetstate() |
| # truncate the list of topics assuming all topics within |
| # this one are also closed |
| if topic in self.topics: |
| self.topics = self.topics[:self.topics.index(topic)] |
| else: |
| if topic not in self.topics: |
| self.starttimes[topic] = now |
| self.startvals[topic] = pos |
| self.topics.append(topic) |
| self.topicstates[topic] = pos, item, unit, total |
| if now - self.lastprint >= self.refresh and self.topics: |
| if (self.lasttopic is None # first time we printed |
| # not a topic change |
| or topic == self.lasttopic |
| # it's been long enough we should print anyway |
| or now - self.lastprint >= self.changedelay): |
| self.lastprint = now |
| self.show(now, topic, *self.topicstates[topic]) |
| |
| _singleton = None |
| |
| def uisetup(ui): |
| global _singleton |
| class progressui(ui.__class__): |
| _progbar = None |
| |
| def _quiet(self): |
| return self.debugflag or self.quiet |
| |
| def progress(self, *args, **opts): |
| if not self._quiet(): |
| self._progbar.progress(*args, **opts) |
| return super(progressui, self).progress(*args, **opts) |
| |
| def write(self, *args, **opts): |
| if not self._quiet() and self._progbar.printed: |
| self._progbar.clear() |
| return super(progressui, self).write(*args, **opts) |
| |
| def write_err(self, *args, **opts): |
| if not self._quiet() and self._progbar.printed: |
| self._progbar.clear() |
| return super(progressui, self).write_err(*args, **opts) |
| |
| # Apps that derive a class from ui.ui() can use |
| # setconfig('progress', 'disable', 'True') to disable this extension |
| if ui.configbool('progress', 'disable'): |
| return |
| if shouldprint(ui) and not ui.debugflag and not ui.quiet: |
| ui.__class__ = progressui |
| # we instantiate one globally shared progress bar to avoid |
| # competing progress bars when multiple UI objects get created |
| if not progressui._progbar: |
| if _singleton is None: |
| _singleton = progbar(ui) |
| progressui._progbar = _singleton |
| |
| def reposetup(ui, repo): |
| uisetup(repo.ui) |
