configitems: register the 'progress.estimate' config

mercurial/configitems.py

@@ -1,207 +1,210 b''
 # configitems.py - centralized declaration of configuration option
 #
 #  Copyright 2017 Pierre-Yves David <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import functools
 
 from . import (
     error,
 )
 
 def loadconfigtable(ui, extname, configtable):
     """update config item known to the ui with the extension ones"""
     for section, items in configtable.items():
         knownitems = ui._knownconfig.setdefault(section, {})
         knownkeys = set(knownitems)
         newkeys = set(items)
         for key in sorted(knownkeys & newkeys):
             msg = "extension '%s' overwrite config item '%s.%s'"
             msg %= (extname, section, key)
             ui.develwarn(msg, config='warn-config')
 
         knownitems.update(items)
 
 class configitem(object):
     """represent a known config item
 
     :section: the official config section where to find this item,
        :name: the official name within the section,
     :default: default value for this item,
     """
 
     def __init__(self, section, name, default=None):
         self.section = section
         self.name = name
         self.default = default
 
 coreitems = {}
 
 def _register(configtable, *args, **kwargs):
     item = configitem(*args, **kwargs)
     section = configtable.setdefault(item.section, {})
     if item.name in section:
         msg = "duplicated config item registration for '%s.%s'"
         raise error.ProgrammingError(msg % (item.section, item.name))
     section[item.name] = item
 
 # Registering actual config items
 
 def getitemregister(configtable):
     return functools.partial(_register, configtable)
 
 coreconfigitem = getitemregister(coreitems)
 
 coreconfigitem('auth', 'cookiefile',
     default=None,
 )
 # bookmarks.pushing: internal hack for discovery
 coreconfigitem('bookmarks', 'pushing',
     default=list,
 )
 # bundle.mainreporoot: internal hack for bundlerepo
 coreconfigitem('bundle', 'mainreporoot',
     default='',
 )
 # bundle.reorder: experimental config
 coreconfigitem('bundle', 'reorder',
     default='auto',
 )
 coreconfigitem('color', 'mode',
     default='auto',
 )
 coreconfigitem('devel', 'all-warnings',
     default=False,
 )
 coreconfigitem('devel', 'bundle2.debug',
     default=False,
 )
 coreconfigitem('devel', 'check-locks',
     default=False,
 )
 coreconfigitem('devel', 'check-relroot',
     default=False,
 )
 coreconfigitem('devel', 'disableloaddefaultcerts',
     default=False,
 )
 coreconfigitem('devel', 'legacy.exchange',
     default=list,
 )
 coreconfigitem('devel', 'servercafile',
     default='',
 )
 coreconfigitem('devel', 'serverexactprotocol',
     default='',
 )
 coreconfigitem('devel', 'serverrequirecert',
     default=False,
 )
 coreconfigitem('devel', 'strip-obsmarkers',
     default=True,
 )
 coreconfigitem('format', 'aggressivemergedeltas',
     default=False,
 )
 coreconfigitem('format', 'chunkcachesize',
     default=None,
 )
 coreconfigitem('format', 'dotencode',
     default=True,
 )
 coreconfigitem('format', 'generaldelta',
     default=False,
 )
 coreconfigitem('format', 'manifestcachesize',
     default=None,
 )
 coreconfigitem('format', 'maxchainlen',
     default=None,
 )
 coreconfigitem('format', 'obsstore-version',
     default=None,
 )
 coreconfigitem('format', 'usefncache',
     default=True,
 )
 coreconfigitem('format', 'usegeneraldelta',
     default=True,
 )
 coreconfigitem('format', 'usestore',
     default=True,
 )
 coreconfigitem('hostsecurity', 'ciphers',
     default=None,
 )
 coreconfigitem('hostsecurity', 'disabletls10warning',
     default=False,
 )
 coreconfigitem('patch', 'eol',
     default='strict',
 )
 coreconfigitem('patch', 'fuzz',
     default=2,
 )
 coreconfigitem('progress', 'assume-tty',
     default=False,
 )
 coreconfigitem('progress', 'clear-complete',
     default=True,
 )
+coreconfigitem('progress', 'estimate',
+    default=2,
+)
 coreconfigitem('server', 'bundle1',
     default=True,
 )
 coreconfigitem('server', 'bundle1gd',
     default=None,
 )
 coreconfigitem('server', 'compressionengines',
     default=list,
 )
 coreconfigitem('server', 'concurrent-push-mode',
     default='strict',
 )
 coreconfigitem('server', 'disablefullbundle',
     default=False,
 )
 coreconfigitem('server', 'maxhttpheaderlen',
     default=1024,
 )
 coreconfigitem('server', 'preferuncompressed',
     default=False,
 )
 coreconfigitem('server', 'uncompressedallowsecret',
     default=False,
 )
 coreconfigitem('server', 'validate',
     default=False,
 )
 coreconfigitem('server', 'zliblevel',
     default=-1,
 )
 coreconfigitem('ui', 'clonebundleprefers',
     default=list,
 )
 coreconfigitem('ui', 'interactive',
     default=None,
 )
 coreconfigitem('ui', 'quiet',
     default=False,
 )
 # Windows defaults to a limit of 512 open files. A buffer of 128
 # should give us enough headway.
 coreconfigitem('worker', 'backgroundclosemaxqueue',
     default=384,
 )
 coreconfigitem('worker', 'backgroundcloseminfilecount',
     default=2048,
 )
 coreconfigitem('worker', 'backgroundclosethreadcount',
     default=4,
 )
 coreconfigitem('worker', 'numcpus',
     default=None,
 )

mercurial/progress.py

@@ -1,280 +1,280 b''
 # progress.py progress bars related code
 #
 # Copyright (C) 2010 Augie Fackler <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import errno
 import threading
 import time
 
 from .i18n import _
 from . import encoding
 
 def spacejoin(*args):
     return ' '.join(s for s in args if s)
 
 def shouldprint(ui):
     return not (ui.quiet or ui.plain('progress')) and (
         ui._isatty(ui.ferr) or ui.configbool('progress', 'assume-tty'))
 
 def fmtremaining(seconds):
     """format a number of remaining seconds in human readable way
 
     This will properly display seconds, minutes, hours, days if needed"""
     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)
 
 # file_write() and file_flush() of Python 2 do not restart on EINTR if
 # the file is attached to a "slow" device (e.g. a terminal) and raise
 # IOError. We cannot know how many bytes would be written by file_write(),
 # but a progress text is known to be short enough to be written by a
 # single write() syscall, so we can just retry file_write() with the whole
 # text. (issue5532)
 #
 # This should be a short-term workaround. We'll need to fix every occurrence
 # of write() to a terminal or pipe.
 def _eintrretry(func, *args):
     while True:
         try:
             return func(*args)
         except IOError as err:
             if err.errno == errno.EINTR:
                 continue
             raise
 
 class progbar(object):
     def __init__(self, ui):
         self.ui = ui
         self._refreshlock = threading.Lock()
         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.curtopic = None
         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 = encoding.trim(item, wid, leftside=True)
                 else:
                     add = encoding.trim(item, wid)
                 add += (wid - encoding.colwidth(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 += encoding.colwidth(head) + 1
             if tail:
                 used += encoding.colwidth(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)
         self._writeerr('\r' + encoding.trim(out, termwidth))
         self.lasttopic = topic
         self._flusherr()
 
     def clear(self):
         if not self.printed or not self.lastprint or not shouldprint(self.ui):
             return
         self._writeerr('\r%s\r' % (' ' * self.width()))
         if self.printed:
             # force immediate re-paint of progress bar
             self.lastprint = 0
 
     def complete(self):
         if not shouldprint(self.ui):
             return
         if self.ui.configbool('progress', 'clear-complete'):
             self.clear()
         else:
             self._writeerr('\n')
         self._flusherr()
 
     def _flusherr(self):
         _eintrretry(self.ui.ferr.flush)
 
     def _writeerr(self, msg):
         _eintrretry(self.ui.ferr.write, msg)
 
     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]
             # experimental config: progress.estimate
             if elapsed > float(
-                self.ui.config('progress', 'estimate', default=2)):
+                self.ui.config('progress', 'estimate')):
                 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)):
+            self.ui.config('progress', 'estimate')):
             return _('%d %s/sec') % (delta / elapsed, unit)
         return ''
 
     def _oktoprint(self, now):
         '''Check if conditions are met to print - e.g. changedelay elapsed'''
         if (self.lasttopic is None # first time we printed
             # not a topic change
             or self.curtopic == self.lasttopic
             # it's been long enough we should print anyway
             or now - self.lastprint >= self.changedelay):
             return True
         else:
             return False
 
     def progress(self, topic, pos, item='', unit='', total=None):
         now = time.time()
         self._refreshlock.acquire()
         try:
             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)]
                     # reset the last topic to the one we just unwound to,
                     # so that higher-level topics will be stickier than
                     # lower-level topics
                     if self.topics:
                         self.lasttopic = self.topics[-1]
                     else:
                         self.lasttopic = None
             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
                 self.curtopic = topic
                 if now - self.lastprint >= self.refresh and self.topics:
                     if self._oktoprint(now):
                         self.lastprint = now
                         self.show(now, topic, *self.topicstates[topic])
         finally:
             self._refreshlock.release()