mercurial-scm/hg: comparison mercurial/ui.py

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 )
 urlreq = util.urlreq
 # for use with str.translate(None, _keepalnum), to keep just alphanumerics
-_keepalnum = ''.join(c for c in map(pycompat.bytechr, range(256))
+_keepalnum = ''.join(
-if not c.isalnum())
+c for c in map(pycompat.bytechr, range(256)) if not c.isalnum()
+)
 # The config knobs that will be altered (if unset) by ui.tweakdefaults.
 tweakrc = b"""
 [ui]
 # The rollback command is dangerous. As a rule, don't use it.
 showfunc = 1
 word-diff = 1
 """
 samplehgrcs = {
-'user':
+'user': b"""# example user config (see 'hg help config' for more info)
-b"""# example user config (see 'hg help config' for more info)
 [ui]
 # name and email, e.g.
 # username = Jane Doe <jdoe@example.com>
 username =
 #
 # histedit =
 # rebase =
 # uncommit =
 """,
+'cloned': b"""# example repository config (see 'hg help config' for more info)
-'cloned':
-b"""# example repository config (see 'hg help config' for more info)
 [paths]
 default = %s
 # path aliases to other clones of this repo in URLs or filesystem paths
 # (see 'hg help config.paths' for more info)
 [ui]
 # name and email (local to this repository, optional), e.g.
 # username = Jane Doe <jdoe@example.com>
 """,
+'local': b"""# example repository config (see 'hg help config' for more info)
-'local':
-b"""# example repository config (see 'hg help config' for more info)
 [paths]
 # path aliases to other clones of this repo in URLs or filesystem paths
 # (see 'hg help config.paths' for more info)
 #
 # default         = http://example.com/hg/example-repo
 [ui]
 # name and email (local to this repository, optional), e.g.
 # username = Jane Doe <jdoe@example.com>
 """,
+'global': b"""# example system-wide hg config (see 'hg help config' for more info)
-'global':
-b"""# example system-wide hg config (see 'hg help config' for more info)
 [ui]
 # uncomment to disable color in command output
 # (see 'hg help color' for details)
 # color = never
 # blackbox =
 # churn =
 """,
 }
 def _maybestrurl(maybebytes):
 return pycompat.rapply(pycompat.strurl, maybebytes)
 def _maybebytesurl(maybestr):
 return pycompat.rapply(pycompat.bytesurl, maybestr)
 class httppasswordmgrdbproxy(object):
 """Delays loading urllib2 until it's needed."""
 def __init__(self):
 self._mgr = None
 def _get_mgr(self):
 if self._mgr is None:
 self._mgr = urlreq.httppasswordmgrwithdefaultrealm()
 return self._mgr
 def add_password(self, realm, uris, user, passwd):
 return self._get_mgr().add_password(
-_maybestrurl(realm), _maybestrurl(uris),
+_maybestrurl(realm),
-_maybestrurl(user), _maybestrurl(passwd))
+_maybestrurl(uris),
+_maybestrurl(user),
+_maybestrurl(passwd),
+)
 def find_user_password(self, realm, uri):
 mgr = self._get_mgr()
-return _maybebytesurl(mgr.find_user_password(_maybestrurl(realm),
+return _maybebytesurl(
-_maybestrurl(uri)))
+mgr.find_user_password(_maybestrurl(realm), _maybestrurl(uri))
+)
 def _catchterm(*args):
 raise error.SignalInterrupt
 # unique object used to detect no default value has been provided when
 # retrieving configuration value.
 _unset = object()
 # _reqexithandlers: callbacks run at the end of a request
 _reqexithandlers = []
 class ui(object):
 def __init__(self, src=None):
 """Create a fresh new ui object if no src given
 # This exists to prevent an extra list lookup.
 self._bufferapplylabels = None
 self.quiet = self.verbose = self.debugflag = self.tracebackflag = False
 self._reportuntrusted = True
 self._knownconfig = configitems.coreitems
-self._ocfg = config.config() # overlay
+self._ocfg = config.config()  # overlay
-self._tcfg = config.config() # trusted
+self._tcfg = config.config()  # trusted
-self._ucfg = config.config() # untrusted
+self._ucfg = config.config()  # untrusted
 self._trustusers = set()
 self._trustgroups = set()
 self.callhooks = True
 # Insecure server connections requested.
 self.insecureconnections = False
 starttime = util.timer()
 try:
 yield
 finally:
 self._blockedtimes[key + '_blocked'] += (
-(util.timer() - starttime) * 1000)
+util.timer() - starttime
+) * 1000
 @contextlib.contextmanager
 def uninterruptible(self):
 """Mark an operation as unsafe.
 few are risky (for example repair.strip). This context manager
 lets you advise Mercurial that something risky is happening so
 that control-C etc can be blocked if desired.
 """
 enabled = self.configbool('experimental', 'nointerrupt')
-if (enabled and
+if enabled and self.configbool(
-self.configbool('experimental', 'nointerrupt-interactiveonly')):
+'experimental', 'nointerrupt-interactiveonly'
+):
 enabled = self.interactive()
 if self._uninterruptible or not enabled:
 # if nointerrupt support is turned off, the process isn't
 # interactive, or we're already in an uninterruptible
 # block, do nothing.
 yield
 return
 def warn():
 self.warn(_("shutting down cleanly\n"))
 self.warn(
-_("press ^C again to terminate immediately (dangerous)\n"))
+_("press ^C again to terminate immediately (dangerous)\n")
+)
 return True
 with procutil.uninterruptible(warn):
 try:
 self._uninterruptible = True
 yield
 finally:
 group = util.groupname(st.st_gid)
 if user in tusers or group in tgroups or user == util.username():
 return True
 if self._reportuntrusted:
-self.warn(_('not trusting file %s from untrusted '
+self.warn(
-'user %s, group %s\n') % (f, user, group))
+_('not trusting file %s from untrusted ' 'user %s, group %s\n')
+% (f, user, group)
+)
 return False
-def readconfig(self, filename, root=None, trust=False,
+def readconfig(
-sections=None, remap=None):
+self, filename, root=None, trust=False, sections=None, remap=None
+):
 try:
 fp = open(filename, r'rb')
 except IOError:
-if not sections: # ignore unless we were looking for something
+if not sections:  # ignore unless we were looking for something
 return
 raise
 cfg = config.config()
 trusted = sections or trust or self._trusted(fp, filename)
 if trusted:
 raise
 self.warn(_("ignored: %s\n") % stringutil.forcebytestr(inst))
 if self.plain():
-for k in ('debug', 'fallbackencoding', 'quiet', 'slash',
+for k in (
-'logtemplate', 'message-output', 'statuscopies', 'style',
+'debug',
-'traceback', 'verbose'):
+'fallbackencoding',
+'quiet',
+'slash',
+'logtemplate',
+'message-output',
+'statuscopies',
+'style',
+'traceback',
+'verbose',
+):
 if k in cfg['ui']:
 del cfg['ui'][k]
 for k, v in cfg.items('defaults'):
 del cfg['defaults'][k]
 for k, v in cfg.items('commands'):
 continue
 if not p:
 continue
 if '%%' in p:
 s = self.configsource('paths', n) or 'none'
-self.warn(_("(deprecated '%%' in path %s=%s from %s)\n")
+self.warn(
-% (n, p, s))
+_("(deprecated '%%' in path %s=%s from %s)\n")
+% (n, p, s)
+)
 p = p.replace('%%', '%')
 p = util.expandpath(p)
 if not util.hasscheme(p) and not os.path.isabs(p):
 p = os.path.normpath(os.path.join(root, p))
 c.set("paths", n, p)
 self.debugflag = self.configbool('ui', 'debug')
 self.verbose = self.debugflag or self.configbool('ui', 'verbose')
 self.quiet = not self.debugflag and self.configbool('ui', 'quiet')
 if self.verbose and self.quiet:
 self.quiet = self.verbose = False
-self._reportuntrusted = self.debugflag or self.configbool("ui",
+self._reportuntrusted = self.debugflag or self.configbool(
-"report_untrusted")
+"ui", "report_untrusted"
+)
 self.tracebackflag = self.configbool('ui', 'traceback')
 self.logblockedtimes = self.configbool('ui', 'logblockedtimes')
 if section in (None, 'trusted'):
 # update trust information
 if tracked:
 logger = loggingutil.fileobjectlogger(self._ferr, tracked)
 self.setlogger(b'debug', logger)
 def backupconfig(self, section, item):
-return (self._ocfg.backup(section, item),
+return (
-self._tcfg.backup(section, item),
+self._ocfg.backup(section, item),
-self._ucfg.backup(section, item),)
+self._tcfg.backup(section, item),
+self._ucfg.backup(section, item),
+)
 def restoreconfig(self, data):
 self._ocfg.restore(data[0])
 self._tcfg.restore(data[1])
 self._ucfg.restore(data[2])
 def configsource(self, section, name, untrusted=False):
 return self._data(untrusted).source(section, name)
 def config(self, section, name, default=_unset, untrusted=False):
 """return the plain string version of a config"""
-value = self._config(section, name, default=default,
+value = self._config(
-untrusted=untrusted)
+section, name, default=default, untrusted=untrusted
+)
 if value is _unset:
 return None
 return value
 def _config(self, section, name, default=_unset, untrusted=False):
 if callable(item.default):
 itemdefault = item.default()
 else:
 itemdefault = item.default
 else:
-msg = ("accessing unregistered config item: '%s.%s'")
+msg = "accessing unregistered config item: '%s.%s'"
 msg %= (section, name)
 self.develwarn(msg, 2, 'warn-config-unknown')
 if default is _unset:
 if item is None:
 msg = "config item requires an explicit default value: '%s.%s'"
 msg %= (section, name)
 self.develwarn(msg, 2, 'warn-config-default')
 else:
 value = itemdefault
-elif (item is not None
+elif (
-and item.default is not configitems.dynamicdefault
+item is not None
-and default != itemdefault):
+and item.default is not configitems.dynamicdefault
-msg = ("specifying a mismatched default value for a registered "
+and default != itemdefault
-"config item: '%s.%s' '%s'")
+):
+msg = (
+"specifying a mismatched default value for a registered "
+"config item: '%s.%s' '%s'"
+)
 msg %= (section, name, pycompat.bytestr(default))
 self.develwarn(msg, 2, 'warn-config-default')
 for s, n in alternates:
 candidate = self._data(untrusted).get(s, n, None)
 if self.debugflag and not untrusted and self._reportuntrusted:
 for s, n in alternates:
 uvalue = self._ucfg.get(s, n)
 if uvalue is not None and uvalue != value:
-self.debug("ignoring untrusted configuration option "
+self.debug(
-"%s.%s = %s\n" % (s, n, uvalue))
+"ignoring untrusted configuration option "
+"%s.%s = %s\n" % (s, n, uvalue)
+)
 return value
 def configsuboptions(self, section, name, default=_unset, untrusted=False):
 """Get a config option and all sub-options.
 data = self._data(untrusted)
 sub = {}
 prefix = '%s:' % name
 for k, v in data.items(section):
 if k.startswith(prefix):
-sub[k[len(prefix):]] = v
+sub[k[len(prefix) :]] = v
 if self.debugflag and not untrusted and self._reportuntrusted:
 for k, v in sub.items():
 uvalue = self._ucfg.get(section, '%s:%s' % (name, k))
 if uvalue is not None and uvalue != v:
-self.debug('ignoring untrusted configuration option '
+self.debug(
-'%s:%s.%s = %s\n' % (section, name, k, uvalue))
+'ignoring untrusted configuration option '
+'%s:%s.%s = %s\n' % (section, name, k, uvalue)
+)
 return main, sub
 def configpath(self, section, name, default=_unset, untrusted=False):
 'get a path config item, expanded relative to repo root or config file'
 return default
 if isinstance(v, bool):
 return v
 b = stringutil.parsebool(v)
 if b is None:
-raise error.ConfigError(_("%s.%s is not a boolean ('%s')")
+raise error.ConfigError(
-% (section, name, v))
+_("%s.%s is not a boolean ('%s')") % (section, name, v)
+)
 return b
-def configwith(self, convert, section, name, default=_unset,
+def configwith(
-desc=None, untrusted=False):
+self, convert, section, name, default=_unset, desc=None, untrusted=False
+):
 """parse a configuration element with a conversion function
 >>> u = ui(); s = b'foo'
 >>> u.setconfig(s, b'float1', b'42')
 >>> u.configwith(float, s, b'float1')
 ConfigError: foo.invalid is not a valid womble ('somevalue')
 """
 v = self.config(section, name, default, untrusted)
 if v is None:
-return v # do not attempt to convert None
+return v  # do not attempt to convert None
 try:
 return convert(v)
 except (ValueError, error.ParseError):
 if desc is None:
 desc = pycompat.sysbytes(convert.__name__)
-raise error.ConfigError(_("%s.%s is not a valid %s ('%s')")
+raise error.ConfigError(
-% (section, name, desc, v))
+_("%s.%s is not a valid %s ('%s')") % (section, name, desc, v)
+)
 def configint(self, section, name, default=_unset, untrusted=False):
 """parse a configuration element as an integer
 >>> u = ui(); s = b'foo'
 Traceback (most recent call last):
 ...
 ConfigError: foo.invalid is not a valid integer ('somevalue')
 """
-return self.configwith(int, section, name, default, 'integer',
+return self.configwith(
-untrusted)
+int, section, name, default, 'integer', untrusted
+)
 def configbytes(self, section, name, default=_unset, untrusted=False):
 """parse a configuration element as a quantity in bytes
 Units can be specified as b (bytes), k or kb (kilobytes), m or
 if not isinstance(value, bytes):
 return value
 try:
 return util.sizetoint(value)
 except error.ParseError:
-raise error.ConfigError(_("%s.%s is not a byte quantity ('%s')")
+raise error.ConfigError(
-% (section, name, value))
+_("%s.%s is not a byte quantity ('%s')")
+% (section, name, value)
+)
 def configlist(self, section, name, default=_unset, untrusted=False):
 """parse a configuration element as a list of comma/space separated
 strings
 >>> u.setconfig(s, b'list2', b'this, is "a small" , test ')
 >>> u.configlist(s, b'list2')
 ['this', 'is', 'a small', 'test']
 """
 # default is not always a list
-v = self.configwith(config.parselist, section, name, default,
+v = self.configwith(
-'list', untrusted)
+config.parselist, section, name, default, 'list', untrusted
+)
 if isinstance(v, bytes):
 return config.parselist(v)
 elif v is None:
 return []
 return v
 >>> u.setconfig(s, b'date', b'0 0')
 >>> u.configdate(s, b'date')
 (0, 0)
 """
 if self.config(section, name, default, untrusted):
-return self.configwith(dateutil.parsedate, section, name, default,
+return self.configwith(
-'date', untrusted)
+dateutil.parsedate, section, name, default, 'date', untrusted
+)
 if default is _unset:
 return None
 return default
 def configdefault(self, section, name):
 if ignoresub:
 items = [i for i in items if ':' not in i[0]]
 if self.debugflag and not untrusted and self._reportuntrusted:
 for k, v in self._ucfg.items(section):
 if self._tcfg.get(section, k) != v:
-self.debug("ignoring untrusted configuration option "
+self.debug(
-"%s.%s = %s\n" % (section, k, v))
+"ignoring untrusted configuration option "
+"%s.%s = %s\n" % (section, k, v)
+)
 return items
 def walkconfig(self, untrusted=False):
 cfg = self._data(untrusted)
 for section in cfg.sections():
 The return value can either be
 - False if HGPLAIN is not set, or feature is in HGPLAINEXCEPT
 - False if feature is disabled by default and not included in HGPLAIN
 - True otherwise
 '''
-if ('HGPLAIN' not in encoding.environ and
+if (
-'HGPLAINEXCEPT' not in encoding.environ):
+'HGPLAIN' not in encoding.environ
+and 'HGPLAINEXCEPT' not in encoding.environ
+):
 return False
-exceptions = encoding.environ.get('HGPLAINEXCEPT',
+exceptions = (
-'').strip().split(',')
+encoding.environ.get('HGPLAINEXCEPT', '').strip().split(',')
+)
 # TODO: add support for HGPLAIN=+feature,-feature syntax
 if '+strictflags' not in encoding.environ.get('HGPLAIN', '').split(','):
 exceptions.append('strictflags')
 if feature and exceptions:
 return feature not in exceptions
 return user
 if user is None and self.configbool("ui", "askusername"):
 user = self.prompt(_("enter a commit username:"), default=None)
 if user is None and not self.interactive():
 try:
-user = '%s@%s' % (procutil.getuser(),
+user = '%s@%s' % (
-encoding.strtolocal(socket.getfqdn()))
+procutil.getuser(),
+encoding.strtolocal(socket.getfqdn()),
+)
 self.warn(_("no username found, using '%s' instead\n") % user)
 except KeyError:
 pass
 if not user:
-raise error.Abort(_('no username supplied'),
+raise error.Abort(
-hint=_("use 'hg config --edit' "
+_('no username supplied'),
-'to set your username'))
+hint=_("use 'hg config --edit' " 'to set your username'),
+)
 if "\n" in user:
-raise error.Abort(_("username %r contains a newline\n")
+raise error.Abort(
-% pycompat.bytestr(user))
+_("username %r contains a newline\n") % pycompat.bytestr(user)
+)
 return user
 def shortuser(self, user):
 """Return a short representation of a user name or email address."""
 if not self.verbose:
 dest.write(msg)
 except IOError as err:
 raise error.StdioError(err)
 finally:
 self._blockedtimes['stdio_blocked'] += (
-(util.timer() - starttime) * 1000)
+util.timer() - starttime
+) * 1000
 def write_err(self, *args, **opts):
 self._write(self._ferr, *args, **opts)
 def _write(self, dest, *args, **opts):
 # stderr may be buffered under win32 when redirected to files,
 # including stdout.
 if dest is self._ferr and not getattr(self._ferr, 'closed', False):
 dest.flush()
 except IOError as err:
-if (dest is self._ferr
+if dest is self._ferr and err.errno in (
-and err.errno in (errno.EPIPE, errno.EIO, errno.EBADF)):
+errno.EPIPE,
+errno.EIO,
+errno.EBADF,
+):
 # no way to report the error, so ignore it
 return
 raise error.StdioError(err)
 finally:
 self._blockedtimes['stdio_blocked'] += (
-(util.timer() - starttime) * 1000)
+util.timer() - starttime
+) * 1000
 def _writemsg(self, dest, *args, **opts):
 _writemsgwith(self._write, dest, *args, **opts)
 def _writemsgnobuf(self, dest, *args, **opts):
 except IOError as err:
 if err.errno not in (errno.EPIPE, errno.EIO, errno.EBADF):
 raise error.StdioError(err)
 finally:
 self._blockedtimes['stdio_blocked'] += (
-(util.timer() - starttime) * 1000)
+util.timer() - starttime
+) * 1000
 def _isatty(self, fh):
 if self.configbool('ui', 'nontty'):
 return False
 return procutil.isatty(fh)
 Args:
 command: The full, non-aliased name of the command. That is, "log"
 not "history, "summary" not "summ", etc.
 """
-if (self._disablepager
+if self._disablepager or self.pageractive:
-or self.pageractive):
 # how pager should do is already determined
 return
 if not command.startswith('internal-always-') and (
 # explicit --pager=on (= 'internal-always-' prefix) should
 # formatted() will need some adjustment.
 or not self.formatted()
 or self.plain()
 or self._buffers
 # TODO: expose debugger-enabled on the UI object
-or '--debugger' in pycompat.sysargv):
+or '--debugger' in pycompat.sysargv
+):
 # We only want to paginate if the ui appears to be
 # interactive, the user didn't say HGPLAIN or
 # HGPLAINEXCEPT=pager, and the user didn't specify --debug.
 return
 pagerenv = {}
 for name, value in rcutil.defaultpagerenv().items():
 if name not in encoding.environ:
 pagerenv[name] = value
-self.debug('starting pager for command %s\n' %
+self.debug(
-stringutil.pprint(command))
+'starting pager for command %s\n' % stringutil.pprint(command)
+)
 self.flush()
 wasformatted = self.formatted()
 if util.safehasattr(signal, "SIGPIPE"):
 signal.signal(signal.SIGPIPE, _catchterm)
 # user so we can also get sane bad PAGER behavior.  MSYS has
 # `more.exe`, so do a cmd.exe style resolution of the executable to
 # determine which one to use.
 fullcmd = procutil.findexe(command)
 if not fullcmd:
-self.warn(_("missing pager command '%s', skipping pager\n")
+self.warn(
-% command)
+_("missing pager command '%s', skipping pager\n") % command
+)
 return False
 command = fullcmd
 try:
 pager = subprocess.Popen(
-procutil.tonativestr(command), shell=shell, bufsize=-1,
+procutil.tonativestr(command),
-close_fds=procutil.closefds, stdin=subprocess.PIPE,
+shell=shell,
-stdout=procutil.stdout, stderr=procutil.stderr,
+bufsize=-1,
-env=procutil.tonativeenv(procutil.shellenviron(env)))
+close_fds=procutil.closefds,
+stdin=subprocess.PIPE,
+stdout=procutil.stdout,
+stderr=procutil.stderr,
+env=procutil.tonativeenv(procutil.shellenviron(env)),
+)
 except OSError as e:
 if e.errno == errno.ENOENT and not shell:
-self.warn(_("missing pager command '%s', skipping pager\n")
+self.warn(
-% command)
+_("missing pager command '%s', skipping pager\n") % command
+)
 return False
 raise
 # back up original file descriptors
 stdoutfd = os.dup(procutil.stdout.fileno())
 the default curses interface (crecord at the moment).
 """
 alldefaults = frozenset(["text", "curses"])
 featureinterfaces = {
-"chunkselector": [
+"chunkselector": ["text", "curses",],
-"text",
+"histedit": ["text", "curses",],
-"curses",
-],
-"histedit": [
-"text",
-"curses",
-],
 }
 # Feature-specific interface
 if feature not in featureinterfaces.keys():
 # Programming error, not user error
 availableinterfaces = frozenset(featureinterfaces[feature])
 if alldefaults > availableinterfaces:
 # Programming error, not user error. We need a use case to
 # define the right thing to do here.
 raise ValueError(
-"Feature %s does not handle all default interfaces" %
+"Feature %s does not handle all default interfaces" % feature
-feature)
+)
 if self.plain() or encoding.environ.get('TERM') == 'dumb':
 return "text"
 # Default interface for all the features
 if f in availableinterfaces:
 choseninterface = f
 if i is not None and defaultinterface != i:
 if f is not None:
-self.warn(_("invalid value for ui.interface: %s\n") %
+self.warn(_("invalid value for ui.interface: %s\n") % (i,))
-(i,))
 else:
-self.warn(_("invalid value for ui.interface: %s (using %s)\n") %
+self.warn(
-(i, choseninterface))
+_("invalid value for ui.interface: %s (using %s)\n")
+% (i, choseninterface)
+)
 if f is not None and choseninterface != f:
-self.warn(_("invalid value for ui.interface.%s: %s (using %s)\n") %
+self.warn(
-(feature, f, choseninterface))
+_("invalid value for ui.interface.%s: %s (using %s)\n")
+% (feature, f, choseninterface)
+)
 return choseninterface
 def interactive(self):
 '''is interactive input allowed?
 def _readline(self, prompt=' ', promptopts=None):
 # Replacing stdin/stdout temporarily is a hard problem on Python 3
 # because they have to be text streams with *no buffering*. Instead,
 # we use rawinput() only if call_readline() will be invoked by
 # PyOS_Readline(), so no I/O will be made at Python layer.
-usereadline = (self._isatty(self._fin) and self._isatty(self._fout)
+usereadline = (
-and procutil.isstdin(self._fin)
+self._isatty(self._fin)
-and procutil.isstdout(self._fout))
+and self._isatty(self._fout)
+and procutil.isstdin(self._fin)
+and procutil.isstdout(self._fout)
+)
 if usereadline:
 try:
 # magically add command line editing support, where
 # available
 import readline
 # force demandimport to really load the module
 readline.read_history_file
 # windows sometimes raises something other than ImportError
 except Exception:
 usereadline = False
 if self._colormode == 'win32' or not usereadline:
 if not promptopts:
 promptopts = {}
-self._writemsgnobuf(self._fmsgout, prompt, type='prompt',
+self._writemsgnobuf(
-**promptopts)
+self._fmsgout, prompt, type='prompt', **promptopts
+)
 self.flush()
 prompt = ' '
 else:
 prompt = self.label(prompt, 'ui.prompt') + ' '
 def _prompt(self, msg, **opts):
 default = opts[r'default']
 if not self.interactive():
 self._writemsg(self._fmsgout, msg, ' ', type='prompt', **opts)
-self._writemsg(self._fmsgout, default or '', "\n",
+self._writemsg(
-type='promptecho')
+self._fmsgout, default or '', "\n", type='promptecho'
+)
 return default
 try:
 r = self._readline(prompt=msg, promptopts=opts)
 if not r:
 r = default
 # choices containing spaces, ASCII, or basically anything
 # except an ampersand followed by a character.
 m = re.match(br'(?s)(.+?)\$\$([^\$]*&[^ \$].*)', prompt)
 msg = m.group(1)
 choices = [p.strip(' ') for p in m.group(2).split('$$')]
 def choicetuple(s):
 ampidx = s.index('&')
-return s[ampidx + 1:ampidx + 2].lower(), s.replace('&', '', 1)
+return s[ampidx + 1 : ampidx + 2].lower(), s.replace('&', '', 1)
 return (msg, [choicetuple(s) for s in choices])
 def promptchoice(self, prompt, default=0):
 """Prompt user with a message, read response, and ensure it matches
 one of the provided choices. The prompt is formatted as follows:
 def getpass(self, prompt=None, default=None):
 if not self.interactive():
 return default
 try:
-self._writemsg(self._fmsgerr, prompt or _('password: '),
+self._writemsg(
-type='prompt', password=True)
+self._fmsgerr,
+prompt or _('password: '),
+type='prompt',
+password=True,
+)
 # disable getpass() only if explicitly specified. it's still valid
 # to interact with tty even if fin is not a tty.
 with self.timeblockedsection('stdio'):
 if self.configbool('ui', 'nontty'):
 l = self._fin.readline()
 '''
 if self.debugflag:
 self._writemsg(self._fmsgout, type='debug', *msg, **opts)
 self.log(b'debug', b'%s', b''.join(msg))
-def edit(self, text, user, extra=None, editform=None, pending=None,
+def edit(
-repopath=None, action=None):
+self,
+text,
+user,
+extra=None,
+editform=None,
+pending=None,
+repopath=None,
+action=None,
+):
 if action is None:
-self.develwarn('action is None but will soon be a required '
+self.develwarn(
-'parameter to ui.edit()')
+'action is None but will soon be a required '
+'parameter to ui.edit()'
+)
 extra_defaults = {
 'prefix': 'editor',
 'suffix': '.txt',
 }
 if extra is not None:
 if extra.get('suffix') is not None:
-self.develwarn('extra.suffix is not None but will soon be '
+self.develwarn(
-'ignored by ui.edit()')
+'extra.suffix is not None but will soon be '
+'ignored by ui.edit()'
+)
 extra_defaults.update(extra)
 extra = extra_defaults
 if action == 'diff':
 suffix = '.diff'
 suffix = extra['suffix']
 rdir = None
 if self.configbool('experimental', 'editortmpinhg'):
 rdir = repopath
-(fd, name) = pycompat.mkstemp(prefix='hg-' + extra['prefix'] + '-',
+(fd, name) = pycompat.mkstemp(
-suffix=suffix,
+prefix='hg-' + extra['prefix'] + '-', suffix=suffix, dir=rdir
-dir=rdir)
+)
 try:
 f = os.fdopen(fd, r'wb')
 f.write(util.tonativeeol(text))
 f.close()
 if pending:
 environ.update({'HG_PENDING': pending})
 editor = self.geteditor()
-self.system("%s \"%s\"" % (editor, name),
+self.system(
-environ=environ,
+"%s \"%s\"" % (editor, name),
-onerr=error.Abort, errprefix=_("edit failed"),
+environ=environ,
-blockedtag='editor')
+onerr=error.Abort,
+errprefix=_("edit failed"),
+blockedtag='editor',
+)
 f = open(name, r'rb')
 t = util.fromnativeeol(f.read())
 f.close()
 finally:
 os.unlink(name)
 return t
-def system(self, cmd, environ=None, cwd=None, onerr=None, errprefix=None,
+def system(
-blockedtag=None):
+self,
+cmd,
+environ=None,
+cwd=None,
+onerr=None,
+errprefix=None,
+blockedtag=None,
+):
 '''execute shell command with appropriate output stream. command
 output will be redirected if fout is not stdout.
 if command fails and onerr is None, return status, else raise onerr
 object as exception.
 if any(s[1] for s in self._bufferstates):
 out = self
 with self.timeblockedsection(blockedtag):
 rc = self._runsystem(cmd, environ=environ, cwd=cwd, out=out)
 if rc and onerr:
-errmsg = '%s %s' % (os.path.basename(cmd.split(None, 1)[0]),
+errmsg = '%s %s' % (
-procutil.explainexit(rc))
+os.path.basename(cmd.split(None, 1)[0]),
+procutil.explainexit(rc),
+)
 if errprefix:
 errmsg = '%s: %s' % (errprefix, errmsg)
 raise onerr(errmsg)
 return rc
 causetb = traceback.format_tb(cause[2])
 exctb = traceback.format_tb(exc[2])
 exconly = traceback.format_exception_only(cause[0], cause[1])
 # exclude frame where 'exc' was chained and rethrown from exctb
-self.write_err('Traceback (most recent call last):\n',
+self.write_err(
-''.join(exctb[:-1]),
+'Traceback (most recent call last):\n',
-''.join(causetb),
+''.join(exctb[:-1]),
-''.join(exconly))
+''.join(causetb),
+''.join(exconly),
+)
 else:
 output = traceback.format_exception(exc[0], exc[1], exc[2])
 self.write_err(encoding.strtolocal(r''.join(output)))
 return self.tracebackflag or force
 # instead default to E to plumb commit messages to
 # avoid confusion.
 editor = 'E'
 else:
 editor = 'vi'
-return (encoding.environ.get("HGEDITOR") or
+return encoding.environ.get("HGEDITOR") or self.config(
-self.config("ui", "editor", editor))
+"ui", "editor", editor
+)
 @util.propertycache
 def _progbar(self):
 """setup the progbar singleton to the ui object"""
-if (self.quiet or self.debugflag
+if (
-or self.configbool('progress', 'disable')
+self.quiet
-or not progress.shouldprint(self)):
+or self.debugflag
+or self.configbool('progress', 'disable')
+or not progress.shouldprint(self)
+):
 return None
 return getprogbar(self)
 def _progclear(self):
 """clear progress bar output if any. use it before any output"""
-if not haveprogbar(): # nothing loaded yet
+if not haveprogbar():  # nothing loaded yet
 return
 if self._progbar is not None and self._progbar.printed:
 self._progbar.clear()
 def progress(self, topic, pos, item="", unit="", total=None):
 Multiple nested topics may be active at a time.
 All topics should be marked closed by setting pos to None at
 termination.
 '''
-self.deprecwarn("use ui.makeprogress() instead of ui.progress()",
+self.deprecwarn("use ui.makeprogress() instead of ui.progress()", "5.1")
-"5.1")
 progress = self.makeprogress(topic, unit, total)
 if pos is not None:
 progress.update(pos, item=item)
 else:
 progress.complete()
 # raw information
 # TODO: consider porting some useful information (e.g. estimated
 # time) from progbar. we might want to support update delay to
 # reduce the cost of transferring progress messages.
 def updatebar(topic, pos, item, unit, total):
-self._fmsgerr.write(None, type=b'progress', topic=topic,
+self._fmsgerr.write(
-pos=pos, item=item, unit=unit, total=total)
+None,
+type=b'progress',
+topic=topic,
+pos=pos,
+item=item,
+unit=unit,
+total=total,
+)
 elif self._progbar is not None:
 updatebar = self._progbar.progress
 else:
 def updatebar(topic, pos, item, unit, total):
 pass
 return scmutil.progress(self, updatebar, topic, unit, total)
 def getlogger(self, name):
 """Returns a logger of the given name; or None if not registered"""
 return self._loggers.get(name)
 **opts currently has no defined meanings.
 '''
 if not self._loggers:
 return
-activeloggers = [l for l in self._loggers.itervalues()
+activeloggers = [
-if l.tracked(event)]
+l for l in self._loggers.itervalues() if l.tracked(event)
+]
 if not activeloggers:
 return
 msg = msgfmt % msgargs
 opts = pycompat.byteskwargs(opts)
 # guard against recursion from e.g. ui.debug()
 """
 if not self.configbool('devel', 'all-warnings'):
 if config is None or not self.configbool('devel', config):
 return
 msg = 'devel-warn: ' + msg
-stacklevel += 1 # get in develwarn
+stacklevel += 1  # get in develwarn
 if self.tracebackflag:
 util.debugstacktrace(msg, stacklevel, self._ferr, self._fout)
-self.log('develwarn', '%s at:\n%s' %
+self.log(
-(msg, ''.join(util.getstackframes(stacklevel))))
+'develwarn',
+'%s at:\n%s' % (msg, ''.join(util.getstackframes(stacklevel))),
+)
 else:
 curframe = inspect.currentframe()
 calframe = inspect.getouterframes(curframe, 2)
 fname, lineno, fmsg = calframe[stacklevel][1:4]
 fname, fmsg = pycompat.sysbytes(fname), pycompat.sysbytes(fmsg)
-self.write_err('%s at: %s:%d (%s)\n'
+self.write_err('%s at: %s:%d (%s)\n' % (msg, fname, lineno, fmsg))
-% (msg, fname, lineno, fmsg))
+self.log(
-self.log('develwarn', '%s at: %s:%d (%s)\n',
+'develwarn', '%s at: %s:%d (%s)\n', msg, fname, lineno, fmsg
-msg, fname, lineno, fmsg)
+)
 curframe = calframe = None  # avoid cycles
 def deprecwarn(self, msg, version, stacklevel=2):
 """issue a deprecation warning
 - msg: message explaining what is deprecated and how to upgrade,
 - version: last version where the API will be supported,
 """
-if not (self.configbool('devel', 'all-warnings')
+if not (
-or self.configbool('devel', 'deprec-warn')):
+self.configbool('devel', 'all-warnings')
+or self.configbool('devel', 'deprec-warn')
+):
 return
-msg += ("\n(compatibility will be dropped after Mercurial-%s,"
+msg += (
-" update your code.)") % version
+"\n(compatibility will be dropped after Mercurial-%s,"
+" update your code.)"
+) % version
 self.develwarn(msg, stacklevel=stacklevel, config='deprec-warn')
 def exportableenviron(self):
 """The environment variables that are safe to export, e.g. through
 hgweb.
 # just restoring ui.quiet config to the previous value is not enough
 # as it does not update ui.quiet class member
 if ('ui', 'quiet') in overrides:
 self.fixconfig(section='ui')
 class paths(dict):
 """Represents a collection of paths and their configs.
 Data is initially derived from ui instances and the config files they have
 loaded.
 """
 def __init__(self, ui):
 dict.__init__(self)
 for name, loc in ui.configitems('paths', ignoresub=True):
 # No location is the same as not existing.
 # Try to resolve as a local path or URI.
 try:
 # We don't pass sub-options in, so no need to pass ui instance.
 return path(None, None, rawloc=name)
 except ValueError:
-raise error.RepoError(_('repository %s does not exist') %
+raise error.RepoError(_('repository %s does not exist') % name)
-name)
 _pathsuboptions = {}
 def pathsuboption(option, attr):
 """Decorator used to declare a path sub-option.
 Arguments are the sub-option name and the attribute it should set on
 instance.
 This decorator can be used to perform additional verification of
 sub-options and to change the type of sub-options.
 """
 def register(func):
 _pathsuboptions[option] = (attr, func)
 return func
 return register
 @pathsuboption('pushurl', 'pushloc')
 def pushurlpathoption(ui, path, value):
 u = util.url(value)
 # Actually require a URL.
 return None
 # Don't support the #foo syntax in the push URL to declare branch to
 # push.
 if u.fragment:
-ui.warn(_('("#fragment" in paths.%s:pushurl not supported; '
+ui.warn(
-'ignoring)\n') % path.name)
+_('("#fragment" in paths.%s:pushurl not supported; ' 'ignoring)\n')
+% path.name
+)
 u.fragment = None
 return bytes(u)
 @pathsuboption('pushrev', 'pushrev')
 def pushrevpathoption(ui, path, value):
 return value
 class path(object):
 """Represents an individual path and its configuration."""
 def __init__(self, ui, name, rawloc=None, suboptions=None):
 self.loc = '%s' % u
 # When given a raw location but not a symbolic name, validate the
 # location is valid.
 if not name and not u.scheme and not self._isvalidlocalpath(self.loc):
-raise ValueError('location is not a URL or path to a local '
+raise ValueError(
-'repo: %s' % rawloc)
+'location is not a URL or path to a local ' 'repo: %s' % rawloc
+)
 suboptions = suboptions or {}
 # Now process the sub-options. If a sub-option is registered, its
 # attribute will always be present. The value will be None if there
 value = getattr(self, attr)
 if value is not None:
 d[subopt] = value
 return d
 # we instantiate one globally shared progress bar to avoid
 # competing progress bars when multiple UI objects get created
 _progresssingleton = None
 def getprogbar(ui):
 global _progresssingleton
 if _progresssingleton is None:
 # passing 'ui' object to the singleton is fishy,
 # this is how the extension used to work but feel free to rework it.
 _progresssingleton = progress.progbar(ui)
 return _progresssingleton
 def haveprogbar():
 return _progresssingleton is not None
 def _selectmsgdests(ui):
 name = ui.config(b'ui', b'message-output')
 if name == b'channel':
 if ui.fmsg:
 return ui.fout, ui.ferr
 if name == b'stderr':
 return ui.ferr, ui.ferr
 raise error.Abort(b'invalid ui.message-output destination: %s' % name)
 def _writemsgwith(write, dest, *args, **opts):
 """Write ui message with the given ui._write*() function
 The specified message type is translated to 'ui.<type>' label if the dest
 isn't a structured channel, so that the message will be colorized.

changeset 43076	2372284d9457
parent 42672	51a2e3102db2
child 43077	687b865b95ad