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

equal deleted inserted replaced

-:2372284d9457
+:687b865b95ad
 )
 urlreq = util.urlreq
 # for use with str.translate(None, _keepalnum), to keep just alphanumerics
-_keepalnum = ''.join(
+_keepalnum = b''.join(
 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"""
 showfunc = 1
 word-diff = 1
 """
 samplehgrcs = {
-'user': b"""# example user config (see 'hg help config' for more info)
+b'user': 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)
+b'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)
+b'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)
+b'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
 self.environ = encoding.environ
 self.httppasswordmgrdb = httppasswordmgrdbproxy()
 self._blockedtimes = collections.defaultdict(int)
-allowed = self.configlist('experimental', 'exportableenviron')
+allowed = self.configlist(b'experimental', b'exportableenviron')
-if '*' in allowed:
+if b'*' in allowed:
 self._exportableenviron = self.environ
 else:
 self._exportableenviron = {}
 for k in allowed:
 if k in self.environ:
 def load(cls):
 """Create a ui and load global and user configs"""
 u = cls()
 # we always trust global config files and environment variables
 for t, f in rcutil.rccomponents():
-if t == 'path':
+if t == b'path':
 u.readconfig(f, trust=True)
-elif t == 'items':
+elif t == b'items':
 sections = set()
 for section, name, value, source in f:
 # do not set u._ocfg
 # XXX clean this up once immutable config object is a thing
 u._tcfg.set(section, name, value, source)
 u._ucfg.set(section, name, value, source)
 sections.add(section)
 for section in sections:
 u.fixconfig(section=section)
 else:
-raise error.ProgrammingError('unknown rctype: %s' % t)
+raise error.ProgrammingError(b'unknown rctype: %s' % t)
 u._maybetweakdefaults()
 return u
 def _maybetweakdefaults(self):
-if not self.configbool('ui', 'tweakdefaults'):
+if not self.configbool(b'ui', b'tweakdefaults'):
 return
-if self._tweaked or self.plain('tweakdefaults'):
+if self._tweaked or self.plain(b'tweakdefaults'):
 return
 # Note: it is SUPER IMPORTANT that you set self._tweaked to
 # True *before* any calls to setconfig(), otherwise you'll get
 # infinite recursion between setconfig and this method.
 #
 # TODO: We should extract an inner method in setconfig() to
 # avoid this weirdness.
 self._tweaked = True
 tmpcfg = config.config()
-tmpcfg.parse('<tweakdefaults>', tweakrc)
+tmpcfg.parse(b'<tweakdefaults>', tweakrc)
 for section in tmpcfg:
 for name, value in tmpcfg.items(section):
 if not self.hasconfig(section, name):
-self.setconfig(section, name, value, "<tweakdefaults>")
+self.setconfig(section, name, value, b"<tweakdefaults>")
 def copy(self):
 return self.__class__(self)
 def resetstate(self):
 # this is open-coded below - search for timeblockedsection to find them
 starttime = util.timer()
 try:
 yield
 finally:
-self._blockedtimes[key + '_blocked'] += (
+self._blockedtimes[key + b'_blocked'] += (
 util.timer() - starttime
 ) * 1000
 @contextlib.contextmanager
 def uninterruptible(self):
 Most operations on a repository are safe to interrupt, but a
 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')
+enabled = self.configbool(b'experimental', b'nointerrupt')
 if enabled and self.configbool(
-'experimental', 'nointerrupt-interactiveonly'
+b'experimental', b'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(_(b"shutting down cleanly\n"))
 self.warn(
-_("press ^C again to terminate immediately (dangerous)\n")
+_(b"press ^C again to terminate immediately (dangerous)\n")
 )
 return True
 with procutil.uninterruptible(warn):
 try:
 st = util.fstat(fp)
 if util.isowner(st):
 return True
 tusers, tgroups = self._trustusers, self._trustgroups
-if '*' in tusers or '*' in tgroups:
+if b'*' in tusers or b'*' in tgroups:
 return True
 user = util.username(st.st_uid)
 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 ' 'user %s, group %s\n')
+_(
+b'not trusting file %s from untrusted '
+b'user %s, group %s\n'
+)
 % (f, user, group)
 )
 return False
 def readconfig(
 cfg.read(filename, fp, sections=sections, remap=remap)
 fp.close()
 except error.ConfigError as inst:
 if trusted:
 raise
-self.warn(_("ignored: %s\n") % stringutil.forcebytestr(inst))
+self.warn(_(b"ignored: %s\n") % stringutil.forcebytestr(inst))
 if self.plain():
 for k in (
-'debug',
+b'debug',
-'fallbackencoding',
+b'fallbackencoding',
-'quiet',
+b'quiet',
-'slash',
+b'slash',
-'logtemplate',
+b'logtemplate',
-'message-output',
+b'message-output',
-'statuscopies',
+b'statuscopies',
-'style',
+b'style',
-'traceback',
+b'traceback',
-'verbose',
+b'verbose',
 ):
-if k in cfg['ui']:
+if k in cfg[b'ui']:
-del cfg['ui'][k]
+del cfg[b'ui'][k]
-for k, v in cfg.items('defaults'):
+for k, v in cfg.items(b'defaults'):
-del cfg['defaults'][k]
+del cfg[b'defaults'][k]
-for k, v in cfg.items('commands'):
+for k, v in cfg.items(b'commands'):
-del cfg['commands'][k]
+del cfg[b'commands'][k]
 # Don't remove aliases from the configuration if in the exceptionlist
-if self.plain('alias'):
+if self.plain(b'alias'):
-for k, v in cfg.items('alias'):
+for k, v in cfg.items(b'alias'):
-del cfg['alias'][k]
+del cfg[b'alias'][k]
-if self.plain('revsetalias'):
+if self.plain(b'revsetalias'):
-for k, v in cfg.items('revsetalias'):
+for k, v in cfg.items(b'revsetalias'):
-del cfg['revsetalias'][k]
+del cfg[b'revsetalias'][k]
-if self.plain('templatealias'):
+if self.plain(b'templatealias'):
-for k, v in cfg.items('templatealias'):
+for k, v in cfg.items(b'templatealias'):
-del cfg['templatealias'][k]
+del cfg[b'templatealias'][k]
 if trusted:
 self._tcfg.update(cfg)
 self._tcfg.update(self._ocfg)
 self._ucfg.update(cfg)
 self._ucfg.update(self._ocfg)
 if root is None:
-root = os.path.expanduser('~')
+root = os.path.expanduser(b'~')
 self.fixconfig(root=root)
 def fixconfig(self, root=None, section=None):
-if section in (None, 'paths'):
+if section in (None, b'paths'):
 # expand vars and ~
 # translate paths relative to root (or home) into absolute paths
 root = root or encoding.getcwd()
 for c in self._tcfg, self._ucfg, self._ocfg:
-for n, p in c.items('paths'):
+for n, p in c.items(b'paths'):
 # Ignore sub-options.
-if ':' in n:
+if b':' in n:
 continue
 if not p:
 continue
-if '%%' in p:
+if b'%%' in p:
-s = self.configsource('paths', n) or 'none'
+s = self.configsource(b'paths', n) or b'none'
 self.warn(
-_("(deprecated '%%' in path %s=%s from %s)\n")
+_(b"(deprecated '%%' in path %s=%s from %s)\n")
 % (n, p, s)
 )
-p = p.replace('%%', '%')
+p = p.replace(b'%%', b'%')
 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)
+c.set(b"paths", n, p)
-if section in (None, 'ui'):
+if section in (None, b'ui'):
 # update ui options
 self._fmsgout, self._fmsgerr = _selectmsgdests(self)
-self.debugflag = self.configbool('ui', 'debug')
+self.debugflag = self.configbool(b'ui', b'debug')
-self.verbose = self.debugflag or self.configbool('ui', 'verbose')
+self.verbose = self.debugflag or self.configbool(b'ui', b'verbose')
-self.quiet = not self.debugflag and self.configbool('ui', 'quiet')
+self.quiet = not self.debugflag and self.configbool(b'ui', b'quiet')
 if self.verbose and self.quiet:
 self.quiet = self.verbose = False
 self._reportuntrusted = self.debugflag or self.configbool(
-"ui", "report_untrusted"
+b"ui", b"report_untrusted"
 )
-self.tracebackflag = self.configbool('ui', 'traceback')
+self.tracebackflag = self.configbool(b'ui', b'traceback')
-self.logblockedtimes = self.configbool('ui', 'logblockedtimes')
+self.logblockedtimes = self.configbool(b'ui', b'logblockedtimes')
-if section in (None, 'trusted'):
+if section in (None, b'trusted'):
 # update trust information
-self._trustusers.update(self.configlist('trusted', 'users'))
+self._trustusers.update(self.configlist(b'trusted', b'users'))
-self._trustgroups.update(self.configlist('trusted', 'groups'))
+self._trustgroups.update(self.configlist(b'trusted', b'groups'))
 if section in (None, b'devel', b'ui') and self.debugflag:
 tracked = set()
 if self.configbool(b'devel', b'debug.extensions'):
 tracked.add(b'extension')
 def restoreconfig(self, data):
 self._ocfg.restore(data[0])
 self._tcfg.restore(data[1])
 self._ucfg.restore(data[2])
-def setconfig(self, section, name, value, source=''):
+def setconfig(self, section, name, value, source=b''):
 for cfg in (self._ocfg, self._tcfg, self._ucfg):
 cfg.set(section, name, value, source)
 self.fixconfig(section=section)
 self._maybetweakdefaults()
 if callable(item.default):
 itemdefault = item.default()
 else:
 itemdefault = item.default
 else:
-msg = "accessing unregistered config item: '%s.%s'"
+msg = b"accessing unregistered config item: '%s.%s'"
 msg %= (section, name)
-self.develwarn(msg, 2, 'warn-config-unknown')
+self.develwarn(msg, 2, b'warn-config-unknown')
 if default is _unset:
 if item is None:
 value = default
 elif item.default is configitems.dynamicdefault:
 value = None
-msg = "config item requires an explicit default value: '%s.%s'"
+msg = b"config item requires an explicit default value: '%s.%s'"
 msg %= (section, name)
-self.develwarn(msg, 2, 'warn-config-default')
+self.develwarn(msg, 2, b'warn-config-default')
 else:
 value = itemdefault
 elif (
 item is not None
 and item.default is not configitems.dynamicdefault
 and default != itemdefault
 ):
 msg = (
-"specifying a mismatched default value for a registered "
+b"specifying a mismatched default value for a registered "
-"config item: '%s.%s' '%s'"
+b"config item: '%s.%s' '%s'"
 )
 msg %= (section, name, pycompat.bytestr(default))
-self.develwarn(msg, 2, 'warn-config-default')
+self.develwarn(msg, 2, b'warn-config-default')
 for s, n in alternates:
 candidate = self._data(untrusted).get(s, n, None)
 if candidate is not None:
 value = candidate
 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 "
+b"ignoring untrusted configuration option "
-"%s.%s = %s\n" % (s, n, uvalue)
+b"%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.
 is a dict of defined sub-options where keys and values are strings.
 """
 main = self.config(section, name, default, untrusted=untrusted)
 data = self._data(untrusted)
 sub = {}
-prefix = '%s:' % name
+prefix = b'%s:' % name
 for k, v in data.items(section):
 if k.startswith(prefix):
 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))
+uvalue = self._ucfg.get(section, b'%s:%s' % (name, k))
 if uvalue is not None and uvalue != v:
 self.debug(
-'ignoring untrusted configuration option '
+b'ignoring untrusted configuration option '
-'%s:%s.%s = %s\n' % (section, name, k, uvalue)
+b'%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'
+b'get a path config item, expanded relative to repo root or config file'
 v = self.config(section, name, default, untrusted)
 if v is None:
 return None
-if not os.path.isabs(v) or "://" not in v:
+if not os.path.isabs(v) or b"://" not in v:
 src = self.configsource(section, name, untrusted)
-if ':' in src:
+if b':' in src:
-base = os.path.dirname(src.rsplit(':')[0])
+base = os.path.dirname(src.rsplit(b':')[0])
 v = os.path.join(base, os.path.expanduser(v))
 return v
 def configbool(self, section, name, default=_unset, untrusted=False):
 """parse a configuration element as a boolean
 if isinstance(v, bool):
 return v
 b = stringutil.parsebool(v)
 if b is None:
 raise error.ConfigError(
-_("%s.%s is not a boolean ('%s')") % (section, name, v)
+_(b"%s.%s is not a boolean ('%s')") % (section, name, v)
 )
 return b
 def configwith(
 self, convert, section, name, default=_unset, desc=None, untrusted=False
 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')") % (section, name, desc, v)
+_(b"%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
 ...
 ConfigError: foo.invalid is not a valid integer ('somevalue')
 """
 return self.configwith(
-int, section, name, default, 'integer', untrusted
+int, section, name, default, b'integer', untrusted
 )
 def configbytes(self, section, name, default=_unset, untrusted=False):
 """parse a configuration element as a quantity in bytes
 return value
 try:
 return util.sizetoint(value)
 except error.ParseError:
 raise error.ConfigError(
-_("%s.%s is not a byte quantity ('%s')")
+_(b"%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
 >>> u.configlist(s, b'list2')
 ['this', 'is', 'a small', 'test']
 """
 # default is not always a list
 v = self.configwith(
-config.parselist, section, name, default, 'list', untrusted
+config.parselist, section, name, default, b'list', untrusted
 )
 if isinstance(v, bytes):
 return config.parselist(v)
 elif v is None:
 return []
 >>> u.configdate(s, b'date')
 (0, 0)
 """
 if self.config(section, name, default, untrusted):
 return self.configwith(
-dateutil.parsedate, section, name, default, 'date', untrusted
+dateutil.parsedate, section, name, default, b'date', untrusted
 )
 if default is _unset:
 return None
 return default
 return section in self._data(untrusted)
 def configitems(self, section, untrusted=False, ignoresub=False):
 items = self._data(untrusted).items(section)
 if ignoresub:
-items = [i for i in items if ':' not in i[0]]
+items = [i for i in items if b':' 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 "
+b"ignoring untrusted configuration option "
-"%s.%s = %s\n" % (section, k, v)
+b"%s.%s = %s\n" % (section, k, v)
 )
 return items
 def walkconfig(self, untrusted=False):
 cfg = self._data(untrusted)
 - 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
+b'HGPLAIN' not in encoding.environ
-and 'HGPLAINEXCEPT' not in encoding.environ
+and b'HGPLAINEXCEPT' not in encoding.environ
 ):
 return False
 exceptions = (
-encoding.environ.get('HGPLAINEXCEPT', '').strip().split(',')
+encoding.environ.get(b'HGPLAINEXCEPT', b'').strip().split(b',')
 )
 # TODO: add support for HGPLAIN=+feature,-feature syntax
-if '+strictflags' not in encoding.environ.get('HGPLAIN', '').split(','):
+if b'+strictflags' not in encoding.environ.get(b'HGPLAIN', b'').split(
-exceptions.append('strictflags')
+b','
+):
+exceptions.append(b'strictflags')
 if feature and exceptions:
 return feature not in exceptions
 return True
 def username(self, acceptempty=False):
 If not found and acceptempty is True, returns None.
 If not found and ui.askusername is True, ask the user, else use
 ($LOGNAME or $USER or $LNAME or $USERNAME) + "@full.hostname".
 If no username could be found, raise an Abort error.
 """
-user = encoding.environ.get("HGUSER")
+user = encoding.environ.get(b"HGUSER")
 if user is None:
-user = self.config("ui", "username")
+user = self.config(b"ui", b"username")
 if user is not None:
 user = os.path.expandvars(user)
 if user is None:
-user = encoding.environ.get("EMAIL")
+user = encoding.environ.get(b"EMAIL")
 if user is None and acceptempty:
 return user
-if user is None and self.configbool("ui", "askusername"):
+if user is None and self.configbool(b"ui", b"askusername"):
-user = self.prompt(_("enter a commit username:"), default=None)
+user = self.prompt(_(b"enter a commit username:"), default=None)
 if user is None and not self.interactive():
 try:
-user = '%s@%s' % (
+user = b'%s@%s' % (
 procutil.getuser(),
 encoding.strtolocal(socket.getfqdn()),
 )
-self.warn(_("no username found, using '%s' instead\n") % user)
+self.warn(_(b"no username found, using '%s' instead\n") % user)
 except KeyError:
 pass
 if not user:
 raise error.Abort(
-_('no username supplied'),
+_(b'no username supplied'),
-hint=_("use 'hg config --edit' " 'to set your username'),
+hint=_(b"use 'hg config --edit' " b'to set your username'),
 )
-if "\n" in user:
+if b"\n" in user:
 raise error.Abort(
-_("username %r contains a newline\n") % pycompat.bytestr(user)
+_(b"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 self._bufferstates:
 self._bufferapplylabels = self._bufferstates[-1][2]
 else:
 self._bufferapplylabels = None
-return "".join(self._buffers.pop())
+return b"".join(self._buffers.pop())
 def _isbuffered(self, dest):
 if dest is self._fout:
 return bool(self._buffers)
 if dest is self._ferr:
 return self._colormode is None
 def canbatchlabeledwrites(self):
 '''check if write calls with labels are batchable'''
 # Windows color printing is special, see ``write``.
-return self._colormode != 'win32'
+return self._colormode != b'win32'
 def write(self, *args, **opts):
 '''write args to output
 By default, this method simply writes to the buffer or stdout.
 '''
 dest = self._fout
 # inlined _write() for speed
 if self._buffers:
-label = opts.get(r'label', '')
+label = opts.get(r'label', b'')
 if label and self._bufferapplylabels:
 self._buffers[-1].extend(self.label(a, label) for a in args)
 else:
 self._buffers[-1].extend(args)
 return
 msg = b''.join(args)
 # opencode timeblockedsection because this is a critical path
 starttime = util.timer()
 try:
-if self._colormode == 'win32':
+if self._colormode == b'win32':
 # windows color printing is its own can of crab, defer to
 # the color module and that is it.
 color.win32print(self, dest.write, msg, **opts)
 else:
 if self._colormode is not None:
-label = opts.get(r'label', '')
+label = opts.get(r'label', b'')
 msg = self.label(msg, label)
 dest.write(msg)
 except IOError as err:
 raise error.StdioError(err)
 finally:
-self._blockedtimes['stdio_blocked'] += (
+self._blockedtimes[b'stdio_blocked'] += (
 util.timer() - starttime
 ) * 1000
 def write_err(self, *args, **opts):
 self._write(self._ferr, *args, **opts)
 def _write(self, dest, *args, **opts):
 # update write() as well if you touch this code
 if self._isbuffered(dest):
-label = opts.get(r'label', '')
+label = opts.get(r'label', b'')
 if label and self._bufferapplylabels:
 self._buffers[-1].extend(self.label(a, label) for a in args)
 else:
 self._buffers[-1].extend(args)
 else:
 self._fout.flush()
 if getattr(dest, 'structured', False):
 # channel for machine-readable output with metadata, where
 # no extra colorization is necessary.
 dest.write(msg, **opts)
-elif self._colormode == 'win32':
+elif self._colormode == b'win32':
 # windows color printing is its own can of crab, defer to
 # the color module and that is it.
 color.win32print(self, dest.write, msg, **opts)
 else:
 if self._colormode is not None:
-label = opts.get(r'label', '')
+label = opts.get(r'label', b'')
 msg = self.label(msg, label)
 dest.write(msg)
 # stderr may be buffered under win32 when redirected to files,
 # including stdout.
 if dest is self._ferr and not getattr(self._ferr, 'closed', False):
 ):
 # no way to report the error, so ignore it
 return
 raise error.StdioError(err)
 finally:
-self._blockedtimes['stdio_blocked'] += (
+self._blockedtimes[b'stdio_blocked'] += (
 util.timer() - starttime
 ) * 1000
 def _writemsg(self, dest, *args, **opts):
 _writemsgwith(self._write, dest, *args, **opts)
 self._ferr.flush()
 except IOError as err:
 if err.errno not in (errno.EPIPE, errno.EIO, errno.EBADF):
 raise error.StdioError(err)
 finally:
-self._blockedtimes['stdio_blocked'] += (
+self._blockedtimes[b'stdio_blocked'] += (
 util.timer() - starttime
 ) * 1000
 def _isatty(self, fh):
-if self.configbool('ui', 'nontty'):
+if self.configbool(b'ui', b'nontty'):
 return False
 return procutil.isatty(fh)
 def protectfinout(self):
 """Duplicate ui streams and redirect original if they are stdio
 """
 if self._disablepager or self.pageractive:
 # how pager should do is already determined
 return
-if not command.startswith('internal-always-') and (
+if not command.startswith(b'internal-always-') and (
 # explicit --pager=on (= 'internal-always-' prefix) should
 # take precedence over disabling factors below
-command in self.configlist('pager', 'ignore')
+command in self.configlist(b'pager', b'ignore')
-or not self.configbool('ui', 'paginate')
+or not self.configbool(b'ui', b'paginate')
-or not self.configbool('pager', 'attend-' + command, True)
+or not self.configbool(b'pager', b'attend-' + command, True)
-or encoding.environ.get('TERM') == 'dumb'
+or encoding.environ.get(b'TERM') == b'dumb'
 # TODO: if we want to allow HGPLAINEXCEPT=pager,
 # 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 b'--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
-pagercmd = self.config('pager', 'pager', rcutil.fallbackpager)
+pagercmd = self.config(b'pager', b'pager', rcutil.fallbackpager)
 if not pagercmd:
 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' % stringutil.pprint(command)
+b'starting pager for command %s\n' % stringutil.pprint(command)
 )
 self.flush()
 wasformatted = self.formatted()
-if util.safehasattr(signal, "SIGPIPE"):
+if util.safehasattr(signal, b"SIGPIPE"):
 signal.signal(signal.SIGPIPE, _catchterm)
 if self._runpager(pagercmd, pagerenv):
 self.pageractive = True
 # Preserve the formatted-ness of the UI. This is important
 # because we mess with stdout, which might confuse
 # auto-detection of things being formatted.
-self.setconfig('ui', 'formatted', wasformatted, 'pager')
+self.setconfig(b'ui', b'formatted', wasformatted, b'pager')
-self.setconfig('ui', 'interactive', False, 'pager')
+self.setconfig(b'ui', b'interactive', False, b'pager')
 # If pagermode differs from color.mode, reconfigure color now that
 # pageractive is set.
 cm = self._colormode
-if cm != self.config('color', 'pagermode', cm):
+if cm != self.config(b'color', b'pagermode', cm):
 color.setup(self)
 else:
 # If the pager can't be spawned in dispatch when --pager=on is
 # given, don't try again when the command runs, to avoid a duplicate
 # warning about a missing pager command.
 """Actually start the pager and set up file descriptors.
 This is separate in part so that extensions (like chg) can
 override how a pager is invoked.
 """
-if command == 'cat':
+if command == b'cat':
 # Save ourselves some work.
 return False
 # If the command doesn't contain any of these characters, we
 # assume it's a binary and exec it directly. This means for
 # simple pager command configurations, we can degrade
 # gracefully and tell the user about their broken pager.
-shell = any(c in command for c in "|&;<>()$`\\\"' \t\n*?[#~=%")
+shell = any(c in command for c in b"|&;<>()$`\\\"' \t\n*?[#~=%")
 if pycompat.iswindows and not shell:
 # Window's built-in `more` cannot be invoked with shell=False, but
 # its `more.com` can.  Hide this implementation detail from the
 # 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") % command
+_(b"missing pager command '%s', skipping pager\n") % command
 )
 return False
 command = fullcmd
 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") % command
+_(b"missing pager command '%s', skipping pager\n") % command
 )
 return False
 raise
 # back up original file descriptors
 if self._isatty(procutil.stderr):
 os.dup2(pager.stdin.fileno(), procutil.stderr.fileno())
 @self.atexit
 def killpager():
-if util.safehasattr(signal, "SIGINT"):
+if util.safehasattr(signal, b"SIGINT"):
 signal.signal(signal.SIGINT, signal.SIG_IGN)
 # restore original fds, closing pager.stdin copies in the process
 os.dup2(stdoutfd, procutil.stdout.fileno())
 os.dup2(stderrfd, procutil.stderr.fileno())
 pager.stdin.close()
 ui.interface.histedit = text
 Then histedit will use the text interface and chunkselector will use
 the default curses interface (crecord at the moment).
 """
-alldefaults = frozenset(["text", "curses"])
+alldefaults = frozenset([b"text", b"curses"])
 featureinterfaces = {
-"chunkselector": ["text", "curses",],
+b"chunkselector": [b"text", b"curses",],
-"histedit": ["text", "curses",],
+b"histedit": [b"text", b"curses",],
 }
 # Feature-specific interface
 if feature not in featureinterfaces.keys():
 # Programming error, not user error
-raise ValueError("Unknown feature requested %s" % feature)
+raise ValueError(b"Unknown feature requested %s" % feature)
 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
+b"Feature %s does not handle all default interfaces" % feature
 )
-if self.plain() or encoding.environ.get('TERM') == 'dumb':
+if self.plain() or encoding.environ.get(b'TERM') == b'dumb':
-return "text"
+return b"text"
 # Default interface for all the features
-defaultinterface = "text"
+defaultinterface = b"text"
-i = self.config("ui", "interface")
+i = self.config(b"ui", b"interface")
 if i in alldefaults:
 defaultinterface = i
 choseninterface = defaultinterface
-f = self.config("ui", "interface.%s" % feature)
+f = self.config(b"ui", b"interface.%s" % feature)
 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") % (i,))
+self.warn(_(b"invalid value for ui.interface: %s\n") % (i,))
 else:
 self.warn(
-_("invalid value for ui.interface: %s (using %s)\n")
+_(b"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")
+_(b"invalid value for ui.interface.%s: %s (using %s)\n")
 % (feature, f, choseninterface)
 )
 return choseninterface
 configuration variable or - if it is unset - when `sys.stdin' points
 to a terminal device.
 This function refers to input only; for output, see `ui.formatted()'.
 '''
-i = self.configbool("ui", "interactive")
+i = self.configbool(b"ui", b"interactive")
 if i is None:
 # some environments replace stdin without implementing isatty
 # usually those are non-interactive
 return self._isatty(self._fin)
 return i
 def termwidth(self):
 '''how wide is the terminal in columns?
 '''
-if 'COLUMNS' in encoding.environ:
+if b'COLUMNS' in encoding.environ:
 try:
-return int(encoding.environ['COLUMNS'])
+return int(encoding.environ[b'COLUMNS'])
 except ValueError:
 pass
 return scmutil.termsize(self)[0]
 def formatted(self):
 This function always returns false when in plain mode, see `ui.plain()'.
 '''
 if self.plain():
 return False
-i = self.configbool("ui", "formatted")
+i = self.configbool(b"ui", b"formatted")
 if i is None:
 # some environments replace stdout without implementing isatty
 # usually those are non-interactive
 return self._isatty(self._fout)
 return i
-def _readline(self, prompt=' ', promptopts=None):
+def _readline(self, prompt=b' ', 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 = (
 readline.read_history_file
 # windows sometimes raises something other than ImportError
 except Exception:
 usereadline = False
-if self._colormode == 'win32' or not usereadline:
+if self._colormode == b'win32' or not usereadline:
 if not promptopts:
 promptopts = {}
 self._writemsgnobuf(
-self._fmsgout, prompt, type='prompt', **promptopts
+self._fmsgout, prompt, type=b'prompt', **promptopts
 )
 self.flush()
-prompt = ' '
+prompt = b' '
 else:
-prompt = self.label(prompt, 'ui.prompt') + ' '
+prompt = self.label(prompt, b'ui.prompt') + b' '
 # prompt ' ' must exist; otherwise readline may delete entire line
 # - http://bugs.python.org/issue12833
-with self.timeblockedsection('stdio'):
+with self.timeblockedsection(b'stdio'):
 if usereadline:
 line = encoding.strtolocal(pycompat.rawinput(prompt))
 # When stdin is in binary mode on Windows, it can cause
 # raw_input() to emit an extra trailing carriage return
 if pycompat.oslinesep == b'\r\n' and line.endswith(b'\r'):
 raise EOFError
 line = line.rstrip(pycompat.oslinesep)
 return line
-def prompt(self, msg, default="y"):
+def prompt(self, msg, default=b"y"):
 """Prompt user with msg, read response.
 If ui is not interactive, the default is returned.
 """
 return self._prompt(msg, default=default)
 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, msg, b' ', type=b'prompt', **opts)
 self._writemsg(
-self._fmsgout, default or '', "\n", type='promptecho'
+self._fmsgout, default or b'', b"\n", type=b'promptecho'
 )
 return default
 try:
 r = self._readline(prompt=msg, promptopts=opts)
 if not r:
 r = default
-if self.configbool('ui', 'promptecho'):
+if self.configbool(b'ui', b'promptecho'):
-self._writemsg(self._fmsgout, r, "\n", type='promptecho')
+self._writemsg(self._fmsgout, r, b"\n", type=b'promptecho')
 return r
 except EOFError:
 raise error.ResponseExpected()
 @staticmethod
 # prompt to start parsing. Sadly, we also can't rely on
 # 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('$$')]
+choices = [p.strip(b' ') for p in m.group(2).split(b'$$')]
 def choicetuple(s):
-ampidx = s.index('&')
+ampidx = s.index(b'&')
-return s[ampidx + 1 : ampidx + 2].lower(), s.replace('&', '', 1)
+return s[ampidx + 1 : ampidx + 2].lower(), s.replace(b'&', b'', 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
 while True:
 r = self._prompt(msg, default=resps[default], choices=choices)
 if r.lower() in resps:
 return resps.index(r.lower())
 # TODO: shouldn't it be a warning?
-self._writemsg(self._fmsgout, _("unrecognized response\n"))
+self._writemsg(self._fmsgout, _(b"unrecognized response\n"))
 def getpass(self, prompt=None, default=None):
 if not self.interactive():
 return default
 try:
 self._writemsg(
 self._fmsgerr,
-prompt or _('password: '),
+prompt or _(b'password: '),
-type='prompt',
+type=b'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'):
+with self.timeblockedsection(b'stdio'):
-if self.configbool('ui', 'nontty'):
+if self.configbool(b'ui', b'nontty'):
 l = self._fin.readline()
 if not l:
 raise EOFError
-return l.rstrip('\n')
+return l.rstrip(b'\n')
 else:
 return getpass.getpass(r'')
 except EOFError:
 raise error.ResponseExpected()
 '''write status message to output (if ui.quiet is False)
 This adds an output label of "ui.status".
 '''
 if not self.quiet:
-self._writemsg(self._fmsgout, type='status', *msg, **opts)
+self._writemsg(self._fmsgout, type=b'status', *msg, **opts)
 def warn(self, *msg, **opts):
 '''write warning message to output (stderr)
 This adds an output label of "ui.warning".
 '''
-self._writemsg(self._fmsgerr, type='warning', *msg, **opts)
+self._writemsg(self._fmsgerr, type=b'warning', *msg, **opts)
 def error(self, *msg, **opts):
 '''write error message to output (stderr)
 This adds an output label of "ui.error".
 '''
-self._writemsg(self._fmsgerr, type='error', *msg, **opts)
+self._writemsg(self._fmsgerr, type=b'error', *msg, **opts)
 def note(self, *msg, **opts):
 '''write note to output (if ui.verbose is True)
 This adds an output label of "ui.note".
 '''
 if self.verbose:
-self._writemsg(self._fmsgout, type='note', *msg, **opts)
+self._writemsg(self._fmsgout, type=b'note', *msg, **opts)
 def debug(self, *msg, **opts):
 '''write debug message to output (if ui.debugflag is True)
 This adds an output label of "ui.debug".
 '''
 if self.debugflag:
-self._writemsg(self._fmsgout, type='debug', *msg, **opts)
+self._writemsg(self._fmsgout, type=b'debug', *msg, **opts)
 self.log(b'debug', b'%s', b''.join(msg))
 def edit(
 self,
 text,
 repopath=None,
 action=None,
 ):
 if action is None:
 self.develwarn(
-'action is None but will soon be a required '
+b'action is None but will soon be a required '
-'parameter to ui.edit()'
+b'parameter to ui.edit()'
 )
 extra_defaults = {
-'prefix': 'editor',
+b'prefix': b'editor',
-'suffix': '.txt',
+b'suffix': b'.txt',
 }
 if extra is not None:
-if extra.get('suffix') is not None:
+if extra.get(b'suffix') is not None:
 self.develwarn(
-'extra.suffix is not None but will soon be '
+b'extra.suffix is not None but will soon be '
-'ignored by ui.edit()'
+b'ignored by ui.edit()'
 )
 extra_defaults.update(extra)
 extra = extra_defaults
-if action == 'diff':
+if action == b'diff':
-suffix = '.diff'
+suffix = b'.diff'
 elif action:
-suffix = '.%s.hg.txt' % action
+suffix = b'.%s.hg.txt' % action
 else:
-suffix = extra['suffix']
+suffix = extra[b'suffix']
 rdir = None
-if self.configbool('experimental', 'editortmpinhg'):
+if self.configbool(b'experimental', b'editortmpinhg'):
 rdir = repopath
 (fd, name) = pycompat.mkstemp(
-prefix='hg-' + extra['prefix'] + '-', suffix=suffix, dir=rdir
+prefix=b'hg-' + extra[b'prefix'] + b'-', suffix=suffix, dir=rdir
 )
 try:
 f = os.fdopen(fd, r'wb')
 f.write(util.tonativeeol(text))
 f.close()
-environ = {'HGUSER': user}
+environ = {b'HGUSER': user}
-if 'transplant_source' in extra:
+if b'transplant_source' in extra:
-environ.update({'HGREVISION': hex(extra['transplant_source'])})
+environ.update(
-for label in ('intermediate-source', 'source', 'rebase_source'):
+{b'HGREVISION': hex(extra[b'transplant_source'])}
+)
+for label in (b'intermediate-source', b'source', b'rebase_source'):
 if label in extra:
-environ.update({'HGREVISION': extra[label]})
+environ.update({b'HGREVISION': extra[label]})
 break
 if editform:
-environ.update({'HGEDITFORM': editform})
+environ.update({b'HGEDITFORM': editform})
 if pending:
-environ.update({'HG_PENDING': pending})
+environ.update({b'HG_PENDING': pending})
 editor = self.geteditor()
 self.system(
-"%s \"%s\"" % (editor, name),
+b"%s \"%s\"" % (editor, name),
 environ=environ,
 onerr=error.Abort,
-errprefix=_("edit failed"),
+errprefix=_(b"edit failed"),
-blockedtag='editor',
+blockedtag=b'editor',
 )
 f = open(name, r'rb')
 t = util.fromnativeeol(f.read())
 f.close()
 '''
 if blockedtag is None:
 # Long cmds tend to be because of an absolute path on cmd. Keep
 # the tail end instead
 cmdsuffix = cmd.translate(None, _keepalnum)[-85:]
-blockedtag = 'unknown_system_' + cmdsuffix
+blockedtag = b'unknown_system_' + cmdsuffix
 out = self._fout
 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' % (
+errmsg = b'%s %s' % (
 os.path.basename(cmd.split(None, 1)[0]),
 procutil.explainexit(rc),
 )
 if errprefix:
-errmsg = '%s: %s' % (errprefix, errmsg)
+errmsg = b'%s: %s' % (errprefix, errmsg)
 raise onerr(errmsg)
 return rc
 def _runsystem(self, cmd, environ, cwd, out):
 """actually execute the given shell command (can be overridden by
 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',
+b'Traceback (most recent call last):\n',
-''.join(exctb[:-1]),
+b''.join(exctb[:-1]),
-''.join(causetb),
+b''.join(causetb),
-''.join(exconly),
+b''.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
 def geteditor(self):
 '''return editor to use'''
-if pycompat.sysplatform == 'plan9':
+if pycompat.sysplatform == b'plan9':
 # vi is the MIPS instruction simulator on Plan 9. We
 # instead default to E to plumb commit messages to
 # avoid confusion.
-editor = 'E'
+editor = b'E'
 else:
-editor = 'vi'
+editor = b'vi'
-return encoding.environ.get("HGEDITOR") or self.config(
+return encoding.environ.get(b"HGEDITOR") or self.config(
-"ui", "editor", editor
+b"ui", b"editor", editor
 )
 @util.propertycache
 def _progbar(self):
 """setup the progbar singleton to the ui object"""
 if (
 self.quiet
 or self.debugflag
-or self.configbool('progress', 'disable')
+or self.configbool(b'progress', b'disable')
 or not progress.shouldprint(self)
 ):
 return None
 return getprogbar(self)
 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):
+def progress(self, topic, pos, item=b"", unit=b"", total=None):
 '''show a progress message
 By default a textual progress bar will be displayed if an operation
 takes too long. 'topic' is the current operation, 'item' is a
 non-numeric marker of the current position (i.e. the currently
 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()", "5.1")
+self.deprecwarn(
+b"use ui.makeprogress() instead of ui.progress()", b"5.1"
+)
 progress = self.makeprogress(topic, unit, total)
 if pos is not None:
 progress.update(pos, item=item)
 else:
 progress.complete()
-def makeprogress(self, topic, unit="", total=None):
+def makeprogress(self, topic, unit=b"", total=None):
 """Create a progress helper for the specified topic"""
 if getattr(self._fmsgerr, 'structured', False):
 # channel for machine-readable output with metadata, just send
 # raw information
 # TODO: consider porting some useful information (e.g. estimated
 """issue a developer warning message
 Use 'stacklevel' to report the offender some layers further up in the
 stack.
 """
-if not self.configbool('devel', 'all-warnings'):
+if not self.configbool(b'devel', b'all-warnings'):
-if config is None or not self.configbool('devel', config):
+if config is None or not self.configbool(b'devel', config):
 return
-msg = 'devel-warn: ' + msg
+msg = b'devel-warn: ' + msg
 stacklevel += 1  # get in develwarn
 if self.tracebackflag:
 util.debugstacktrace(msg, stacklevel, self._ferr, self._fout)
 self.log(
-'develwarn',
+b'develwarn',
-'%s at:\n%s' % (msg, ''.join(util.getstackframes(stacklevel))),
+b'%s at:\n%s'
+% (msg, b''.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' % (msg, fname, lineno, fmsg))
+self.write_err(b'%s at: %s:%d (%s)\n' % (msg, fname, lineno, fmsg))
 self.log(
-'develwarn', '%s at: %s:%d (%s)\n', msg, fname, lineno, fmsg
+b'develwarn', b'%s at: %s:%d (%s)\n', 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')
+self.configbool(b'devel', b'all-warnings')
-or self.configbool('devel', 'deprec-warn')
+or self.configbool(b'devel', b'deprec-warn')
 ):
 return
 msg += (
-"\n(compatibility will be dropped after Mercurial-%s,"
+b"\n(compatibility will be dropped after Mercurial-%s,"
-" update your code.)"
+b" update your code.)"
 ) % version
-self.develwarn(msg, stacklevel=stacklevel, config='deprec-warn')
+self.develwarn(msg, stacklevel=stacklevel, config=b'deprec-warn')
 def exportableenviron(self):
 """The environment variables that are safe to export, e.g. through
 hgweb.
 """
 return self._exportableenviron
 @contextlib.contextmanager
-def configoverride(self, overrides, source=""):
+def configoverride(self, overrides, source=b""):
 """Context manager for temporary config overrides
 `overrides` must be a dict of the following structure:
 {(section, name) : value}"""
 backups = {}
 try:
 finally:
 for __, backup in backups.items():
 self.restoreconfig(backup)
 # 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:
+if (b'ui', b'quiet') in overrides:
-self.fixconfig(section='ui')
+self.fixconfig(section=b'ui')
 class paths(dict):
 """Represents a collection of paths and their configs.
 """
 def __init__(self, ui):
 dict.__init__(self)
-for name, loc in ui.configitems('paths', ignoresub=True):
+for name, loc in ui.configitems(b'paths', ignoresub=True):
 # No location is the same as not existing.
 if not loc:
 continue
-loc, sub = ui.configsuboptions('paths', name)
+loc, sub = ui.configsuboptions(b'paths', name)
 self[name] = path(ui, name, rawloc=loc, suboptions=sub)
 def getpath(self, name, default=None):
 """Return a ``path`` from a string, falling back to default.
 # 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') % name)
+raise error.RepoError(_(b'repository %s does not exist') % name)
 _pathsuboptions = {}
 return func
 return register
-@pathsuboption('pushurl', 'pushloc')
+@pathsuboption(b'pushurl', b'pushloc')
 def pushurlpathoption(ui, path, value):
 u = util.url(value)
 # Actually require a URL.
 if not u.scheme:
-ui.warn(_('(paths.%s:pushurl not a URL; ignoring)\n') % path.name)
+ui.warn(_(b'(paths.%s:pushurl not a URL; ignoring)\n') % path.name)
 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; ' 'ignoring)\n')
+_(
+b'("#fragment" in paths.%s:pushurl not supported; '
+b'ignoring)\n'
+)
 % path.name
 )
 u.fragment = None
 return bytes(u)
-@pathsuboption('pushrev', 'pushrev')
+@pathsuboption(b'pushrev', b'pushrev')
 def pushrevpathoption(ui, path, value):
 return value
 class path(object):
 If ``name`` is not defined, we require that the location be a) a local
 filesystem path with a .hg directory or b) a URL. If not,
 ``ValueError`` is raised.
 """
 if not rawloc:
-raise ValueError('rawloc must be defined')
+raise ValueError(b'rawloc must be defined')
 # Locations may define branches via syntax <base>#<branch>.
 u = util.url(rawloc)
 branch = None
 if u.fragment:
 self.url = u
 self.branch = branch
 self.name = name
 self.rawloc = rawloc
-self.loc = '%s' % u
+self.loc = b'%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 ' 'repo: %s' % rawloc
+b'location is not a URL or path to a local '
+b'repo: %s' % rawloc
 )
 suboptions = suboptions or {}
 # Now process the sub-options. If a sub-option is registered, its
 """Returns True if the given path is a potentially valid repository.
 This is its own function so that extensions can change the definition of
 'valid' in this case (like when pulling from a git repo into a hg
 one)."""
 try:
-return os.path.isdir(os.path.join(path, '.hg'))
+return os.path.isdir(os.path.join(path, b'.hg'))
 # Python 2 may return TypeError. Python 3, ValueError.
 except (TypeError, ValueError):
 return False
 @property
 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.
 """
 # TODO: maybe change 'type' to a mandatory option
 if r'type' in opts and not getattr(dest, 'structured', False):
-opts[r'label'] = opts.get(r'label', '') + ' ui.%s' % opts.pop(r'type')
+opts[r'label'] = opts.get(r'label', b'') + b' ui.%s' % opts.pop(r'type')
 write(dest, *args, **opts)

changeset 43077	687b865b95ad
parent 43076	2372284d9457
child 43079	5209fc94b982