formatting: byteify all mercurial/ and hgext/ string literals

Done with

    python3.7 contrib/byteify-strings.py -i $(hg files 'set:mercurial/**.py - mercurial/thirdparty/** + hgext/**.py - hgext/fsmonitor/pywatchman/** - mercurial/__init__.py')
    black -l 80 -t py33 -S $(hg files 'set:**.py - mercurial/thirdparty/** - "contrib/python-zstandard/**" - hgext/fsmonitor/pywatchman/**')

# skip-blame mass-reformatting only

Differential Revision: https://phab.mercurial-scm.org/D6972

hgext/absorb.py

@@ -59,7 +59,7 b' from mercurial.utils import stringutil'
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
-testedwith = 'ships-with-hg-core'
+testedwith = b'ships-with-hg-core'
 
 cmdtable = {}
 command = registrar.command(cmdtable)
@@ -67,14 +67,14 b' command = registrar.command(cmdtable)'
 configtable = {}
 configitem = registrar.configitem(configtable)
 
-configitem('absorb', 'add-noise', default=True)
-configitem('absorb', 'amend-flag', default=None)
-configitem('absorb', 'max-stack-size', default=50)
+configitem(b'absorb', b'add-noise', default=True)
+configitem(b'absorb', b'amend-flag', default=None)
+configitem(b'absorb', b'max-stack-size', default=50)
 
 colortable = {
-    'absorb.description': 'yellow',
-    'absorb.node': 'blue bold',
-    'absorb.path': 'bold',
+    b'absorb.description': b'yellow',
+    b'absorb.node': b'blue bold',
+    b'absorb.path': b'bold',
 }
 
 defaultdict = collections.defaultdict
@@ -98,7 +98,7 b' class emptyfilecontext(object):'
     """minimal filecontext representing an empty file"""
 
     def data(self):
-        return ''
+        return b''
 
     def node(self):
         return node.nullid
@@ -364,11 +364,11 b' class filefixupstate(object):'
             if self.ui.debugflag:
                 idx = (max(rev - 1, 0)) // 2
                 self.ui.write(
-                    _('%s: chunk %d:%d -> %d lines\n')
+                    _(b'%s: chunk %d:%d -> %d lines\n')
                     % (node.short(self.fctxs[idx].node()), a1, a2, len(blines))
                 )
             self.linelog.replacelines(rev, a1, a2, b1, b2)
-        if self.opts.get('edit_lines', False):
+        if self.opts.get(b'edit_lines', False):
             self.finalcontents = self._checkoutlinelogwithedits()
         else:
             self.finalcontents = self._checkoutlinelog()
@@ -434,7 +434,7 b' class filefixupstate(object):'
         """like mdiff.allblocks, but only care about differences"""
         blocks = mdiff.allblocks(a, b, lines1=alines, lines2=blines)
         for chunk, btype in blocks:
-            if btype != '!':
+            if btype != b'!':
                 continue
             yield chunk
 
@@ -443,7 +443,7 b' class filefixupstate(object):'
         this is similar to running a partial "annotate".
         """
         llog = linelog.linelog()
-        a, alines = '', []
+        a, alines = b'', []
         for i in pycompat.xrange(len(self.contents)):
             b, blines = self.contents[i], self.contentlines[i]
             llrev = i * 2 + 1
@@ -459,7 +459,7 b' class filefixupstate(object):'
         for i in pycompat.xrange(len(self.contents)):
             rev = (i + 1) * 2
             self.linelog.annotate(rev)
-            content = ''.join(map(self._getline, self.linelog.annotateresult))
+            content = b''.join(map(self._getline, self.linelog.annotateresult))
             contents.append(content)
         return contents
 
@@ -469,8 +469,8 b' class filefixupstate(object):'
         # header
         editortext = (
             _(
-                'HG: editing %s\nHG: "y" means the line to the right '
-                'exists in the changeset to the top\nHG:\n'
+                b'HG: editing %s\nHG: "y" means the line to the right '
+                b'exists in the changeset to the top\nHG:\n'
             )
             % self.fctxs[-1].path()
         )
@@ -481,13 +481,13 b' class filefixupstate(object):'
             if not isinstance(f, emptyfilecontext)
         ]
         for i, (j, f) in enumerate(visiblefctxs):
-            editortext += _('HG: %s/%s %s %s\n') % (
-                '|' * i,
-                '-' * (len(visiblefctxs) - i + 1),
+            editortext += _(b'HG: %s/%s %s %s\n') % (
+                b'|' * i,
+                b'-' * (len(visiblefctxs) - i + 1),
                 node.short(f.node()),
-                f.description().split('\n', 1)[0],
+                f.description().split(b'\n', 1)[0],
             )
-        editortext += _('HG: %s\n') % ('|' * len(visiblefctxs))
+        editortext += _(b'HG: %s\n') % (b'|' * len(visiblefctxs))
         # figure out the lifetime of a line, this is relatively inefficient,
         # but probably fine
         lineset = defaultdict(lambda: set())  # {(llrev, linenum): {llrev}}
@@ -497,33 +497,33 b' class filefixupstate(object):'
                 lineset[l].add(i)
         # append lines
         for l in alllines:
-            editortext += '    %s : %s' % (
-                ''.join(
+            editortext += b'    %s : %s' % (
+                b''.join(
                     [
-                        ('y' if i in lineset[l] else ' ')
+                        (b'y' if i in lineset[l] else b' ')
                         for i, _f in visiblefctxs
                     ]
                 ),
                 self._getline(l),
             )
         # run editor
-        editedtext = self.ui.edit(editortext, '', action='absorb')
+        editedtext = self.ui.edit(editortext, b'', action=b'absorb')
         if not editedtext:
-            raise error.Abort(_('empty editor text'))
+            raise error.Abort(_(b'empty editor text'))
         # parse edited result
-        contents = ['' for i in self.fctxs]
+        contents = [b'' for i in self.fctxs]
         leftpadpos = 4
         colonpos = leftpadpos + len(visiblefctxs) + 1
         for l in mdiff.splitnewlines(editedtext):
-            if l.startswith('HG:'):
+            if l.startswith(b'HG:'):
                 continue
-            if l[colonpos - 1 : colonpos + 2] != ' : ':
-                raise error.Abort(_('malformed line: %s') % l)
+            if l[colonpos - 1 : colonpos + 2] != b' : ':
+                raise error.Abort(_(b'malformed line: %s') % l)
             linecontent = l[colonpos + 2 :]
             for i, ch in enumerate(
                 pycompat.bytestr(l[leftpadpos : colonpos - 1])
             ):
-                if ch == 'y':
+                if ch == b'y':
                     contents[visiblefctxs[i][0]] += linecontent
         # chunkstats is hard to calculate if anything changes, therefore
         # set them to just a simple value (1, 1).
@@ -589,7 +589,7 b' class filefixupstate(object):'
 
     def _showchanges(self, fm, alines, blines, chunk, fixups):
         def trim(line):
-            if line.endswith('\n'):
+            if line.endswith(b'\n'):
                 line = line[:-1]
             return line
 
@@ -605,25 +605,25 b' class filefixupstate(object):'
 
         fm.startitem()
         fm.write(
-            'hunk',
-            '        %s\n',
-            '@@ -%d,%d +%d,%d @@' % (a1, a2 - a1, b1, b2 - b1),
-            label='diff.hunk',
+            b'hunk',
+            b'        %s\n',
+            b'@@ -%d,%d +%d,%d @@' % (a1, a2 - a1, b1, b2 - b1),
+            label=b'diff.hunk',
         )
-        fm.data(path=self.path, linetype='hunk')
+        fm.data(path=self.path, linetype=b'hunk')
 
         def writeline(idx, diffchar, line, linetype, linelabel):
             fm.startitem()
-            node = ''
+            node = b''
             if idx:
                 ctx = self.fctxs[idx]
                 fm.context(fctx=ctx)
                 node = ctx.hex()
                 self.ctxaffected.add(ctx.changectx())
-            fm.write('node', '%-7.7s ', node, label='absorb.node')
+            fm.write(b'node', b'%-7.7s ', node, label=b'absorb.node')
             fm.write(
-                'diffchar ' + linetype,
-                '%s%s\n',
+                b'diffchar ' + linetype,
+                b'%s%s\n',
                 diffchar,
                 line,
                 label=linelabel,
@@ -632,11 +632,19 b' class filefixupstate(object):'
 
         for i in pycompat.xrange(a1, a2):
             writeline(
-                aidxs[i - a1], '-', trim(alines[i]), 'deleted', 'diff.deleted'
+                aidxs[i - a1],
+                b'-',
+                trim(alines[i]),
+                b'deleted',
+                b'diff.deleted',
             )
         for i in pycompat.xrange(b1, b2):
             writeline(
-                bidxs[i - b1], '+', trim(blines[i]), 'inserted', 'diff.inserted'
+                bidxs[i - b1],
+                b'+',
+                trim(blines[i]),
+                b'inserted',
+                b'diff.inserted',
             )
 
 
@@ -681,7 +689,7 b' class fixupstate(object):'
         self.paths = []
         # but if --edit-lines is used, the user may want to edit files
         # even if they are not modified
-        editopt = self.opts.get('edit_lines')
+        editopt = self.opts.get(b'edit_lines')
         if not self.status.modified and editopt and match:
             interestingpaths = match.files()
         else:
@@ -691,7 +699,7 b' class fixupstate(object):'
         # sorting is necessary to eliminate ambiguity for the "double move"
         # case: "hg cp A B; hg cp A C; hg rm A", then only "B" can affect "A".
         for path in sorted(interestingpaths):
-            self.ui.debug('calculating fixups for %s\n' % path)
+            self.ui.debug(b'calculating fixups for %s\n' % path)
             targetfctx = targetctx[path]
             fctxs, ctx2fctx = getfilestack(self.stack, path, seenfctxs)
             # ignore symbolic links or binary, or unchanged files
@@ -708,9 +716,9 b' class fixupstate(object):'
             fstate = filefixupstate(fctxs, path, ui=self.ui, opts=self.opts)
             if fm is not None:
                 fm.startitem()
-                fm.plain('showing changes for ')
-                fm.write('path', '%s\n', path, label='absorb.path')
-                fm.data(linetype='path')
+                fm.plain(b'showing changes for ')
+                fm.write(b'path', b'%s\n', path, label=b'absorb.path')
+                fm.data(linetype=b'path')
             fstate.diffwith(targetfctx, fm)
             self.fixupmap[path] = fstate
             self.paths.append(path)
@@ -720,7 +728,7 b' class fixupstate(object):'
         """apply fixups to individual filefixupstates"""
         for path, state in self.fixupmap.iteritems():
             if self.ui.debugflag:
-                self.ui.write(_('applying fixups to %s\n') % path)
+                self.ui.write(_(b'applying fixups to %s\n') % path)
             state.apply()
 
     @property
@@ -733,10 +741,10 b' class fixupstate(object):'
 
     def commit(self):
         """commit changes. update self.finalnode, self.replacemap"""
-        with self.repo.transaction('absorb') as tr:
+        with self.repo.transaction(b'absorb') as tr:
             self._commitstack()
             self._movebookmarks(tr)
-            if self.repo['.'].node() in self.replacemap:
+            if self.repo[b'.'].node() in self.replacemap:
                 self._moveworkingdirectoryparent()
             self._cleanupoldcommits()
         return self.finalnode
@@ -750,14 +758,14 b' class fixupstate(object):'
             for path, stat in chunkstats.iteritems():
                 if stat[0]:
                     ui.write(
-                        _('%s: %d of %d chunk(s) applied\n')
+                        _(b'%s: %d of %d chunk(s) applied\n')
                         % (path, stat[0], stat[1])
                     )
         elif not ui.quiet:
             # a summary for all files
             stats = chunkstats.values()
             applied, total = (sum(s[i] for s in stats) for i in (0, 1))
-            ui.write(_('%d of %d chunk(s) applied\n') % (applied, total))
+            ui.write(_(b'%d of %d chunk(s) applied\n') % (applied, total))
 
     def _commitstack(self):
         """make new commits. update self.finalnode, self.replacemap.
@@ -777,7 +785,7 b' class fixupstate(object):'
             if self._willbecomenoop(memworkingcopy, ctx, nextp1):
                 # changeset is no longer necessary
                 self.replacemap[ctx.node()] = None
-                msg = _('became empty and was dropped')
+                msg = _(b'became empty and was dropped')
             else:
                 # changeset needs re-commit
                 nodestr = self._commitsingle(memworkingcopy, ctx, p1=nextp1)
@@ -785,21 +793,21 b' class fixupstate(object):'
                 nextp1 = lastcommitted
                 self.replacemap[ctx.node()] = lastcommitted.node()
                 if memworkingcopy:
-                    msg = _('%d file(s) changed, became %s') % (
+                    msg = _(b'%d file(s) changed, became %s') % (
                         len(memworkingcopy),
                         self._ctx2str(lastcommitted),
                     )
                 else:
-                    msg = _('became %s') % self._ctx2str(lastcommitted)
+                    msg = _(b'became %s') % self._ctx2str(lastcommitted)
             if self.ui.verbose and msg:
-                self.ui.write(_('%s: %s\n') % (self._ctx2str(ctx), msg))
+                self.ui.write(_(b'%s: %s\n') % (self._ctx2str(ctx), msg))
         self.finalnode = lastcommitted and lastcommitted.node()
 
     def _ctx2str(self, ctx):
         if self.ui.debugflag:
-            return '%d:%s' % (ctx.rev(), ctx.hex())
+            return b'%d:%s' % (ctx.rev(), ctx.hex())
         else:
-            return '%d:%s' % (ctx.rev(), node.short(ctx.node()))
+            return b'%d:%s' % (ctx.rev(), node.short(ctx.node()))
 
     def _getnewfilecontents(self, ctx):
         """(ctx) -> {path: str}
@@ -832,18 +840,18 b' class fixupstate(object):'
                 changes.append((name, hsh))
                 if self.ui.verbose:
                     self.ui.write(
-                        _('moving bookmark %s to %s\n') % (name, node.hex(hsh))
+                        _(b'moving bookmark %s to %s\n') % (name, node.hex(hsh))
                     )
             else:
                 changes.append((name, None))
                 if self.ui.verbose:
-                    self.ui.write(_('deleting bookmark %s\n') % name)
+                    self.ui.write(_(b'deleting bookmark %s\n') % name)
         repo._bookmarks.applychanges(repo, tr, changes)
 
     def _moveworkingdirectoryparent(self):
         if not self.finalnode:
             # Find the latest not-{obsoleted,stripped} parent.
-            revs = self.repo.revs('max(::. - %ln)', self.replacemap.keys())
+            revs = self.repo.revs(b'max(::. - %ln)', self.replacemap.keys())
             ctx = self.repo[revs.first()]
             self.finalnode = ctx.node()
         else:
@@ -854,7 +862,7 b' class fixupstate(object):'
         # be slow. in absorb's case, no need to invalidate fsmonitorstate.
         noop = lambda: 0
         restore = noop
-        if util.safehasattr(dirstate, '_fsmonitorstate'):
+        if util.safehasattr(dirstate, b'_fsmonitorstate'):
             bak = dirstate._fsmonitorstate.invalidate
 
             def restore():
@@ -901,8 +909,8 b' class fixupstate(object):'
         """
         parents = p1 and (p1, node.nullid)
         extra = ctx.extra()
-        if self._useobsolete and self.ui.configbool('absorb', 'add-noise'):
-            extra['absorb_source'] = ctx.hex()
+        if self._useobsolete and self.ui.configbool(b'absorb', b'add-noise'):
+            extra[b'absorb_source'] = ctx.hex()
         mctx = overlaycontext(memworkingcopy, ctx, parents, extra=extra)
         return mctx.commit()
 
@@ -918,7 +926,7 b' class fixupstate(object):'
         }
         if replacements:
             scmutil.cleanupnodes(
-                self.repo, replacements, operation='absorb', fixphase=True
+                self.repo, replacements, operation=b'absorb', fixphase=True
             )
 
 
@@ -935,7 +943,7 b' def _parsechunk(hunk):'
     patchlines = mdiff.splitnewlines(buf.getvalue())
     # hunk.prettystr() will update hunk.removed
     a2 = a1 + hunk.removed
-    blines = [l[1:] for l in patchlines[1:] if not l.startswith('-')]
+    blines = [l[1:] for l in patchlines[1:] if not l.startswith(b'-')]
     return path, (a1, a2, blines)
 
 
@@ -967,7 +975,7 b' def overlaydiffcontext(ctx, chunks):'
         lines = mdiff.splitnewlines(ctx[path].data())
         for a1, a2, blines in patches:
             lines[a1:a2] = blines
-        memworkingcopy[path] = ''.join(lines)
+        memworkingcopy[path] = b''.join(lines)
     return overlaycontext(memworkingcopy, ctx)
 
 
@@ -979,18 +987,21 b' def absorb(ui, repo, stack=None, targetc'
     return fixupstate.
     """
     if stack is None:
-        limit = ui.configint('absorb', 'max-stack-size')
-        headctx = repo['.']
+        limit = ui.configint(b'absorb', b'max-stack-size')
+        headctx = repo[b'.']
         if len(headctx.parents()) > 1:
-            raise error.Abort(_('cannot absorb into a merge'))
+            raise error.Abort(_(b'cannot absorb into a merge'))
         stack = getdraftstack(headctx, limit)
         if limit and len(stack) >= limit:
             ui.warn(
-                _('absorb: only the recent %d changesets will ' 'be analysed\n')
+                _(
+                    b'absorb: only the recent %d changesets will '
+                    b'be analysed\n'
+                )
                 % limit
             )
     if not stack:
-        raise error.Abort(_('no mutable changeset to change'))
+        raise error.Abort(_(b'no mutable changeset to change'))
     if targetctx is None:  # default to working copy
         targetctx = repo[None]
     if pats is None:
@@ -999,85 +1010,89 b' def absorb(ui, repo, stack=None, targetc'
         opts = {}
     state = fixupstate(stack, ui=ui, opts=opts)
     matcher = scmutil.match(targetctx, pats, opts)
-    if opts.get('interactive'):
+    if opts.get(b'interactive'):
         diff = patch.diff(repo, stack[-1].node(), targetctx.node(), matcher)
         origchunks = patch.parsepatch(diff)
         chunks = cmdutil.recordfilter(ui, origchunks, matcher)[0]
         targetctx = overlaydiffcontext(stack[-1], chunks)
     fm = None
-    if opts.get('print_changes') or not opts.get('apply_changes'):
-        fm = ui.formatter('absorb', opts)
+    if opts.get(b'print_changes') or not opts.get(b'apply_changes'):
+        fm = ui.formatter(b'absorb', opts)
     state.diffwith(targetctx, matcher, fm)
     if fm is not None:
         fm.startitem()
-        fm.write("count", "\n%d changesets affected\n", len(state.ctxaffected))
-        fm.data(linetype='summary')
+        fm.write(
+            b"count", b"\n%d changesets affected\n", len(state.ctxaffected)
+        )
+        fm.data(linetype=b'summary')
         for ctx in reversed(stack):
             if ctx not in state.ctxaffected:
                 continue
             fm.startitem()
             fm.context(ctx=ctx)
-            fm.data(linetype='changeset')
-            fm.write('node', '%-7.7s ', ctx.hex(), label='absorb.node')
+            fm.data(linetype=b'changeset')
+            fm.write(b'node', b'%-7.7s ', ctx.hex(), label=b'absorb.node')
             descfirstline = ctx.description().splitlines()[0]
             fm.write(
-                'descfirstline',
-                '%s\n',
+                b'descfirstline',
+                b'%s\n',
                 descfirstline,
-                label='absorb.description',
+                label=b'absorb.description',
             )
         fm.end()
-    if not opts.get('dry_run'):
+    if not opts.get(b'dry_run'):
         if (
-            not opts.get('apply_changes')
+            not opts.get(b'apply_changes')
             and state.ctxaffected
-            and ui.promptchoice("apply changes (yn)? $$ &Yes $$ &No", default=1)
+            and ui.promptchoice(
+                b"apply changes (yn)? $$ &Yes $$ &No", default=1
+            )
         ):
-            raise error.Abort(_('absorb cancelled\n'))
+            raise error.Abort(_(b'absorb cancelled\n'))
 
         state.apply()
         if state.commit():
             state.printchunkstats()
         elif not ui.quiet:
-            ui.write(_('nothing applied\n'))
+            ui.write(_(b'nothing applied\n'))
     return state
 
 
 @command(
-    'absorb',
+    b'absorb',
     [
         (
-            'a',
-            'apply-changes',
+            b'a',
+            b'apply-changes',
             None,
-            _('apply changes without prompting for confirmation'),
+            _(b'apply changes without prompting for confirmation'),
         ),
         (
-            'p',
-            'print-changes',
+            b'p',
+            b'print-changes',
             None,
-            _('always print which changesets are modified by which changes'),
+            _(b'always print which changesets are modified by which changes'),
         ),
         (
-            'i',
-            'interactive',
+            b'i',
+            b'interactive',
             None,
-            _('interactively select which chunks to apply (EXPERIMENTAL)'),
+            _(b'interactively select which chunks to apply (EXPERIMENTAL)'),
         ),
         (
-            'e',
-            'edit-lines',
+            b'e',
+            b'edit-lines',
             None,
             _(
-                'edit what lines belong to which changesets before commit '
-                '(EXPERIMENTAL)'
+                b'edit what lines belong to which changesets before commit '
+                b'(EXPERIMENTAL)'
             ),
         ),
     ]
     + commands.dryrunopts
     + commands.templateopts
     + commands.walkopts,
-    _('hg absorb [OPTION] [FILE]...'),
+    _(b'hg absorb [OPTION] [FILE]...'),
     helpcategory=command.CATEGORY_COMMITTING,
     helpbasic=True,
 )
@@ -1108,7 +1123,7 b' def absorbcmd(ui, repo, *pats, **opts):'
     opts = pycompat.byteskwargs(opts)
 
     with repo.wlock(), repo.lock():
-        if not opts['dry_run']:
+        if not opts[b'dry_run']:
             cmdutil.checkunfinished(repo)
 
         state = absorb(ui, repo, pats=pats, opts=opts)

hgext/acl.py

@@ -232,66 +232,66 b' urlreq = util.urlreq'
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
-testedwith = 'ships-with-hg-core'
+testedwith = b'ships-with-hg-core'
 
 configtable = {}
 configitem = registrar.configitem(configtable)
 
 # deprecated config: acl.config
 configitem(
-    'acl', 'config', default=None,
+    b'acl', b'config', default=None,
 )
 configitem(
-    'acl.groups', '.*', default=None, generic=True,
+    b'acl.groups', b'.*', default=None, generic=True,
 )
 configitem(
-    'acl.deny.branches', '.*', default=None, generic=True,
+    b'acl.deny.branches', b'.*', default=None, generic=True,
 )
 configitem(
-    'acl.allow.branches', '.*', default=None, generic=True,
+    b'acl.allow.branches', b'.*', default=None, generic=True,
 )
 configitem(
-    'acl.deny', '.*', default=None, generic=True,
+    b'acl.deny', b'.*', default=None, generic=True,
 )
 configitem(
-    'acl.allow', '.*', default=None, generic=True,
+    b'acl.allow', b'.*', default=None, generic=True,
 )
 configitem(
-    'acl', 'sources', default=lambda: ['serve'],
+    b'acl', b'sources', default=lambda: [b'serve'],
 )
 
 
 def _getusers(ui, group):
 
     # First, try to use group definition from section [acl.groups]
-    hgrcusers = ui.configlist('acl.groups', group)
+    hgrcusers = ui.configlist(b'acl.groups', group)
     if hgrcusers:
         return hgrcusers
 
-    ui.debug('acl: "%s" not defined in [acl.groups]\n' % group)
+    ui.debug(b'acl: "%s" not defined in [acl.groups]\n' % group)
     # If no users found in group definition, get users from OS-level group
     try:
         return util.groupmembers(group)
     except KeyError:
-        raise error.Abort(_("group '%s' is undefined") % group)
+        raise error.Abort(_(b"group '%s' is undefined") % group)
 
 
 def _usermatch(ui, user, usersorgroups):
 
-    if usersorgroups == '*':
+    if usersorgroups == b'*':
         return True
 
-    for ug in usersorgroups.replace(',', ' ').split():
+    for ug in usersorgroups.replace(b',', b' ').split():
 
-        if ug.startswith('!'):
+        if ug.startswith(b'!'):
             # Test for excluded user or group. Format:
             # if ug is a user  name: !username
             # if ug is a group name: !@groupname
             ug = ug[1:]
             if (
-                not ug.startswith('@')
+                not ug.startswith(b'@')
                 and user != ug
-                or ug.startswith('@')
+                or ug.startswith(b'@')
                 and user not in _getusers(ui, ug[1:])
             ):
                 return True
@@ -299,7 +299,9 b' def _usermatch(ui, user, usersorgroups):'
         # Test for user or group. Format:
         # if ug is a user  name: username
         # if ug is a group name: @groupname
-        elif user == ug or ug.startswith('@') and user in _getusers(ui, ug[1:]):
+        elif (
+            user == ug or ug.startswith(b'@') and user in _getusers(ui, ug[1:])
+        ):
             return True
 
     return False
@@ -308,14 +310,14 b' def _usermatch(ui, user, usersorgroups):'
 def buildmatch(ui, repo, user, key):
     '''return tuple of (match function, list enabled).'''
     if not ui.has_section(key):
-        ui.debug('acl: %s not enabled\n' % key)
+        ui.debug(b'acl: %s not enabled\n' % key)
         return None
 
     pats = [
         pat for pat, users in ui.configitems(key) if _usermatch(ui, user, users)
     ]
     ui.debug(
-        'acl: %s enabled, %d entries for user %s\n' % (key, len(pats), user)
+        b'acl: %s enabled, %d entries for user %s\n' % (key, len(pats), user)
     )
 
     # Branch-based ACL
@@ -323,14 +325,14 b' def buildmatch(ui, repo, user, key):'
         if pats:
             # If there's an asterisk (meaning "any branch"), always return True;
             # Otherwise, test if b is in pats
-            if '*' in pats:
+            if b'*' in pats:
                 return util.always
             return lambda b: b in pats
         return util.never
 
     # Path-based ACL
     if pats:
-        return match.match(repo.root, '', pats)
+        return match.match(repo.root, b'', pats)
     return util.never
 
 
@@ -342,122 +344,128 b' def ensureenabled(ui):'
     never loaded. This function ensure the extension is enabled when running
     hooks.
     """
-    if 'acl' in ui._knownconfig:
+    if b'acl' in ui._knownconfig:
         return
-    ui.setconfig('extensions', 'acl', '', source='internal')
-    extensions.loadall(ui, ['acl'])
+    ui.setconfig(b'extensions', b'acl', b'', source=b'internal')
+    extensions.loadall(ui, [b'acl'])
 
 
 def hook(ui, repo, hooktype, node=None, source=None, **kwargs):
 
     ensureenabled(ui)
 
-    if hooktype not in ['pretxnchangegroup', 'pretxncommit', 'prepushkey']:
+    if hooktype not in [b'pretxnchangegroup', b'pretxncommit', b'prepushkey']:
         raise error.Abort(
             _(
-                'config error - hook type "%s" cannot stop '
-                'incoming changesets, commits, nor bookmarks'
+                b'config error - hook type "%s" cannot stop '
+                b'incoming changesets, commits, nor bookmarks'
             )
             % hooktype
         )
-    if hooktype == 'pretxnchangegroup' and source not in ui.configlist(
-        'acl', 'sources'
+    if hooktype == b'pretxnchangegroup' and source not in ui.configlist(
+        b'acl', b'sources'
     ):
-        ui.debug('acl: changes have source "%s" - skipping\n' % source)
+        ui.debug(b'acl: changes have source "%s" - skipping\n' % source)
         return
 
     user = None
-    if source == 'serve' and r'url' in kwargs:
-        url = kwargs[r'url'].split(':')
-        if url[0] == 'remote' and url[1].startswith('http'):
+    if source == b'serve' and r'url' in kwargs:
+        url = kwargs[r'url'].split(b':')
+        if url[0] == b'remote' and url[1].startswith(b'http'):
             user = urlreq.unquote(url[3])
 
     if user is None:
         user = procutil.getuser()
 
-    ui.debug('acl: checking access for user "%s"\n' % user)
+    ui.debug(b'acl: checking access for user "%s"\n' % user)
 
-    if hooktype == 'prepushkey':
+    if hooktype == b'prepushkey':
         _pkhook(ui, repo, hooktype, node, source, user, **kwargs)
     else:
         _txnhook(ui, repo, hooktype, node, source, user, **kwargs)
 
 
 def _pkhook(ui, repo, hooktype, node, source, user, **kwargs):
-    if kwargs[r'namespace'] == 'bookmarks':
+    if kwargs[r'namespace'] == b'bookmarks':
         bookmark = kwargs[r'key']
         ctx = kwargs[r'new']
-        allowbookmarks = buildmatch(ui, None, user, 'acl.allow.bookmarks')
-        denybookmarks = buildmatch(ui, None, user, 'acl.deny.bookmarks')
+        allowbookmarks = buildmatch(ui, None, user, b'acl.allow.bookmarks')
+        denybookmarks = buildmatch(ui, None, user, b'acl.deny.bookmarks')
 
         if denybookmarks and denybookmarks(bookmark):
             raise error.Abort(
-                _('acl: user "%s" denied on bookmark "%s"' ' (changeset "%s")')
+                _(
+                    b'acl: user "%s" denied on bookmark "%s"'
+                    b' (changeset "%s")'
+                )
                 % (user, bookmark, ctx)
             )
         if allowbookmarks and not allowbookmarks(bookmark):
             raise error.Abort(
                 _(
-                    'acl: user "%s" not allowed on bookmark "%s"'
-                    ' (changeset "%s")'
+                    b'acl: user "%s" not allowed on bookmark "%s"'
+                    b' (changeset "%s")'
                 )
                 % (user, bookmark, ctx)
             )
         ui.debug(
-            'acl: bookmark access granted: "%s" on bookmark "%s"\n'
+            b'acl: bookmark access granted: "%s" on bookmark "%s"\n'
             % (ctx, bookmark)
         )
 
 
 def _txnhook(ui, repo, hooktype, node, source, user, **kwargs):
     # deprecated config: acl.config
-    cfg = ui.config('acl', 'config')
+    cfg = ui.config(b'acl', b'config')
     if cfg:
         ui.readconfig(
             cfg,
             sections=[
-                'acl.groups',
-                'acl.allow.branches',
-                'acl.deny.branches',
-                'acl.allow',
-                'acl.deny',
+                b'acl.groups',
+                b'acl.allow.branches',
+                b'acl.deny.branches',
+                b'acl.allow',
+                b'acl.deny',
             ],
         )
 
-    allowbranches = buildmatch(ui, None, user, 'acl.allow.branches')
-    denybranches = buildmatch(ui, None, user, 'acl.deny.branches')
-    allow = buildmatch(ui, repo, user, 'acl.allow')
-    deny = buildmatch(ui, repo, user, 'acl.deny')
+    allowbranches = buildmatch(ui, None, user, b'acl.allow.branches')
+    denybranches = buildmatch(ui, None, user, b'acl.deny.branches')
+    allow = buildmatch(ui, repo, user, b'acl.allow')
+    deny = buildmatch(ui, repo, user, b'acl.deny')
 
     for rev in pycompat.xrange(repo[node].rev(), len(repo)):
         ctx = repo[rev]
         branch = ctx.branch()
         if denybranches and denybranches(branch):
             raise error.Abort(
-                _('acl: user "%s" denied on branch "%s"' ' (changeset "%s")')
+                _(b'acl: user "%s" denied on branch "%s"' b' (changeset "%s")')
                 % (user, branch, ctx)
             )
         if allowbranches and not allowbranches(branch):
             raise error.Abort(
                 _(
-                    'acl: user "%s" not allowed on branch "%s"'
-                    ' (changeset "%s")'
+                    b'acl: user "%s" not allowed on branch "%s"'
+                    b' (changeset "%s")'
                 )
                 % (user, branch, ctx)
             )
         ui.debug(
-            'acl: branch access granted: "%s" on branch "%s"\n' % (ctx, branch)
+            b'acl: branch access granted: "%s" on branch "%s"\n' % (ctx, branch)
         )
 
         for f in ctx.files():
             if deny and deny(f):
                 raise error.Abort(
-                    _('acl: user "%s" denied on "%s"' ' (changeset "%s")')
+                    _(b'acl: user "%s" denied on "%s"' b' (changeset "%s")')
                     % (user, f, ctx)
                 )
             if allow and not allow(f):
                 raise error.Abort(
-                    _('acl: user "%s" not allowed on "%s"' ' (changeset "%s")')
+                    _(
+                        b'acl: user "%s" not allowed on "%s"'
+                        b' (changeset "%s")'
+                    )
                     % (user, f, ctx)
                 )
-        ui.debug('acl: path access granted: "%s"\n' % ctx)
+        ui.debug(b'acl: path access granted: "%s"\n' % ctx)

hgext/amend.py

@@ -24,23 +24,23 b' from mercurial import ('
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
-testedwith = 'ships-with-hg-core'
+testedwith = b'ships-with-hg-core'
 
 cmdtable = {}
 command = registrar.command(cmdtable)
 
 
 @command(
-    'amend',
+    b'amend',
     [
         (
-            'A',
-            'addremove',
+            b'A',
+            b'addremove',
             None,
-            _('mark new/missing files as added/removed before committing'),
+            _(b'mark new/missing files as added/removed before committing'),
         ),
-        ('e', 'edit', None, _('invoke editor on commit messages')),
-        ('i', 'interactive', None, _('use interactive mode')),
+        (b'e', b'edit', None, _(b'invoke editor on commit messages')),
+        (b'i', b'interactive', None, _(b'use interactive mode')),
         (
             b'',
             b'close-branch',
@@ -48,13 +48,13 b' command = registrar.command(cmdtable)'
             _(b'mark a branch as closed, hiding it from the branch list'),
         ),
         (b's', b'secret', None, _(b'use the secret phase for committing')),
-        ('n', 'note', '', _('store a note on the amend')),
+        (b'n', b'note', b'', _(b'store a note on the amend')),
     ]
     + cmdutil.walkopts
     + cmdutil.commitopts
     + cmdutil.commitopts2
     + cmdutil.commitopts3,
-    _('[OPTION]... [FILE]...'),
+    _(b'[OPTION]... [FILE]...'),
     helpcategory=command.CATEGORY_COMMITTING,
     inferrepo=True,
 )
@@ -70,7 +70,7 b' def amend(ui, repo, *pats, **opts):'
     cmdutil.checknotesize(ui, opts)
 
     with repo.wlock(), repo.lock():
-        if not opts.get('logfile'):
-            opts['message'] = opts.get('message') or repo['.'].description()
-        opts['amend'] = True
+        if not opts.get(b'logfile'):
+            opts[b'message'] = opts.get(b'message') or repo[b'.'].description()
+        opts[b'amend'] = True
         return commands._docommit(ui, repo, *pats, **pycompat.strkwargs(opts))

hgext/automv.py

@@ -42,14 +42,14 b' configtable = {}'
 configitem = registrar.configitem(configtable)
 
 configitem(
-    'automv', 'similarity', default=95,
+    b'automv', b'similarity', default=95,
 )
 
 
 def extsetup(ui):
-    entry = extensions.wrapcommand(commands.table, 'commit', mvcheck)
+    entry = extensions.wrapcommand(commands.table, b'commit', mvcheck)
     entry[1].append(
-        ('', 'no-automv', None, _('disable automatic file move detection'))
+        (b'', b'no-automv', None, _(b'disable automatic file move detection'))
     )
 
 
@@ -57,11 +57,11 b' def mvcheck(orig, ui, repo, *pats, **opt'
     """Hook to check for moves at commit time"""
     opts = pycompat.byteskwargs(opts)
     renames = None
-    disabled = opts.pop('no_automv', False)
+    disabled = opts.pop(b'no_automv', False)
     if not disabled:
-        threshold = ui.configint('automv', 'similarity')
+        threshold = ui.configint(b'automv', b'similarity')
         if not 0 <= threshold <= 100:
-            raise error.Abort(_('automv.similarity must be between 0 and 100'))
+            raise error.Abort(_(b'automv.similarity must be between 0 and 100'))
         if threshold > 0:
             match = scmutil.match(repo[None], pats, opts)
             added, removed = _interestingfiles(repo, match)
@@ -87,7 +87,7 b' def _interestingfiles(repo, matcher):'
     added = stat.added
     removed = stat.removed
 
-    copy = copies.pathcopies(repo['.'], repo[None], matcher)
+    copy = copies.pathcopies(repo[b'.'], repo[None], matcher)
     # remove the copy files for which we already have copy info
     added = [f for f in added if f not in copy]
 
@@ -108,10 +108,10 b' def _findrenames(repo, uipathfn, added, '
         ):
             if repo.ui.verbose:
                 repo.ui.status(
-                    _('detected move of %s as %s (%d%% similar)\n')
+                    _(b'detected move of %s as %s (%d%% similar)\n')
                     % (uipathfn(src), uipathfn(dst), score * 100)
                 )
             renames[dst] = src
     if renames:
-        repo.ui.status(_('detected move of %d files\n') % len(renames))
+        repo.ui.status(_(b'detected move of %d files\n') % len(renames))
     return renames

hgext/beautifygraph.py

@@ -26,33 +26,33 b' from mercurial import ('
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
-testedwith = 'ships-with-hg-core'
+testedwith = b'ships-with-hg-core'
 
 
 def prettyedge(before, edge, after):
-    if edge == '~':
-        return '\xE2\x95\xA7'  # U+2567 ╧
-    if edge == '/':
-        return '\xE2\x95\xB1'  # U+2571 ╱
-    if edge == '-':
-        return '\xE2\x94\x80'  # U+2500 ─
-    if edge == '|':
-        return '\xE2\x94\x82'  # U+2502 │
-    if edge == ':':
-        return '\xE2\x94\x86'  # U+2506 ┆
-    if edge == '\\':
-        return '\xE2\x95\xB2'  # U+2572 ╲
-    if edge == '+':
-        if before == ' ' and not after == ' ':
-            return '\xE2\x94\x9C'  # U+251C ├
-        if after == ' ' and not before == ' ':
-            return '\xE2\x94\xA4'  # U+2524 ┤
-        return '\xE2\x94\xBC'  # U+253C ┼
+    if edge == b'~':
+        return b'\xE2\x95\xA7'  # U+2567 ╧
+    if edge == b'/':
+        return b'\xE2\x95\xB1'  # U+2571 ╱
+    if edge == b'-':
+        return b'\xE2\x94\x80'  # U+2500 ─
+    if edge == b'|':
+        return b'\xE2\x94\x82'  # U+2502 │
+    if edge == b':':
+        return b'\xE2\x94\x86'  # U+2506 ┆
+    if edge == b'\\':
+        return b'\xE2\x95\xB2'  # U+2572 ╲
+    if edge == b'+':
+        if before == b' ' and not after == b' ':
+            return b'\xE2\x94\x9C'  # U+251C ├
+        if after == b' ' and not before == b' ':
+            return b'\xE2\x94\xA4'  # U+2524 ┤
+        return b'\xE2\x94\xBC'  # U+253C ┼
     return edge
 
 
 def convertedges(line):
-    line = ' %s ' % line
+    line = b' %s ' % line
     pretty = []
     for idx in pycompat.xrange(len(line) - 2):
         pretty.append(
@@ -62,21 +62,21 b' def convertedges(line):'
                 line[idx + 2 : idx + 3],
             )
         )
-    return ''.join(pretty)
+    return b''.join(pretty)
 
 
 def getprettygraphnode(orig, *args, **kwargs):
     node = orig(*args, **kwargs)
-    if node == 'o':
-        return '\xE2\x97\x8B'  # U+25CB ○
-    if node == '@':
-        return '\xE2\x97\x8D'  # U+25CD ◍
-    if node == '*':
-        return '\xE2\x88\x97'  # U+2217 ∗
-    if node == 'x':
-        return '\xE2\x97\x8C'  # U+25CC ◌
-    if node == '_':
-        return '\xE2\x95\xA4'  # U+2564 ╤
+    if node == b'o':
+        return b'\xE2\x97\x8B'  # U+25CB ○
+    if node == b'@':
+        return b'\xE2\x97\x8D'  # U+25CD ◍
+    if node == b'*':
+        return b'\xE2\x88\x97'  # U+2217 ∗
+    if node == b'x':
+        return b'\xE2\x97\x8C'  # U+25CC ◌
+    if node == b'_':
+        return b'\xE2\x95\xA4'  # U+2564 ╤
     return node
 
 
@@ -87,21 +87,21 b' def outputprettygraph(orig, ui, graph, *'
 
 
 def extsetup(ui):
-    if ui.plain('graph'):
+    if ui.plain(b'graph'):
         return
 
-    if encoding.encoding != 'UTF-8':
-        ui.warn(_('beautifygraph: unsupported encoding, UTF-8 required\n'))
+    if encoding.encoding != b'UTF-8':
+        ui.warn(_(b'beautifygraph: unsupported encoding, UTF-8 required\n'))
         return
 
     if r'A' in encoding._wide:
         ui.warn(
             _(
-                'beautifygraph: unsupported terminal settings, '
-                'monospace narrow text required\n'
+                b'beautifygraph: unsupported terminal settings, '
+                b'monospace narrow text required\n'
             )
         )
         return
 
-    extensions.wrapfunction(graphmod, 'outputgraph', outputprettygraph)
-    extensions.wrapfunction(templatekw, 'getgraphnode', getprettygraphnode)
+    extensions.wrapfunction(graphmod, b'outputgraph', outputprettygraph)
+    extensions.wrapfunction(templatekw, b'getgraphnode', getprettygraphnode)

hgext/blackbox.py

@@ -63,7 +63,7 b' from mercurial.utils import ('
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
-testedwith = 'ships-with-hg-core'
+testedwith = b'ships-with-hg-core'
 
 cmdtable = {}
 command = registrar.command(cmdtable)
@@ -72,27 +72,27 b' configtable = {}'
 configitem = registrar.configitem(configtable)
 
 configitem(
-    'blackbox', 'dirty', default=False,
+    b'blackbox', b'dirty', default=False,
 )
 configitem(
-    'blackbox', 'maxsize', default='1 MB',
+    b'blackbox', b'maxsize', default=b'1 MB',
 )
 configitem(
-    'blackbox', 'logsource', default=False,
+    b'blackbox', b'logsource', default=False,
 )
 configitem(
-    'blackbox', 'maxfiles', default=7,
+    b'blackbox', b'maxfiles', default=7,
 )
 configitem(
-    'blackbox', 'track', default=lambda: ['*'],
+    b'blackbox', b'track', default=lambda: [b'*'],
 )
 configitem(
-    'blackbox',
-    'ignore',
-    default=lambda: ['chgserver', 'cmdserver', 'extension'],
+    b'blackbox',
+    b'ignore',
+    default=lambda: [b'chgserver', b'cmdserver', b'extension'],
 )
 configitem(
-    'blackbox', 'date-format', default='%Y/%m/%d %H:%M:%S',
+    b'blackbox', b'date-format', default=b'%Y/%m/%d %H:%M:%S',
 )
 
 _lastlogger = loggingutil.proxylogger()
@@ -101,10 +101,10 b' configitem('
 class blackboxlogger(object):
     def __init__(self, ui, repo):
         self._repo = repo
-        self._trackedevents = set(ui.configlist('blackbox', 'track'))
-        self._ignoredevents = set(ui.configlist('blackbox', 'ignore'))
-        self._maxfiles = ui.configint('blackbox', 'maxfiles')
-        self._maxsize = ui.configbytes('blackbox', 'maxsize')
+        self._trackedevents = set(ui.configlist(b'blackbox', b'track'))
+        self._ignoredevents = set(ui.configlist(b'blackbox', b'ignore'))
+        self._maxfiles = ui.configint(b'blackbox', b'maxfiles')
+        self._maxsize = ui.configbytes(b'blackbox', b'maxsize')
         self._inlog = False
 
     def tracked(self, event):
@@ -125,29 +125,29 b' class blackboxlogger(object):'
             self._inlog = False
 
     def _log(self, ui, event, msg, opts):
-        default = ui.configdate('devel', 'default-date')
-        date = dateutil.datestr(default, ui.config('blackbox', 'date-format'))
+        default = ui.configdate(b'devel', b'default-date')
+        date = dateutil.datestr(default, ui.config(b'blackbox', b'date-format'))
         user = procutil.getuser()
-        pid = '%d' % procutil.getpid()
-        changed = ''
+        pid = b'%d' % procutil.getpid()
+        changed = b''
         ctx = self._repo[None]
         parents = ctx.parents()
-        rev = '+'.join([hex(p.node()) for p in parents])
-        if ui.configbool('blackbox', 'dirty') and ctx.dirty(
+        rev = b'+'.join([hex(p.node()) for p in parents])
+        if ui.configbool(b'blackbox', b'dirty') and ctx.dirty(
             missing=True, merge=False, branch=False
         ):
-            changed = '+'
-        if ui.configbool('blackbox', 'logsource'):
-            src = ' [%s]' % event
+            changed = b'+'
+        if ui.configbool(b'blackbox', b'logsource'):
+            src = b' [%s]' % event
         else:
-            src = ''
+            src = b''
         try:
-            fmt = '%s %s @%s%s (%s)%s> %s'
+            fmt = b'%s %s @%s%s (%s)%s> %s'
             args = (date, user, rev, changed, pid, src, msg)
             with loggingutil.openlogfile(
                 ui,
                 self._repo.vfs,
-                name='blackbox.log',
+                name=b'blackbox.log',
                 maxfiles=self._maxfiles,
                 maxsize=self._maxsize,
             ) as fp:
@@ -156,7 +156,7 b' class blackboxlogger(object):'
             # deactivate this to avoid failed logging again
             self._trackedevents.clear()
             ui.debug(
-                'warning: cannot write to blackbox.log: %s\n'
+                b'warning: cannot write to blackbox.log: %s\n'
                 % encoding.strtolocal(err.strerror)
             )
             return
@@ -184,13 +184,13 b' def reposetup(ui, repo):'
     if _lastlogger.logger is None:
         _lastlogger.logger = logger
 
-    repo._wlockfreeprefix.add('blackbox.log')
+    repo._wlockfreeprefix.add(b'blackbox.log')
 
 
 @command(
-    'blackbox',
-    [('l', 'limit', 10, _('the number of events to show')),],
-    _('hg blackbox [OPTION]...'),
+    b'blackbox',
+    [(b'l', b'limit', 10, _(b'the number of events to show')),],
+    _(b'hg blackbox [OPTION]...'),
     helpcategory=command.CATEGORY_MAINTENANCE,
     helpbasic=True,
 )
@@ -198,12 +198,12 b' def blackbox(ui, repo, *revs, **opts):'
     '''view the recent repository events
     '''
 
-    if not repo.vfs.exists('blackbox.log'):
+    if not repo.vfs.exists(b'blackbox.log'):
         return
 
     limit = opts.get(r'limit')
-    fp = repo.vfs('blackbox.log', 'r')
-    lines = fp.read().split('\n')
+    fp = repo.vfs(b'blackbox.log', b'r')
+    lines = fp.read().split(b'\n')
 
     count = 0
     output = []
@@ -216,4 +216,4 b' def blackbox(ui, repo, *revs, **opts):'
             count += 1
         output.append(line)
 
-    ui.status('\n'.join(reversed(output)))
+    ui.status(b'\n'.join(reversed(output)))

hgext/bookflow.py

@@ -24,14 +24,14 b' from mercurial import ('
     registrar,
 )
 
-MY_NAME = 'bookflow'
+MY_NAME = b'bookflow'
 
 configtable = {}
 configitem = registrar.configitem(configtable)
 
-configitem(MY_NAME, 'protect', ['@'])
-configitem(MY_NAME, 'require-bookmark', True)
-configitem(MY_NAME, 'enable-branches', False)
+configitem(MY_NAME, b'protect', [b'@'])
+configitem(MY_NAME, b'require-bookmark', True)
+configitem(MY_NAME, b'enable-branches', False)
 
 cmdtable = {}
 command = registrar.command(cmdtable)
@@ -40,19 +40,19 b' command = registrar.command(cmdtable)'
 def commit_hook(ui, repo, **kwargs):
     active = repo._bookmarks.active
     if active:
-        if active in ui.configlist(MY_NAME, 'protect'):
+        if active in ui.configlist(MY_NAME, b'protect'):
             raise error.Abort(
-                _('cannot commit, bookmark %s is protected') % active
+                _(b'cannot commit, bookmark %s is protected') % active
             )
         if not cwd_at_bookmark(repo, active):
             raise error.Abort(
                 _(
-                    'cannot commit, working directory out of sync with active bookmark'
+                    b'cannot commit, working directory out of sync with active bookmark'
                 ),
-                hint=_("run 'hg up %s'") % active,
+                hint=_(b"run 'hg up %s'") % active,
             )
-    elif ui.configbool(MY_NAME, 'require-bookmark', True):
-        raise error.Abort(_('cannot commit without an active bookmark'))
+    elif ui.configbool(MY_NAME, b'require-bookmark', True):
+        raise error.Abort(_(b'cannot commit without an active bookmark'))
     return 0
 
 
@@ -74,7 +74,7 b' def bookmarks_addbookmarks('
             if name in marks:
                 raise error.Abort(
                     _(
-                        "bookmark %s already exists, to move use the --rev option"
+                        b"bookmark %s already exists, to move use the --rev option"
                     )
                     % name
                 )
@@ -92,8 +92,8 b' def commands_pull(orig, ui, repo, *args,'
     if active and not cwd_at_bookmark(repo, active):
         ui.warn(
             _(
-                "working directory out of sync with active bookmark, run "
-                "'hg up %s'"
+                b"working directory out of sync with active bookmark, run "
+                b"'hg up %s'"
             )
             % active
         )
@@ -104,23 +104,23 b' def commands_branch(orig, ui, repo, labe'
     if label and not opts.get(r'clean') and not opts.get(r'rev'):
         raise error.Abort(
             _(
-                "creating named branches is disabled and you should use bookmarks"
+                b"creating named branches is disabled and you should use bookmarks"
             ),
-            hint="see 'hg help bookflow'",
+            hint=b"see 'hg help bookflow'",
         )
     return orig(ui, repo, label, **opts)
 
 
 def cwd_at_bookmark(repo, mark):
     mark_id = repo._bookmarks[mark]
-    cur_id = repo.lookup('.')
+    cur_id = repo.lookup(b'.')
     return cur_id == mark_id
 
 
 def uisetup(ui):
-    extensions.wrapfunction(bookmarks, 'update', bookmarks_update)
-    extensions.wrapfunction(bookmarks, 'addbookmarks', bookmarks_addbookmarks)
-    extensions.wrapcommand(commands.table, 'commit', commands_commit)
-    extensions.wrapcommand(commands.table, 'pull', commands_pull)
-    if not ui.configbool(MY_NAME, 'enable-branches'):
-        extensions.wrapcommand(commands.table, 'branch', commands_branch)
+    extensions.wrapfunction(bookmarks, b'update', bookmarks_update)
+    extensions.wrapfunction(bookmarks, b'addbookmarks', bookmarks_addbookmarks)
+    extensions.wrapcommand(commands.table, b'commit', commands_commit)
+    extensions.wrapcommand(commands.table, b'pull', commands_pull)
+    if not ui.configbool(MY_NAME, b'enable-branches'):
+        extensions.wrapcommand(commands.table, b'branch', commands_branch)

hgext/bugzilla.py

@@ -319,32 +319,32 b' xmlrpclib = util.xmlrpclib'
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
-testedwith = 'ships-with-hg-core'
+testedwith = b'ships-with-hg-core'
 
 configtable = {}
 configitem = registrar.configitem(configtable)
 
 configitem(
-    'bugzilla', 'apikey', default='',
+    b'bugzilla', b'apikey', default=b'',
 )
 configitem(
-    'bugzilla', 'bzdir', default='/var/www/html/bugzilla',
+    b'bugzilla', b'bzdir', default=b'/var/www/html/bugzilla',
 )
 configitem(
-    'bugzilla', 'bzemail', default=None,
+    b'bugzilla', b'bzemail', default=None,
 )
 configitem(
-    'bugzilla', 'bzurl', default='http://localhost/bugzilla/',
+    b'bugzilla', b'bzurl', default=b'http://localhost/bugzilla/',
 )
 configitem(
-    'bugzilla', 'bzuser', default=None,
+    b'bugzilla', b'bzuser', default=None,
 )
 configitem(
-    'bugzilla', 'db', default='bugs',
+    b'bugzilla', b'db', default=b'bugs',
 )
 configitem(
-    'bugzilla',
-    'fixregexp',
+    b'bugzilla',
+    b'fixregexp',
     default=(
         br'fix(?:es)?\s*(?:bugs?\s*)?,?\s*'
         br'(?:nos?\.?|num(?:ber)?s?)?\s*'
@@ -353,23 +353,23 b' configitem('
     ),
 )
 configitem(
-    'bugzilla', 'fixresolution', default='FIXED',
+    b'bugzilla', b'fixresolution', default=b'FIXED',
 )
 configitem(
-    'bugzilla', 'fixstatus', default='RESOLVED',
+    b'bugzilla', b'fixstatus', default=b'RESOLVED',
 )
 configitem(
-    'bugzilla', 'host', default='localhost',
+    b'bugzilla', b'host', default=b'localhost',
 )
 configitem(
-    'bugzilla', 'notify', default=configitem.dynamicdefault,
+    b'bugzilla', b'notify', default=configitem.dynamicdefault,
 )
 configitem(
-    'bugzilla', 'password', default=None,
+    b'bugzilla', b'password', default=None,
 )
 configitem(
-    'bugzilla',
-    'regexp',
+    b'bugzilla',
+    b'regexp',
     default=(
         br'bugs?\s*,?\s*(?:#|nos?\.?|num(?:ber)?s?)?\s*'
         br'(?P<ids>(?:\d+\s*(?:,?\s*(?:and)?)?\s*)+)'
@@ -377,25 +377,25 b' configitem('
     ),
 )
 configitem(
-    'bugzilla', 'strip', default=0,
+    b'bugzilla', b'strip', default=0,
 )
 configitem(
-    'bugzilla', 'style', default=None,
+    b'bugzilla', b'style', default=None,
 )
 configitem(
-    'bugzilla', 'template', default=None,
+    b'bugzilla', b'template', default=None,
 )
 configitem(
-    'bugzilla', 'timeout', default=5,
+    b'bugzilla', b'timeout', default=5,
 )
 configitem(
-    'bugzilla', 'user', default='bugs',
+    b'bugzilla', b'user', default=b'bugs',
 )
 configitem(
-    'bugzilla', 'usermap', default=None,
+    b'bugzilla', b'usermap', default=None,
 )
 configitem(
-    'bugzilla', 'version', default=None,
+    b'bugzilla', b'version', default=None,
 )
 
 
@@ -404,13 +404,13 b' class bzaccess(object):'
 
     def __init__(self, ui):
         self.ui = ui
-        usermap = self.ui.config('bugzilla', 'usermap')
+        usermap = self.ui.config(b'bugzilla', b'usermap')
         if usermap:
-            self.ui.readconfig(usermap, sections=['usermap'])
+            self.ui.readconfig(usermap, sections=[b'usermap'])
 
     def map_committer(self, user):
         '''map name of committer to Bugzilla user name.'''
-        for committer, bzuser in self.ui.configitems('usermap'):
+        for committer, bzuser in self.ui.configitems(b'usermap'):
             if committer.lower() == user.lower():
                 return bzuser
         return user
@@ -457,7 +457,7 b' class bzmysql(bzaccess):'
     @staticmethod
     def sql_buglist(ids):
         '''return SQL-friendly list of bug ids'''
-        return '(' + ','.join(map(str, ids)) + ')'
+        return b'(' + b','.join(map(str, ids)) + b')'
 
     _MySQLdb = None
 
@@ -467,18 +467,20 b' class bzmysql(bzaccess):'
 
             bzmysql._MySQLdb = mysql
         except ImportError as err:
-            raise error.Abort(_('python mysql support not available: %s') % err)
+            raise error.Abort(
+                _(b'python mysql support not available: %s') % err
+            )
 
         bzaccess.__init__(self, ui)
 
-        host = self.ui.config('bugzilla', 'host')
-        user = self.ui.config('bugzilla', 'user')
-        passwd = self.ui.config('bugzilla', 'password')
-        db = self.ui.config('bugzilla', 'db')
-        timeout = int(self.ui.config('bugzilla', 'timeout'))
+        host = self.ui.config(b'bugzilla', b'host')
+        user = self.ui.config(b'bugzilla', b'user')
+        passwd = self.ui.config(b'bugzilla', b'password')
+        db = self.ui.config(b'bugzilla', b'db')
+        timeout = int(self.ui.config(b'bugzilla', b'timeout'))
         self.ui.note(
-            _('connecting to %s:%s as %s, password %s\n')
-            % (host, db, user, '*' * len(passwd))
+            _(b'connecting to %s:%s as %s, password %s\n')
+            % (host, db, user, b'*' * len(passwd))
         )
         self.conn = bzmysql._MySQLdb.connect(
             host=host, user=user, passwd=passwd, db=db, connect_timeout=timeout
@@ -486,35 +488,35 b' class bzmysql(bzaccess):'
         self.cursor = self.conn.cursor()
         self.longdesc_id = self.get_longdesc_id()
         self.user_ids = {}
-        self.default_notify = "cd %(bzdir)s && ./processmail %(id)s %(user)s"
+        self.default_notify = b"cd %(bzdir)s && ./processmail %(id)s %(user)s"
 
     def run(self, *args, **kwargs):
         '''run a query.'''
-        self.ui.note(_('query: %s %s\n') % (args, kwargs))
+        self.ui.note(_(b'query: %s %s\n') % (args, kwargs))
         try:
             self.cursor.execute(*args, **kwargs)
         except bzmysql._MySQLdb.MySQLError:
-            self.ui.note(_('failed query: %s %s\n') % (args, kwargs))
+            self.ui.note(_(b'failed query: %s %s\n') % (args, kwargs))
             raise
 
     def get_longdesc_id(self):
         '''get identity of longdesc field'''
-        self.run('select fieldid from fielddefs where name = "longdesc"')
+        self.run(b'select fieldid from fielddefs where name = "longdesc"')
         ids = self.cursor.fetchall()
         if len(ids) != 1:
-            raise error.Abort(_('unknown database schema'))
+            raise error.Abort(_(b'unknown database schema'))
         return ids[0][0]
 
     def filter_real_bug_ids(self, bugs):
         '''filter not-existing bugs from set.'''
         self.run(
-            'select bug_id from bugs where bug_id in %s'
+            b'select bug_id from bugs where bug_id in %s'
             % bzmysql.sql_buglist(bugs.keys())
         )
         existing = [id for (id,) in self.cursor.fetchall()]
         for id in bugs.keys():
             if id not in existing:
-                self.ui.status(_('bug %d does not exist\n') % id)
+                self.ui.status(_(b'bug %d does not exist\n') % id)
                 del bugs[id]
 
     def filter_cset_known_bug_ids(self, node, bugs):
@@ -526,36 +528,36 b' class bzmysql(bzaccess):'
         )
         for (id,) in self.cursor.fetchall():
             self.ui.status(
-                _('bug %d already knows about changeset %s\n')
+                _(b'bug %d already knows about changeset %s\n')
                 % (id, short(node))
             )
             del bugs[id]
 
     def notify(self, bugs, committer):
         '''tell bugzilla to send mail.'''
-        self.ui.status(_('telling bugzilla to send mail:\n'))
+        self.ui.status(_(b'telling bugzilla to send mail:\n'))
         (user, userid) = self.get_bugzilla_user(committer)
         for id in bugs.keys():
-            self.ui.status(_('  bug %s\n') % id)
-            cmdfmt = self.ui.config('bugzilla', 'notify', self.default_notify)
-            bzdir = self.ui.config('bugzilla', 'bzdir')
+            self.ui.status(_(b'  bug %s\n') % id)
+            cmdfmt = self.ui.config(b'bugzilla', b'notify', self.default_notify)
+            bzdir = self.ui.config(b'bugzilla', b'bzdir')
             try:
                 # Backwards-compatible with old notify string, which
                 # took one string. This will throw with a new format
                 # string.
                 cmd = cmdfmt % id
             except TypeError:
-                cmd = cmdfmt % {'bzdir': bzdir, 'id': id, 'user': user}
-            self.ui.note(_('running notify command %s\n') % cmd)
-            fp = procutil.popen('(%s) 2>&1' % cmd, 'rb')
+                cmd = cmdfmt % {b'bzdir': bzdir, b'id': id, b'user': user}
+            self.ui.note(_(b'running notify command %s\n') % cmd)
+            fp = procutil.popen(b'(%s) 2>&1' % cmd, b'rb')
             out = util.fromnativeeol(fp.read())
             ret = fp.close()
             if ret:
                 self.ui.warn(out)
                 raise error.Abort(
-                    _('bugzilla notify command %s') % procutil.explainexit(ret)
+                    _(b'bugzilla notify command %s') % procutil.explainexit(ret)
                 )
-        self.ui.status(_('done\n'))
+        self.ui.status(_(b'done\n'))
 
     def get_user_id(self, user):
         '''look up numeric bugzilla user id.'''
@@ -565,7 +567,7 b' class bzmysql(bzaccess):'
             try:
                 userid = int(user)
             except ValueError:
-                self.ui.note(_('looking up user %s\n') % user)
+                self.ui.note(_(b'looking up user %s\n') % user)
                 self.run(
                     '''select userid from profiles
                             where login_name like %s''',
@@ -587,16 +589,16 b' class bzmysql(bzaccess):'
             userid = self.get_user_id(user)
         except KeyError:
             try:
-                defaultuser = self.ui.config('bugzilla', 'bzuser')
+                defaultuser = self.ui.config(b'bugzilla', b'bzuser')
                 if not defaultuser:
                     raise error.Abort(
-                        _('cannot find bugzilla user id for %s') % user
+                        _(b'cannot find bugzilla user id for %s') % user
                     )
                 userid = self.get_user_id(defaultuser)
                 user = defaultuser
             except KeyError:
                 raise error.Abort(
-                    _('cannot find bugzilla user id for %s or %s')
+                    _(b'cannot find bugzilla user id for %s or %s')
                     % (user, defaultuser)
                 )
         return (user, userid)
@@ -607,7 +609,7 b' class bzmysql(bzaccess):'
         Try adding comment as committer of changeset, otherwise as
         default bugzilla user.'''
         if len(newstate) > 0:
-            self.ui.warn(_("Bugzilla/MySQL cannot update bug state\n"))
+            self.ui.warn(_(b"Bugzilla/MySQL cannot update bug state\n"))
 
         (user, userid) = self.get_bugzilla_user(committer)
         now = time.strftime(r'%Y-%m-%d %H:%M:%S')
@@ -631,7 +633,7 b' class bzmysql_2_18(bzmysql):'
     def __init__(self, ui):
         bzmysql.__init__(self, ui)
         self.default_notify = (
-            "cd %(bzdir)s && perl -T contrib/sendbugmail.pl %(id)s %(user)s"
+            b"cd %(bzdir)s && perl -T contrib/sendbugmail.pl %(id)s %(user)s"
         )
 
 
@@ -643,10 +645,10 b' class bzmysql_3_0(bzmysql_2_18):'
 
     def get_longdesc_id(self):
         '''get identity of longdesc field'''
-        self.run('select id from fielddefs where name = "longdesc"')
+        self.run(b'select id from fielddefs where name = "longdesc"')
         ids = self.cursor.fetchall()
         if len(ids) != 1:
-            raise error.Abort(_('unknown database schema'))
+            raise error.Abort(_(b'unknown database schema'))
         return ids[0][0]
 
 
@@ -674,7 +676,7 b' class cookietransportrequest(object):'
     def send_cookies(self, connection):
         if self.cookies:
             for cookie in self.cookies:
-                connection.putheader("Cookie", cookie)
+                connection.putheader(b"Cookie", cookie)
 
     def request(self, host, handler, request_body, verbose=0):
         self.verbose = verbose
@@ -702,9 +704,9 b' class cookietransportrequest(object):'
             response = h._conn.getresponse()
 
         # Add any cookie definitions to our list.
-        for header in response.msg.getallmatchingheaders("Set-Cookie"):
-            val = header.split(": ", 1)[1]
-            cookie = val.split(";", 1)[0]
+        for header in response.msg.getallmatchingheaders(b"Set-Cookie"):
+            val = header.split(b": ", 1)[1]
+            cookie = val.split(b";", 1)[0]
             self.cookies.append(cookie)
 
         if response.status != 200:
@@ -729,13 +731,13 b' class cookietransportrequest(object):'
 # inheritance with a new-style class.
 class cookietransport(cookietransportrequest, xmlrpclib.Transport):
     def __init__(self, use_datetime=0):
-        if util.safehasattr(xmlrpclib.Transport, "__init__"):
+        if util.safehasattr(xmlrpclib.Transport, b"__init__"):
             xmlrpclib.Transport.__init__(self, use_datetime)
 
 
 class cookiesafetransport(cookietransportrequest, xmlrpclib.SafeTransport):
     def __init__(self, use_datetime=0):
-        if util.safehasattr(xmlrpclib.Transport, "__init__"):
+        if util.safehasattr(xmlrpclib.Transport, b"__init__"):
             xmlrpclib.SafeTransport.__init__(self, use_datetime)
 
 
@@ -748,26 +750,26 b' class bzxmlrpc(bzaccess):'
     def __init__(self, ui):
         bzaccess.__init__(self, ui)
 
-        bzweb = self.ui.config('bugzilla', 'bzurl')
-        bzweb = bzweb.rstrip("/") + "/xmlrpc.cgi"
+        bzweb = self.ui.config(b'bugzilla', b'bzurl')
+        bzweb = bzweb.rstrip(b"/") + b"/xmlrpc.cgi"
 
-        user = self.ui.config('bugzilla', 'user')
-        passwd = self.ui.config('bugzilla', 'password')
+        user = self.ui.config(b'bugzilla', b'user')
+        passwd = self.ui.config(b'bugzilla', b'password')
 
-        self.fixstatus = self.ui.config('bugzilla', 'fixstatus')
-        self.fixresolution = self.ui.config('bugzilla', 'fixresolution')
+        self.fixstatus = self.ui.config(b'bugzilla', b'fixstatus')
+        self.fixresolution = self.ui.config(b'bugzilla', b'fixresolution')
 
         self.bzproxy = xmlrpclib.ServerProxy(bzweb, self.transport(bzweb))
-        ver = self.bzproxy.Bugzilla.version()['version'].split('.')
+        ver = self.bzproxy.Bugzilla.version()[b'version'].split(b'.')
         self.bzvermajor = int(ver[0])
         self.bzverminor = int(ver[1])
         login = self.bzproxy.User.login(
-            {'login': user, 'password': passwd, 'restrict_login': True}
+            {b'login': user, b'password': passwd, b'restrict_login': True}
         )
-        self.bztoken = login.get('token', '')
+        self.bztoken = login.get(b'token', b'')
 
     def transport(self, uri):
-        if util.urlreq.urlparse(uri, "http")[0] == "https":
+        if util.urlreq.urlparse(uri, b"http")[0] == b"https":
             return cookiesafetransport()
         else:
             return cookietransport()
@@ -775,56 +777,58 b' class bzxmlrpc(bzaccess):'
     def get_bug_comments(self, id):
         """Return a string with all comment text for a bug."""
         c = self.bzproxy.Bug.comments(
-            {'ids': [id], 'include_fields': ['text'], 'token': self.bztoken}
+            {b'ids': [id], b'include_fields': [b'text'], b'token': self.bztoken}
         )
-        return ''.join([t['text'] for t in c['bugs']['%d' % id]['comments']])
+        return b''.join(
+            [t[b'text'] for t in c[b'bugs'][b'%d' % id][b'comments']]
+        )
 
     def filter_real_bug_ids(self, bugs):
         probe = self.bzproxy.Bug.get(
             {
-                'ids': sorted(bugs.keys()),
-                'include_fields': [],
-                'permissive': True,
-                'token': self.bztoken,
+                b'ids': sorted(bugs.keys()),
+                b'include_fields': [],
+                b'permissive': True,
+                b'token': self.bztoken,
             }
         )
-        for badbug in probe['faults']:
-            id = badbug['id']
-            self.ui.status(_('bug %d does not exist\n') % id)
+        for badbug in probe[b'faults']:
+            id = badbug[b'id']
+            self.ui.status(_(b'bug %d does not exist\n') % id)
             del bugs[id]
 
     def filter_cset_known_bug_ids(self, node, bugs):
         for id in sorted(bugs.keys()):
             if self.get_bug_comments(id).find(short(node)) != -1:
                 self.ui.status(
-                    _('bug %d already knows about changeset %s\n')
+                    _(b'bug %d already knows about changeset %s\n')
                     % (id, short(node))
                 )
                 del bugs[id]
 
     def updatebug(self, bugid, newstate, text, committer):
         args = {}
-        if 'hours' in newstate:
-            args['work_time'] = newstate['hours']
+        if b'hours' in newstate:
+            args[b'work_time'] = newstate[b'hours']
 
         if self.bzvermajor >= 4:
-            args['ids'] = [bugid]
-            args['comment'] = {'body': text}
-            if 'fix' in newstate:
-                args['status'] = self.fixstatus
-                args['resolution'] = self.fixresolution
-            args['token'] = self.bztoken
+            args[b'ids'] = [bugid]
+            args[b'comment'] = {b'body': text}
+            if b'fix' in newstate:
+                args[b'status'] = self.fixstatus
+                args[b'resolution'] = self.fixresolution
+            args[b'token'] = self.bztoken
             self.bzproxy.Bug.update(args)
         else:
-            if 'fix' in newstate:
+            if b'fix' in newstate:
                 self.ui.warn(
                     _(
-                        "Bugzilla/XMLRPC needs Bugzilla 4.0 or later "
-                        "to mark bugs fixed\n"
+                        b"Bugzilla/XMLRPC needs Bugzilla 4.0 or later "
+                        b"to mark bugs fixed\n"
                     )
                 )
-            args['id'] = bugid
-            args['comment'] = text
+            args[b'id'] = bugid
+            args[b'comment'] = text
             self.bzproxy.Bug.add_comment(args)
 
 
@@ -851,18 +855,18 b' class bzxmlrpcemail(bzxmlrpc):'
     def __init__(self, ui):
         bzxmlrpc.__init__(self, ui)
 
-        self.bzemail = self.ui.config('bugzilla', 'bzemail')
+        self.bzemail = self.ui.config(b'bugzilla', b'bzemail')
         if not self.bzemail:
-            raise error.Abort(_("configuration 'bzemail' missing"))
+            raise error.Abort(_(b"configuration 'bzemail' missing"))
         mail.validateconfig(self.ui)
 
     def makecommandline(self, fieldname, value):
         if self.bzvermajor >= 4:
-            return "@%s %s" % (fieldname, pycompat.bytestr(value))
+            return b"@%s %s" % (fieldname, pycompat.bytestr(value))
         else:
-            if fieldname == "id":
-                fieldname = "bug_id"
-            return "@%s = %s" % (fieldname, pycompat.bytestr(value))
+            if fieldname == b"id":
+                fieldname = b"bug_id"
+            return b"@%s = %s" % (fieldname, pycompat.bytestr(value))
 
     def send_bug_modify_email(self, bugid, commands, comment, committer):
         '''send modification message to Bugzilla bug via email.
@@ -877,39 +881,41 b' class bzxmlrpcemail(bzxmlrpc):'
         '''
         user = self.map_committer(committer)
         matches = self.bzproxy.User.get(
-            {'match': [user], 'token': self.bztoken}
+            {b'match': [user], b'token': self.bztoken}
         )
-        if not matches['users']:
-            user = self.ui.config('bugzilla', 'user')
+        if not matches[b'users']:
+            user = self.ui.config(b'bugzilla', b'user')
             matches = self.bzproxy.User.get(
-                {'match': [user], 'token': self.bztoken}
+                {b'match': [user], b'token': self.bztoken}
             )
-            if not matches['users']:
+            if not matches[b'users']:
                 raise error.Abort(
-                    _("default bugzilla user %s email not found") % user
+                    _(b"default bugzilla user %s email not found") % user
                 )
-        user = matches['users'][0]['email']
-        commands.append(self.makecommandline("id", bugid))
+        user = matches[b'users'][0][b'email']
+        commands.append(self.makecommandline(b"id", bugid))
 
-        text = "\n".join(commands) + "\n\n" + comment
+        text = b"\n".join(commands) + b"\n\n" + comment
 
         _charsets = mail._charsets(self.ui)
         user = mail.addressencode(self.ui, user, _charsets)
         bzemail = mail.addressencode(self.ui, self.bzemail, _charsets)
         msg = mail.mimeencode(self.ui, text, _charsets)
-        msg['From'] = user
-        msg['To'] = bzemail
-        msg['Subject'] = mail.headencode(self.ui, "Bug modification", _charsets)
+        msg[b'From'] = user
+        msg[b'To'] = bzemail
+        msg[b'Subject'] = mail.headencode(
+            self.ui, b"Bug modification", _charsets
+        )
         sendmail = mail.connect(self.ui)
         sendmail(user, bzemail, msg.as_string())
 
     def updatebug(self, bugid, newstate, text, committer):
         cmds = []
-        if 'hours' in newstate:
-            cmds.append(self.makecommandline("work_time", newstate['hours']))
-        if 'fix' in newstate:
-            cmds.append(self.makecommandline("bug_status", self.fixstatus))
-            cmds.append(self.makecommandline("resolution", self.fixresolution))
+        if b'hours' in newstate:
+            cmds.append(self.makecommandline(b"work_time", newstate[b'hours']))
+        if b'fix' in newstate:
+            cmds.append(self.makecommandline(b"bug_status", self.fixstatus))
+            cmds.append(self.makecommandline(b"resolution", self.fixresolution))
         self.send_bug_modify_email(bugid, cmds, text, committer)
 
 
@@ -924,26 +930,26 b' class bzrestapi(bzaccess):'
 
     def __init__(self, ui):
         bzaccess.__init__(self, ui)
-        bz = self.ui.config('bugzilla', 'bzurl')
-        self.bzroot = '/'.join([bz, 'rest'])
-        self.apikey = self.ui.config('bugzilla', 'apikey')
-        self.user = self.ui.config('bugzilla', 'user')
-        self.passwd = self.ui.config('bugzilla', 'password')
-        self.fixstatus = self.ui.config('bugzilla', 'fixstatus')
-        self.fixresolution = self.ui.config('bugzilla', 'fixresolution')
+        bz = self.ui.config(b'bugzilla', b'bzurl')
+        self.bzroot = b'/'.join([bz, b'rest'])
+        self.apikey = self.ui.config(b'bugzilla', b'apikey')
+        self.user = self.ui.config(b'bugzilla', b'user')
+        self.passwd = self.ui.config(b'bugzilla', b'password')
+        self.fixstatus = self.ui.config(b'bugzilla', b'fixstatus')
+        self.fixresolution = self.ui.config(b'bugzilla', b'fixresolution')
 
     def apiurl(self, targets, include_fields=None):
-        url = '/'.join([self.bzroot] + [pycompat.bytestr(t) for t in targets])
+        url = b'/'.join([self.bzroot] + [pycompat.bytestr(t) for t in targets])
         qv = {}
         if self.apikey:
-            qv['api_key'] = self.apikey
+            qv[b'api_key'] = self.apikey
         elif self.user and self.passwd:
-            qv['login'] = self.user
-            qv['password'] = self.passwd
+            qv[b'login'] = self.user
+            qv[b'password'] = self.passwd
         if include_fields:
-            qv['include_fields'] = include_fields
+            qv[b'include_fields'] = include_fields
         if qv:
-            url = '%s?%s' % (url, util.urlreq.urlencode(qv))
+            url = b'%s?%s' % (url, util.urlreq.urlencode(qv))
         return url
 
     def _fetch(self, burl):
@@ -952,30 +958,30 b' class bzrestapi(bzaccess):'
             return json.loads(resp.read())
         except util.urlerr.httperror as inst:
             if inst.code == 401:
-                raise error.Abort(_('authorization failed'))
+                raise error.Abort(_(b'authorization failed'))
             if inst.code == 404:
                 raise NotFound()
             else:
                 raise
 
-    def _submit(self, burl, data, method='POST'):
+    def _submit(self, burl, data, method=b'POST'):
         data = json.dumps(data)
-        if method == 'PUT':
+        if method == b'PUT':
 
             class putrequest(util.urlreq.request):
                 def get_method(self):
-                    return 'PUT'
+                    return b'PUT'
 
             request_type = putrequest
         else:
             request_type = util.urlreq.request
-        req = request_type(burl, data, {'Content-Type': 'application/json'})
+        req = request_type(burl, data, {b'Content-Type': b'application/json'})
         try:
             resp = url.opener(self.ui).open(req)
             return json.loads(resp.read())
         except util.urlerr.httperror as inst:
             if inst.code == 401:
-                raise error.Abort(_('authorization failed'))
+                raise error.Abort(_(b'authorization failed'))
             if inst.code == 404:
                 raise NotFound()
             else:
@@ -985,7 +991,7 b' class bzrestapi(bzaccess):'
         '''remove bug IDs that do not exist in Bugzilla from bugs.'''
         badbugs = set()
         for bugid in bugs:
-            burl = self.apiurl(('bug', bugid), include_fields='status')
+            burl = self.apiurl((b'bug', bugid), include_fields=b'status')
             try:
                 self._fetch(burl)
             except NotFound:
@@ -997,12 +1003,15 b' class bzrestapi(bzaccess):'
         '''remove bug IDs where node occurs in comment text from bugs.'''
         sn = short(node)
         for bugid in bugs.keys():
-            burl = self.apiurl(('bug', bugid, 'comment'), include_fields='text')
+            burl = self.apiurl(
+                (b'bug', bugid, b'comment'), include_fields=b'text'
+            )
             result = self._fetch(burl)
-            comments = result['bugs'][pycompat.bytestr(bugid)]['comments']
-            if any(sn in c['text'] for c in comments):
+            comments = result[b'bugs'][pycompat.bytestr(bugid)][b'comments']
+            if any(sn in c[b'text'] for c in comments):
                 self.ui.status(
-                    _('bug %d already knows about changeset %s\n') % (bugid, sn)
+                    _(b'bug %d already knows about changeset %s\n')
+                    % (bugid, sn)
                 )
                 del bugs[bugid]
 
@@ -1013,28 +1022,32 b' class bzrestapi(bzaccess):'
         the changeset. Otherwise use the default Bugzilla user.
         '''
         bugmod = {}
-        if 'hours' in newstate:
-            bugmod['work_time'] = newstate['hours']
-        if 'fix' in newstate:
-            bugmod['status'] = self.fixstatus
-            bugmod['resolution'] = self.fixresolution
+        if b'hours' in newstate:
+            bugmod[b'work_time'] = newstate[b'hours']
+        if b'fix' in newstate:
+            bugmod[b'status'] = self.fixstatus
+            bugmod[b'resolution'] = self.fixresolution
         if bugmod:
             # if we have to change the bugs state do it here
-            bugmod['comment'] = {
-                'comment': text,
-                'is_private': False,
-                'is_markdown': False,
+            bugmod[b'comment'] = {
+                b'comment': text,
+                b'is_private': False,
+                b'is_markdown': False,
             }
-            burl = self.apiurl(('bug', bugid))
-            self._submit(burl, bugmod, method='PUT')
-            self.ui.debug('updated bug %s\n' % bugid)
+            burl = self.apiurl((b'bug', bugid))
+            self._submit(burl, bugmod, method=b'PUT')
+            self.ui.debug(b'updated bug %s\n' % bugid)
         else:
-            burl = self.apiurl(('bug', bugid, 'comment'))
+            burl = self.apiurl((b'bug', bugid, b'comment'))
             self._submit(
                 burl,
-                {'comment': text, 'is_private': False, 'is_markdown': False,},
+                {
+                    b'comment': text,
+                    b'is_private': False,
+                    b'is_markdown': False,
+                },
             )
-            self.ui.debug('added comment to bug %s\n' % bugid)
+            self.ui.debug(b'added comment to bug %s\n' % bugid)
 
     def notify(self, bugs, committer):
         '''Force sending of Bugzilla notification emails.
@@ -1049,32 +1062,32 b' class bugzilla(object):'
     # supported versions of bugzilla. different versions have
     # different schemas.
     _versions = {
-        '2.16': bzmysql,
-        '2.18': bzmysql_2_18,
-        '3.0': bzmysql_3_0,
-        'xmlrpc': bzxmlrpc,
-        'xmlrpc+email': bzxmlrpcemail,
-        'restapi': bzrestapi,
+        b'2.16': bzmysql,
+        b'2.18': bzmysql_2_18,
+        b'3.0': bzmysql_3_0,
+        b'xmlrpc': bzxmlrpc,
+        b'xmlrpc+email': bzxmlrpcemail,
+        b'restapi': bzrestapi,
     }
 
     def __init__(self, ui, repo):
         self.ui = ui
         self.repo = repo
 
-        bzversion = self.ui.config('bugzilla', 'version')
+        bzversion = self.ui.config(b'bugzilla', b'version')
         try:
             bzclass = bugzilla._versions[bzversion]
         except KeyError:
             raise error.Abort(
-                _('bugzilla version %s not supported') % bzversion
+                _(b'bugzilla version %s not supported') % bzversion
             )
         self.bzdriver = bzclass(self.ui)
 
         self.bug_re = re.compile(
-            self.ui.config('bugzilla', 'regexp'), re.IGNORECASE
+            self.ui.config(b'bugzilla', b'regexp'), re.IGNORECASE
         )
         self.fix_re = re.compile(
-            self.ui.config('bugzilla', 'fixregexp'), re.IGNORECASE
+            self.ui.config(b'bugzilla', b'fixregexp'), re.IGNORECASE
         )
         self.split_re = re.compile(br'\D+')
 
@@ -1106,25 +1119,25 b' class bugzilla(object):'
             start = m.end()
             if m is bugmatch:
                 bugmatch = self.bug_re.search(ctx.description(), start)
-                if 'fix' in bugattribs:
-                    del bugattribs['fix']
+                if b'fix' in bugattribs:
+                    del bugattribs[b'fix']
             else:
                 fixmatch = self.fix_re.search(ctx.description(), start)
-                bugattribs['fix'] = None
+                bugattribs[b'fix'] = None
 
             try:
-                ids = m.group('ids')
+                ids = m.group(b'ids')
             except IndexError:
                 ids = m.group(1)
             try:
-                hours = float(m.group('hours'))
-                bugattribs['hours'] = hours
+                hours = float(m.group(b'hours'))
+                bugattribs[b'hours'] = hours
             except IndexError:
                 pass
             except TypeError:
                 pass
             except ValueError:
-                self.ui.status(_("%s: invalid hours\n") % m.group('hours'))
+                self.ui.status(_(b"%s: invalid hours\n") % m.group(b'hours'))
 
             for id in self.split_re.split(ids):
                 if not id:
@@ -1142,10 +1155,10 b' class bugzilla(object):'
         def webroot(root):
             '''strip leading prefix of repo root and turn into
             url-safe path.'''
-            count = int(self.ui.config('bugzilla', 'strip'))
+            count = int(self.ui.config(b'bugzilla', b'strip'))
             root = util.pconvert(root)
             while count > 0:
-                c = root.find('/')
+                c = root.find(b'/')
                 if c == -1:
                     break
                 root = root[c + 1 :]
@@ -1153,13 +1166,13 b' class bugzilla(object):'
             return root
 
         mapfile = None
-        tmpl = self.ui.config('bugzilla', 'template')
+        tmpl = self.ui.config(b'bugzilla', b'template')
         if not tmpl:
-            mapfile = self.ui.config('bugzilla', 'style')
+            mapfile = self.ui.config(b'bugzilla', b'style')
         if not mapfile and not tmpl:
             tmpl = _(
-                'changeset {node|short} in repo {root} refers '
-                'to bug {bug}.\ndetails:\n\t{desc|tabindent}'
+                b'changeset {node|short} in repo {root} refers '
+                b'to bug {bug}.\ndetails:\n\t{desc|tabindent}'
             )
         spec = logcmdutil.templatespec(tmpl, mapfile)
         t = logcmdutil.changesettemplater(self.ui, self.repo, spec)
@@ -1168,7 +1181,7 b' class bugzilla(object):'
             ctx,
             changes=ctx.changeset(),
             bug=pycompat.bytestr(bugid),
-            hgweb=self.ui.config('web', 'baseurl'),
+            hgweb=self.ui.config(b'web', b'baseurl'),
             root=self.repo.root,
             webroot=webroot(self.repo.root),
         )
@@ -1188,7 +1201,7 b' def hook(ui, repo, hooktype, node=None, '
     seen multiple times does not fill bug with duplicate data.'''
     if node is None:
         raise error.Abort(
-            _('hook type %s does not pass a changeset id') % hooktype
+            _(b'hook type %s does not pass a changeset id') % hooktype
         )
     try:
         bz = bugzilla(ui, repo)
@@ -1199,4 +1212,4 b' def hook(ui, repo, hooktype, node=None, '
                 bz.update(bug, bugs[bug], ctx)
             bz.notify(bugs, stringutil.email(ctx.user()))
     except Exception as e:
-        raise error.Abort(_('Bugzilla error: %s') % e)
+        raise error.Abort(_(b'Bugzilla error: %s') % e)

hgext/censor.py

@@ -42,49 +42,55 b' command = registrar.command(cmdtable)'
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
-testedwith = 'ships-with-hg-core'
+testedwith = b'ships-with-hg-core'
 
 
 @command(
-    'censor',
+    b'censor',
     [
-        ('r', 'rev', '', _('censor file from specified revision'), _('REV')),
-        ('t', 'tombstone', '', _('replacement tombstone data'), _('TEXT')),
+        (
+            b'r',
+            b'rev',
+            b'',
+            _(b'censor file from specified revision'),
+            _(b'REV'),
+        ),
+        (b't', b'tombstone', b'', _(b'replacement tombstone data'), _(b'TEXT')),
     ],
-    _('-r REV [-t TEXT] [FILE]'),
+    _(b'-r REV [-t TEXT] [FILE]'),
     helpcategory=command.CATEGORY_MAINTENANCE,
 )
-def censor(ui, repo, path, rev='', tombstone='', **opts):
+def censor(ui, repo, path, rev=b'', tombstone=b'', **opts):
     with repo.wlock(), repo.lock():
         return _docensor(ui, repo, path, rev, tombstone, **opts)
 
 
-def _docensor(ui, repo, path, rev='', tombstone='', **opts):
+def _docensor(ui, repo, path, rev=b'', tombstone=b'', **opts):
     if not path:
-        raise error.Abort(_('must specify file path to censor'))
+        raise error.Abort(_(b'must specify file path to censor'))
     if not rev:
-        raise error.Abort(_('must specify revision to censor'))
+        raise error.Abort(_(b'must specify revision to censor'))
 
     wctx = repo[None]
 
     m = scmutil.match(wctx, (path,))
     if m.anypats() or len(m.files()) != 1:
-        raise error.Abort(_('can only specify an explicit filename'))
+        raise error.Abort(_(b'can only specify an explicit filename'))
     path = m.files()[0]
     flog = repo.file(path)
     if not len(flog):
-        raise error.Abort(_('cannot censor file with no history'))
+        raise error.Abort(_(b'cannot censor file with no history'))
 
     rev = scmutil.revsingle(repo, rev, rev).rev()
     try:
         ctx = repo[rev]
     except KeyError:
-        raise error.Abort(_('invalid revision identifier %s') % rev)
+        raise error.Abort(_(b'invalid revision identifier %s') % rev)
 
     try:
         fctx = ctx.filectx(path)
     except error.LookupError:
-        raise error.Abort(_('file does not exist at revision %s') % rev)
+        raise error.Abort(_(b'file does not exist at revision %s') % rev)
 
     fnode = fctx.filenode()
     heads = []
@@ -93,17 +99,17 b" def _docensor(ui, repo, path, rev='', to"
         if path in hc and hc.filenode(path) == fnode:
             heads.append(hc)
     if heads:
-        headlist = ', '.join([short(c.node()) for c in heads])
+        headlist = b', '.join([short(c.node()) for c in heads])
         raise error.Abort(
-            _('cannot censor file in heads (%s)') % headlist,
-            hint=_('clean/delete and commit first'),
+            _(b'cannot censor file in heads (%s)') % headlist,
+            hint=_(b'clean/delete and commit first'),
         )
 
     wp = wctx.parents()
     if ctx.node() in [p.node() for p in wp]:
         raise error.Abort(
-            _('cannot censor working directory'),
-            hint=_('clean/delete/update first'),
+            _(b'cannot censor working directory'),
+            hint=_(b'clean/delete/update first'),
         )
 
     with repo.transaction(b'censor') as tr:

hgext/children.py

@@ -33,14 +33,22 b' command = registrar.command(cmdtable)'
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
-testedwith = 'ships-with-hg-core'
+testedwith = b'ships-with-hg-core'
 
 
 @command(
-    'children',
-    [('r', 'rev', '.', _('show children of the specified revision'), _('REV')),]
+    b'children',
+    [
+        (
+            b'r',
+            b'rev',
+            b'.',
+            _(b'show children of the specified revision'),
+            _(b'REV'),
+        ),
+    ]
     + templateopts,
-    _('hg children [-r REV] [FILE]'),
+    _(b'hg children [-r REV] [FILE]'),
     helpcategory=command.CATEGORY_CHANGE_NAVIGATION,
     inferrepo=True,
 )
@@ -62,7 +70,7 b' def children(ui, repo, file_=None, **opt'
 
     """
     opts = pycompat.byteskwargs(opts)
-    rev = opts.get('rev')
+    rev = opts.get(b'rev')
     ctx = scmutil.revsingle(repo, rev)
     if file_:
         fctx = repo.filectx(file_, changeid=ctx.rev())

hgext/churn.py

@@ -32,17 +32,17 b' command = registrar.command(cmdtable)'
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
-testedwith = 'ships-with-hg-core'
+testedwith = b'ships-with-hg-core'
 
 
 def changedlines(ui, repo, ctx1, ctx2, fns):
     added, removed = 0, 0
     fmatch = scmutil.matchfiles(repo, fns)
-    diff = ''.join(patch.diff(repo, ctx1.node(), ctx2.node(), fmatch))
-    for l in diff.split('\n'):
-        if l.startswith("+") and not l.startswith("+++ "):
+    diff = b''.join(patch.diff(repo, ctx1.node(), ctx2.node(), fmatch))
+    for l in diff.split(b'\n'):
+        if l.startswith(b"+") and not l.startswith(b"+++ "):
             added += 1
-        elif l.startswith("-") and not l.startswith("--- "):
+        elif l.startswith(b"-") and not l.startswith(b"--- "):
             removed += 1
     return (added, removed)
 
@@ -50,17 +50,17 b' def changedlines(ui, repo, ctx1, ctx2, f'
 def countrate(ui, repo, amap, *pats, **opts):
     """Calculate stats"""
     opts = pycompat.byteskwargs(opts)
-    if opts.get('dateformat'):
+    if opts.get(b'dateformat'):
 
         def getkey(ctx):
             t, tz = ctx.date()
             date = datetime.datetime(*time.gmtime(float(t) - tz)[:6])
             return encoding.strtolocal(
-                date.strftime(encoding.strfromlocal(opts['dateformat']))
+                date.strftime(encoding.strfromlocal(opts[b'dateformat']))
             )
 
     else:
-        tmpl = opts.get('oldtemplate') or opts.get('template')
+        tmpl = opts.get(b'oldtemplate') or opts.get(b'template')
         tmpl = logcmdutil.maketemplater(ui, repo, tmpl)
 
         def getkey(ctx):
@@ -69,12 +69,12 b' def countrate(ui, repo, amap, *pats, **o'
             return ui.popbuffer()
 
     progress = ui.makeprogress(
-        _('analyzing'), unit=_('revisions'), total=len(repo)
+        _(b'analyzing'), unit=_(b'revisions'), total=len(repo)
     )
     rate = {}
     df = False
-    if opts.get('date'):
-        df = dateutil.matchdate(opts['date'])
+    if opts.get(b'date'):
+        df = dateutil.matchdate(opts[b'date'])
 
     m = scmutil.match(repo[None], pats, opts)
 
@@ -85,12 +85,12 b' def countrate(ui, repo, amap, *pats, **o'
 
         key = getkey(ctx).strip()
         key = amap.get(key, key)  # alias remap
-        if opts.get('changesets'):
+        if opts.get(b'changesets'):
             rate[key] = (rate.get(key, (0,))[0] + 1, 0)
         else:
             parents = ctx.parents()
             if len(parents) > 1:
-                ui.note(_('revision %d is a merge, ignoring...\n') % (rev,))
+                ui.note(_(b'revision %d is a merge, ignoring...\n') % (rev,))
                 return
 
             ctx1 = parents[0]
@@ -108,50 +108,50 b' def countrate(ui, repo, amap, *pats, **o'
 
 
 @command(
-    'churn',
+    b'churn',
     [
         (
-            'r',
-            'rev',
+            b'r',
+            b'rev',
             [],
-            _('count rate for the specified revision or revset'),
-            _('REV'),
+            _(b'count rate for the specified revision or revset'),
+            _(b'REV'),
         ),
         (
-            'd',
-            'date',
-            '',
-            _('count rate for revisions matching date spec'),
-            _('DATE'),
+            b'd',
+            b'date',
+            b'',
+            _(b'count rate for revisions matching date spec'),
+            _(b'DATE'),
         ),
         (
-            't',
-            'oldtemplate',
-            '',
-            _('template to group changesets (DEPRECATED)'),
-            _('TEMPLATE'),
+            b't',
+            b'oldtemplate',
+            b'',
+            _(b'template to group changesets (DEPRECATED)'),
+            _(b'TEMPLATE'),
         ),
         (
-            'T',
-            'template',
-            '{author|email}',
-            _('template to group changesets'),
-            _('TEMPLATE'),
+            b'T',
+            b'template',
+            b'{author|email}',
+            _(b'template to group changesets'),
+            _(b'TEMPLATE'),
         ),
         (
-            'f',
-            'dateformat',
-            '',
-            _('strftime-compatible format for grouping by date'),
-            _('FORMAT'),
+            b'f',
+            b'dateformat',
+            b'',
+            _(b'strftime-compatible format for grouping by date'),
+            _(b'FORMAT'),
         ),
-        ('c', 'changesets', False, _('count rate by number of changesets')),
-        ('s', 'sort', False, _('sort by key (default: sort by count)')),
-        ('', 'diffstat', False, _('display added/removed lines separately')),
-        ('', 'aliases', '', _('file with email aliases'), _('FILE')),
+        (b'c', b'changesets', False, _(b'count rate by number of changesets')),
+        (b's', b'sort', False, _(b'sort by key (default: sort by count)')),
+        (b'', b'diffstat', False, _(b'display added/removed lines separately')),
+        (b'', b'aliases', b'', _(b'file with email aliases'), _(b'FILE')),
     ]
     + cmdutil.walkopts,
-    _("hg churn [-d DATE] [-r REV] [--aliases FILE] [FILE]"),
+    _(b"hg churn [-d DATE] [-r REV] [--aliases FILE] [FILE]"),
     helpcategory=command.CATEGORY_MAINTENANCE,
     inferrepo=True,
 )
@@ -193,21 +193,21 b' def churn(ui, repo, *pats, **opts):'
     '''
 
     def pad(s, l):
-        return s + " " * (l - encoding.colwidth(s))
+        return s + b" " * (l - encoding.colwidth(s))
 
     amap = {}
     aliases = opts.get(r'aliases')
-    if not aliases and os.path.exists(repo.wjoin('.hgchurn')):
-        aliases = repo.wjoin('.hgchurn')
+    if not aliases and os.path.exists(repo.wjoin(b'.hgchurn')):
+        aliases = repo.wjoin(b'.hgchurn')
     if aliases:
-        for l in open(aliases, "rb"):
+        for l in open(aliases, b"rb"):
             try:
-                alias, actual = l.rsplit('=' in l and '=' or None, 1)
+                alias, actual = l.rsplit(b'=' in l and b'=' or None, 1)
                 amap[alias.strip()] = actual.strip()
             except ValueError:
                 l = l.strip()
                 if l:
-                    ui.warn(_("skipping malformed alias: %s\n") % l)
+                    ui.warn(_(b"skipping malformed alias: %s\n") % l)
                 continue
 
     rate = list(countrate(ui, repo, amap, *pats, **opts).items())
@@ -224,7 +224,7 b' def churn(ui, repo, *pats, **opts):'
     maxname = max(len(k) for k, v in rate)
 
     ttywidth = ui.termwidth()
-    ui.debug("assuming %i character terminal\n" % ttywidth)
+    ui.debug(b"assuming %i character terminal\n" % ttywidth)
     width = ttywidth - maxname - 2 - 2 - 2
 
     if opts.get(r'diffstat'):
@@ -232,21 +232,21 b' def churn(ui, repo, *pats, **opts):'
 
         def format(name, diffstat):
             added, removed = diffstat
-            return "%s %15s %s%s\n" % (
+            return b"%s %15s %s%s\n" % (
                 pad(name, maxname),
-                '+%d/-%d' % (added, removed),
-                ui.label('+' * charnum(added), 'diffstat.inserted'),
-                ui.label('-' * charnum(removed), 'diffstat.deleted'),
+                b'+%d/-%d' % (added, removed),
+                ui.label(b'+' * charnum(added), b'diffstat.inserted'),
+                ui.label(b'-' * charnum(removed), b'diffstat.deleted'),
             )
 
     else:
         width -= 6
 
         def format(name, count):
-            return "%s %6d %s\n" % (
+            return b"%s %6d %s\n" % (
                 pad(name, maxname),
                 sum(count),
-                '*' * charnum(sum(count)),
+                b'*' * charnum(sum(count)),
             )
 
     def charnum(count):

hgext/clonebundles.py

@@ -201,7 +201,7 b' from mercurial import ('
     wireprotov1server,
 )
 
-testedwith = 'ships-with-hg-core'
+testedwith = b'ships-with-hg-core'
 
 
 def capabilities(orig, repo, proto):
@@ -210,11 +210,11 b' def capabilities(orig, repo, proto):'
     # Only advertise if a manifest exists. This does add some I/O to requests.
     # But this should be cheaper than a wasted network round trip due to
     # missing file.
-    if repo.vfs.exists('clonebundles.manifest'):
-        caps.append('clonebundles')
+    if repo.vfs.exists(b'clonebundles.manifest'):
+        caps.append(b'clonebundles')
 
     return caps
 
 
 def extsetup(ui):
-    extensions.wrapfunction(wireprotov1server, '_capabilities', capabilities)
+    extensions.wrapfunction(wireprotov1server, b'_capabilities', capabilities)

hgext/closehead.py

@@ -24,17 +24,17 b' command = registrar.command(cmdtable)'
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
-testedwith = 'ships-with-hg-core'
+testedwith = b'ships-with-hg-core'
 
 commitopts = cmdutil.commitopts
 commitopts2 = cmdutil.commitopts2
-commitopts3 = [('r', 'rev', [], _('revision to check'), _('REV'))]
+commitopts3 = [(b'r', b'rev', [], _(b'revision to check'), _(b'REV'))]
 
 
 @command(
-    'close-head|close-heads',
+    b'close-head|close-heads',
     commitopts + commitopts2 + commitopts3,
-    _('[OPTION]... [REV]...'),
+    _(b'[OPTION]... [REV]...'),
     helpcategory=command.CATEGORY_CHANGE_MANAGEMENT,
     inferrepo=True,
 )
@@ -55,11 +55,11 b' def close_branch(ui, repo, *revs, **opts'
             text=message,
             files=[],
             filectxfn=None,
-            user=opts.get('user'),
-            date=opts.get('date'),
+            user=opts.get(b'user'),
+            date=opts.get(b'date'),
             extra=extra,
         )
-        tr = repo.transaction('commit')
+        tr = repo.transaction(b'commit')
         ret = repo.commitctx(cctx, True)
         bookmarks.update(repo, [rev, None], ret)
         cctx.markcommitted(ret)
@@ -67,11 +67,11 b' def close_branch(ui, repo, *revs, **opts'
 
     opts = pycompat.byteskwargs(opts)
 
-    revs += tuple(opts.get('rev', []))
+    revs += tuple(opts.get(b'rev', []))
     revs = scmutil.revrange(repo, revs)
 
     if not revs:
-        raise error.Abort(_('no revisions specified'))
+        raise error.Abort(_(b'no revisions specified'))
 
     heads = []
     for branch in repo.branchmap():
@@ -79,17 +79,17 b' def close_branch(ui, repo, *revs, **opts'
     heads = set(repo[h].rev() for h in heads)
     for rev in revs:
         if rev not in heads:
-            raise error.Abort(_('revision is not an open head: %d') % rev)
+            raise error.Abort(_(b'revision is not an open head: %d') % rev)
 
     message = cmdutil.logmessage(ui, opts)
     if not message:
-        raise error.Abort(_("no commit message specified with -l or -m"))
-    extra = {'close': '1'}
+        raise error.Abort(_(b"no commit message specified with -l or -m"))
+    extra = {b'close': b'1'}
 
     with repo.wlock(), repo.lock():
         for rev in revs:
             r = repo[rev]
             branch = r.branch()
-            extra['branch'] = branch
+            extra[b'branch'] = branch
             docommit(r)
     return 0

hgext/commitextras.py

@@ -22,57 +22,64 b' from mercurial import ('
 
 cmdtable = {}
 command = registrar.command(cmdtable)
-testedwith = 'ships-with-hg-core'
+testedwith = b'ships-with-hg-core'
 
 usedinternally = {
-    'amend_source',
-    'branch',
-    'close',
-    'histedit_source',
-    'topic',
-    'rebase_source',
-    'intermediate-source',
-    '__touch-noise__',
-    'source',
-    'transplant_source',
+    b'amend_source',
+    b'branch',
+    b'close',
+    b'histedit_source',
+    b'topic',
+    b'rebase_source',
+    b'intermediate-source',
+    b'__touch-noise__',
+    b'source',
+    b'transplant_source',
 }
 
 
 def extsetup(ui):
-    entry = extensions.wrapcommand(commands.table, 'commit', _commit)
+    entry = extensions.wrapcommand(commands.table, b'commit', _commit)
     options = entry[1]
     options.append(
-        ('', 'extra', [], _('set a changeset\'s extra values'), _("KEY=VALUE"))
+        (
+            b'',
+            b'extra',
+            [],
+            _(b'set a changeset\'s extra values'),
+            _(b"KEY=VALUE"),
+        )
     )
 
 
 def _commit(orig, ui, repo, *pats, **opts):
-    if util.safehasattr(repo, 'unfiltered'):
+    if util.safehasattr(repo, b'unfiltered'):
         repo = repo.unfiltered()
 
     class repoextra(repo.__class__):
         def commit(self, *innerpats, **inneropts):
             extras = opts.get(r'extra')
             for raw in extras:
-                if '=' not in raw:
+                if b'=' not in raw:
                     msg = _(
-                        "unable to parse '%s', should follow "
-                        "KEY=VALUE format"
+                        b"unable to parse '%s', should follow "
+                        b"KEY=VALUE format"
                     )
                     raise error.Abort(msg % raw)
-                k, v = raw.split('=', 1)
+                k, v = raw.split(b'=', 1)
                 if not k:
-                    msg = _("unable to parse '%s', keys can't be empty")
+                    msg = _(b"unable to parse '%s', keys can't be empty")
                     raise error.Abort(msg % raw)
                 if re.search(br'[^\w-]', k):
                     msg = _(
-                        "keys can only contain ascii letters, digits,"
-                        " '_' and '-'"
+                        b"keys can only contain ascii letters, digits,"
+                        b" '_' and '-'"
                     )
                     raise error.Abort(msg)
                 if k in usedinternally:
                     msg = _(
-                        "key '%s' is used internally, can't be set " "manually"
+                        b"key '%s' is used internally, can't be set "
+                        b"manually"
                     )
                     raise error.Abort(msg % k)
                 inneropts[r'extra'][k] = v

hgext/convert/__init__.py

@@ -24,60 +24,72 b' command = registrar.command(cmdtable)'
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
-testedwith = 'ships-with-hg-core'
+testedwith = b'ships-with-hg-core'
 
 # Commands definition was moved elsewhere to ease demandload job.
 
 
 @command(
-    'convert',
+    b'convert',
     [
         (
-            '',
-            'authors',
-            '',
+            b'',
+            b'authors',
+            b'',
             _(
-                'username mapping filename (DEPRECATED) (use --authormap instead)'
+                b'username mapping filename (DEPRECATED) (use --authormap instead)'
             ),
-            _('FILE'),
+            _(b'FILE'),
         ),
-        ('s', 'source-type', '', _('source repository type'), _('TYPE')),
-        ('d', 'dest-type', '', _('destination repository type'), _('TYPE')),
-        ('r', 'rev', [], _('import up to source revision REV'), _('REV')),
-        ('A', 'authormap', '', _('remap usernames using this file'), _('FILE')),
+        (b's', b'source-type', b'', _(b'source repository type'), _(b'TYPE')),
         (
-            '',
-            'filemap',
-            '',
-            _('remap file names using contents of file'),
-            _('FILE'),
+            b'd',
+            b'dest-type',
+            b'',
+            _(b'destination repository type'),
+            _(b'TYPE'),
+        ),
+        (b'r', b'rev', [], _(b'import up to source revision REV'), _(b'REV')),
+        (
+            b'A',
+            b'authormap',
+            b'',
+            _(b'remap usernames using this file'),
+            _(b'FILE'),
         ),
         (
-            '',
-            'full',
-            None,
-            _('apply filemap changes by converting all files again'),
+            b'',
+            b'filemap',
+            b'',
+            _(b'remap file names using contents of file'),
+            _(b'FILE'),
         ),
         (
-            '',
-            'splicemap',
-            '',
-            _('splice synthesized history into place'),
-            _('FILE'),
+            b'',
+            b'full',
+            None,
+            _(b'apply filemap changes by converting all files again'),
         ),
         (
-            '',
-            'branchmap',
-            '',
-            _('change branch names while converting'),
-            _('FILE'),
+            b'',
+            b'splicemap',
+            b'',
+            _(b'splice synthesized history into place'),
+            _(b'FILE'),
         ),
-        ('', 'branchsort', None, _('try to sort changesets by branches')),
-        ('', 'datesort', None, _('try to sort changesets by date')),
-        ('', 'sourcesort', None, _('preserve source changesets order')),
-        ('', 'closesort', None, _('try to reorder closed revisions')),
+        (
+            b'',
+            b'branchmap',
+            b'',
+            _(b'change branch names while converting'),
+            _(b'FILE'),
+        ),
+        (b'', b'branchsort', None, _(b'try to sort changesets by branches')),
+        (b'', b'datesort', None, _(b'try to sort changesets by date')),
+        (b'', b'sourcesort', None, _(b'preserve source changesets order')),
+        (b'', b'closesort', None, _(b'try to reorder closed revisions')),
     ],
-    _('hg convert [OPTION]... SOURCE [DEST [REVMAP]]'),
+    _(b'hg convert [OPTION]... SOURCE [DEST [REVMAP]]'),
     norepo=True,
 )
 def convert(ui, src, dest=None, revmapfile=None, **opts):
@@ -483,34 +495,44 b' def convert(ui, src, dest=None, revmapfi'
     return convcmd.convert(ui, src, dest, revmapfile, **opts)
 
 
-@command('debugsvnlog', [], 'hg debugsvnlog', norepo=True)
+@command(b'debugsvnlog', [], b'hg debugsvnlog', norepo=True)
 def debugsvnlog(ui, **opts):
     return subversion.debugsvnlog(ui, **opts)
 
 
 @command(
-    'debugcvsps',
+    b'debugcvsps',
     [
         # Main options shared with cvsps-2.1
-        ('b', 'branches', [], _('only return changes on specified branches')),
-        ('p', 'prefix', '', _('prefix to remove from file names')),
         (
-            'r',
-            'revisions',
+            b'b',
+            b'branches',
             [],
-            _('only return changes after or between specified tags'),
+            _(b'only return changes on specified branches'),
+        ),
+        (b'p', b'prefix', b'', _(b'prefix to remove from file names')),
+        (
+            b'r',
+            b'revisions',
+            [],
+            _(b'only return changes after or between specified tags'),
         ),
-        ('u', 'update-cache', None, _("update cvs log cache")),
-        ('x', 'new-cache', None, _("create new cvs log cache")),
-        ('z', 'fuzz', 60, _('set commit time fuzz in seconds')),
-        ('', 'root', '', _('specify cvsroot')),
+        (b'u', b'update-cache', None, _(b"update cvs log cache")),
+        (b'x', b'new-cache', None, _(b"create new cvs log cache")),
+        (b'z', b'fuzz', 60, _(b'set commit time fuzz in seconds')),
+        (b'', b'root', b'', _(b'specify cvsroot')),
         # Options specific to builtin cvsps
-        ('', 'parents', '', _('show parent changesets')),
-        ('', 'ancestors', '', _('show current changeset in ancestor branches')),
+        (b'', b'parents', b'', _(b'show parent changesets')),
+        (
+            b'',
+            b'ancestors',
+            b'',
+            _(b'show current changeset in ancestor branches'),
+        ),
         # Options that are ignored for compatibility with cvsps-2.1
-        ('A', 'cvs-direct', None, _('ignored for compatibility')),
+        (b'A', b'cvs-direct', None, _(b'ignored for compatibility')),
     ],
-    _('hg debugcvsps [OPTION]... [PATH]...'),
+    _(b'hg debugcvsps [OPTION]... [PATH]...'),
     norepo=True,
 )
 def debugcvsps(ui, *args, **opts):
@@ -528,14 +550,14 b' def debugcvsps(ui, *args, **opts):'
 
 
 def kwconverted(context, mapping, name):
-    ctx = context.resource(mapping, 'ctx')
-    rev = ctx.extra().get('convert_revision', '')
-    if rev.startswith('svn:'):
-        if name == 'svnrev':
+    ctx = context.resource(mapping, b'ctx')
+    rev = ctx.extra().get(b'convert_revision', b'')
+    if rev.startswith(b'svn:'):
+        if name == b'svnrev':
             return b"%d" % subversion.revsplit(rev)[2]
-        elif name == 'svnpath':
+        elif name == b'svnpath':
             return subversion.revsplit(rev)[1]
-        elif name == 'svnuuid':
+        elif name == b'svnuuid':
             return subversion.revsplit(rev)[0]
     return rev
 
@@ -543,22 +565,22 b' def kwconverted(context, mapping, name):'
 templatekeyword = registrar.templatekeyword()
 
 
-@templatekeyword('svnrev', requires={'ctx'})
+@templatekeyword(b'svnrev', requires={b'ctx'})
 def kwsvnrev(context, mapping):
     """String. Converted subversion revision number."""
-    return kwconverted(context, mapping, 'svnrev')
+    return kwconverted(context, mapping, b'svnrev')
 
 
-@templatekeyword('svnpath', requires={'ctx'})
+@templatekeyword(b'svnpath', requires={b'ctx'})
 def kwsvnpath(context, mapping):
     """String. Converted subversion revision project path."""
-    return kwconverted(context, mapping, 'svnpath')
+    return kwconverted(context, mapping, b'svnpath')
 
 
-@templatekeyword('svnuuid', requires={'ctx'})
+@templatekeyword(b'svnuuid', requires={b'ctx'})
 def kwsvnuuid(context, mapping):
     """String. Converted subversion revision repository identifier."""
-    return kwconverted(context, mapping, 'svnuuid')
+    return kwconverted(context, mapping, b'svnuuid')
 
 
 # tell hggettext to extract docstrings from these functions:

hgext/convert/bzr.py

@@ -17,7 +17,7 b' from . import common'
 
 # these do not work with demandimport, blacklist
 demandimport.IGNORES.update(
-    ['bzrlib.transactions', 'bzrlib.urlutils', 'ElementPath',]
+    [b'bzrlib.transactions', b'bzrlib.urlutils', b'ElementPath',]
 )
 
 try:
@@ -35,7 +35,7 b' try:'
 except ImportError:
     pass
 
-supportedkinds = ('file', 'symlink')
+supportedkinds = (b'file', b'symlink')
 
 
 class bzr_source(common.converter_source):
@@ -44,16 +44,16 b' class bzr_source(common.converter_source'
     def __init__(self, ui, repotype, path, revs=None):
         super(bzr_source, self).__init__(ui, repotype, path, revs=revs)
 
-        if not os.path.exists(os.path.join(path, '.bzr')):
+        if not os.path.exists(os.path.join(path, b'.bzr')):
             raise common.NoRepo(
-                _('%s does not look like a Bazaar repository') % path
+                _(b'%s does not look like a Bazaar repository') % path
             )
 
         try:
             # access bzrlib stuff
             bzrdir
         except NameError:
-            raise common.NoRepo(_('Bazaar modules could not be loaded'))
+            raise common.NoRepo(_(b'Bazaar modules could not be loaded'))
 
         path = os.path.abspath(path)
         self._checkrepotype(path)
@@ -61,10 +61,10 b' class bzr_source(common.converter_source'
             self.sourcerepo = bzrdir.BzrDir.open(path).open_repository()
         except errors.NoRepositoryPresent:
             raise common.NoRepo(
-                _('%s does not look like a Bazaar repository') % path
+                _(b'%s does not look like a Bazaar repository') % path
             )
         self._parentids = {}
-        self._saverev = ui.configbool('convert', 'bzr.saverev')
+        self._saverev = ui.configbool(b'convert', b'bzr.saverev')
 
     def _checkrepotype(self, path):
         # Lightweight checkouts detection is informational but probably
@@ -84,13 +84,13 b' class bzr_source(common.converter_source'
             ):
                 self.ui.warn(
                     _(
-                        'warning: lightweight checkouts may cause '
-                        'conversion failures, try with a regular '
-                        'branch instead.\n'
+                        b'warning: lightweight checkouts may cause '
+                        b'conversion failures, try with a regular '
+                        b'branch instead.\n'
                     )
                 )
         except Exception:
-            self.ui.note(_('bzr source type could not be determined\n'))
+            self.ui.note(_(b'bzr source type could not be determined\n'))
 
     def before(self):
         """Before the conversion begins, acquire a read lock
@@ -126,16 +126,16 b' class bzr_source(common.converter_source'
                 revid = info.rev_id
             if revid is None:
                 raise error.Abort(
-                    _('%s is not a valid revision') % self.revs[0]
+                    _(b'%s is not a valid revision') % self.revs[0]
                 )
             heads = [revid]
         # Empty repositories return 'null:', which cannot be retrieved
-        heads = [h for h in heads if h != 'null:']
+        heads = [h for h in heads if h != b'null:']
         return heads
 
     def getfile(self, name, rev):
         revtree = self.sourcerepo.revision_tree(rev)
-        fileid = revtree.path2id(name.decode(self.encoding or 'utf-8'))
+        fileid = revtree.path2id(name.decode(self.encoding or b'utf-8'))
         kind = None
         if fileid is not None:
             kind = revtree.kind(fileid)
@@ -143,11 +143,11 b' class bzr_source(common.converter_source'
             # the file is not available anymore - was deleted
             return None, None
         mode = self._modecache[(name, rev)]
-        if kind == 'symlink':
+        if kind == b'symlink':
             target = revtree.get_symlink_target(fileid)
             if target is None:
                 raise error.Abort(
-                    _('%s.%s symlink has no target') % (name, rev)
+                    _(b'%s.%s symlink has no target') % (name, rev)
                 )
             return target, mode
         else:
@@ -156,7 +156,7 b' class bzr_source(common.converter_source'
 
     def getchanges(self, version, full):
         if full:
-            raise error.Abort(_("convert from cvs does not support --full"))
+            raise error.Abort(_(b"convert from cvs does not support --full"))
         self._modecache = {}
         self._revtree = self.sourcerepo.revision_tree(version)
         # get the parentids from the cache
@@ -176,12 +176,12 b' class bzr_source(common.converter_source'
             parents = self._filterghosts(rev.parent_ids)
             self._parentids[version] = parents
 
-        branch = self.recode(rev.properties.get('branch-nick', u'default'))
-        if branch == 'trunk':
-            branch = 'default'
+        branch = self.recode(rev.properties.get(b'branch-nick', u'default'))
+        if branch == b'trunk':
+            branch = b'default'
         return common.commit(
             parents=parents,
-            date='%d %d' % (rev.timestamp, -rev.timezone),
+            date=b'%d %d' % (rev.timestamp, -rev.timezone),
             author=self.recode(rev.committer),
             desc=self.recode(rev.message),
             branch=branch,
@@ -248,13 +248,13 b' class bzr_source(common.converter_source'
 
             # bazaar tracks directories, mercurial does not, so
             # we have to rename the directory contents
-            if kind[1] == 'directory':
-                if kind[0] not in (None, 'directory'):
+            if kind[1] == b'directory':
+                if kind[0] not in (None, b'directory'):
                     # Replacing 'something' with a directory, record it
                     # so it can be removed.
                     changes.append((self.recode(paths[0]), revid))
 
-                if kind[0] == 'directory' and None not in paths:
+                if kind[0] == b'directory' and None not in paths:
                     renaming = paths[0] != paths[1]
                     # neither an add nor an delete - a move
                     # rename all directory contents manually
@@ -262,9 +262,9 b' class bzr_source(common.converter_source'
                     # get all child-entries of the directory
                     for name, entry in inventory.iter_entries(subdir):
                         # hg does not track directory renames
-                        if entry.kind == 'directory':
+                        if entry.kind == b'directory':
                             continue
-                        frompath = self.recode(paths[0] + '/' + name)
+                        frompath = self.recode(paths[0] + b'/' + name)
                         if frompath in seen:
                             # Already handled by a more specific change entry
                             # This is important when you have:
@@ -275,15 +275,15 b' class bzr_source(common.converter_source'
                         seen.add(frompath)
                         if not renaming:
                             continue
-                        topath = self.recode(paths[1] + '/' + name)
+                        topath = self.recode(paths[1] + b'/' + name)
                         # register the files as changed
                         changes.append((frompath, revid))
                         changes.append((topath, revid))
                         # add to mode cache
                         mode = (
-                            (entry.executable and 'x')
-                            or (entry.kind == 'symlink' and 's')
-                            or ''
+                            (entry.executable and b'x')
+                            or (entry.kind == b'symlink' and b's')
+                            or b''
                         )
                         self._modecache[(topath, revid)] = mode
                         # register the change as move
@@ -312,7 +312,7 b' class bzr_source(common.converter_source'
 
             # populate the mode cache
             kind, executable = [e[1] for e in (kind, executable)]
-            mode = (executable and 'x') or (kind == 'symlink' and 'l') or ''
+            mode = (executable and b'x') or (kind == b'symlink' and b'l') or b''
             self._modecache[(topath, revid)] = mode
             changes.append((topath, revid))
 

hgext/convert/common.py

@@ -46,7 +46,7 b' class _shlexpy3proxy(object):'
 
     @property
     def infile(self):
-        return self._l.infile or '<unknown>'
+        return self._l.infile or b'<unknown>'
 
     @property
     def lineno(self):
@@ -56,13 +56,13 b' class _shlexpy3proxy(object):'
 def shlexer(data=None, filepath=None, wordchars=None, whitespace=None):
     if data is None:
         if pycompat.ispy3:
-            data = open(filepath, 'r', encoding=r'latin1')
+            data = open(filepath, b'r', encoding=r'latin1')
         else:
-            data = open(filepath, 'r')
+            data = open(filepath, b'r')
     else:
         if filepath is not None:
             raise error.ProgrammingError(
-                'shlexer only accepts data or filepath, not both'
+                b'shlexer only accepts data or filepath, not both'
             )
         if pycompat.ispy3:
             data = data.decode('latin1')
@@ -87,7 +87,7 b' def encodeargs(args):'
     def encodearg(s):
         lines = base64.encodestring(s)
         lines = [l.splitlines()[0] for l in lines]
-        return ''.join(lines)
+        return b''.join(lines)
 
     s = pickle.dumps(args)
     return encodearg(s)
@@ -109,14 +109,14 b' def checktool(exe, name=None, abort=True'
             exc = error.Abort
         else:
             exc = MissingTool
-        raise exc(_('cannot find required "%s" tool') % name)
+        raise exc(_(b'cannot find required "%s" tool') % name)
 
 
 class NoRepo(Exception):
     pass
 
 
-SKIPREV = 'SKIP'
+SKIPREV = b'SKIP'
 
 
 class commit(object):
@@ -135,8 +135,8 b' class commit(object):'
         optparents=None,
         ctx=None,
     ):
-        self.author = author or 'unknown'
-        self.date = date or '0 0'
+        self.author = author or b'unknown'
+        self.date = date or b'0 0'
         self.desc = desc
         self.parents = parents  # will be converted and used as parents
         self.optparents = optparents or []  # will be used if already converted
@@ -160,15 +160,15 b' class converter_source(object):'
         self.revs = revs
         self.repotype = repotype
 
-        self.encoding = 'utf-8'
+        self.encoding = b'utf-8'
 
-    def checkhexformat(self, revstr, mapname='splicemap'):
+    def checkhexformat(self, revstr, mapname=b'splicemap'):
         """ fails if revstr is not a 40 byte hex. mercurial and git both uses
             such format for their revision numbering
         """
         if not re.match(br'[0-9a-fA-F]{40,40}$', revstr):
             raise error.Abort(
-                _('%s entry %s is not a valid revision' ' identifier')
+                _(b'%s entry %s is not a valid revision' b' identifier')
                 % (mapname, revstr)
             )
 
@@ -236,7 +236,7 b' class converter_source(object):'
 
     def recode(self, s, encoding=None):
         if not encoding:
-            encoding = self.encoding or 'utf-8'
+            encoding = self.encoding or b'utf-8'
 
         if isinstance(s, pycompat.unicode):
             return s.encode("utf-8")
@@ -292,7 +292,7 b' class converter_source(object):'
         """
         return {}
 
-    def checkrevformat(self, revstr, mapname='splicemap'):
+    def checkrevformat(self, revstr, mapname=b'splicemap'):
         """revstr is a string that describes a revision in the given
            source control system.  Return true if revstr has correct
            format.
@@ -412,20 +412,20 b' class commandline(object):'
         cmdline = [self.command, cmd] + list(args)
         for k, v in kwargs.iteritems():
             if len(k) == 1:
-                cmdline.append('-' + k)
+                cmdline.append(b'-' + k)
             else:
-                cmdline.append('--' + k.replace('_', '-'))
+                cmdline.append(b'--' + k.replace(b'_', b'-'))
             try:
                 if len(k) == 1:
-                    cmdline.append('' + v)
+                    cmdline.append(b'' + v)
                 else:
-                    cmdline[-1] += '=' + v
+                    cmdline[-1] += b'=' + v
             except TypeError:
                 pass
         cmdline = [procutil.shellquote(arg) for arg in cmdline]
         if not self.ui.debugflag:
-            cmdline += ['2>', pycompat.bytestr(os.devnull)]
-        cmdline = ' '.join(cmdline)
+            cmdline += [b'2>', pycompat.bytestr(os.devnull)]
+        cmdline = b' '.join(cmdline)
         return cmdline
 
     def _run(self, cmd, *args, **kwargs):
@@ -449,7 +449,7 b' class commandline(object):'
 
     def _dorun(self, openfunc, cmd, *args, **kwargs):
         cmdline = self._cmdline(cmd, *args, **kwargs)
-        self.ui.debug('running: %s\n' % (cmdline,))
+        self.ui.debug(b'running: %s\n' % (cmdline,))
         self.prerun()
         try:
             return openfunc(cmdline)
@@ -466,16 +466,16 b' class commandline(object):'
         p = self._run(cmd, *args, **kwargs)
         output = p.stdout.readlines()
         p.wait()
-        self.ui.debug(''.join(output))
+        self.ui.debug(b''.join(output))
         return output, p.returncode
 
-    def checkexit(self, status, output=''):
+    def checkexit(self, status, output=b''):
         if status:
             if output:
-                self.ui.warn(_('%s error:\n') % self.command)
+                self.ui.warn(_(b'%s error:\n') % self.command)
                 self.ui.warn(output)
             msg = procutil.explainexit(status)
-            raise error.Abort('%s %s' % (self.command, msg))
+            raise error.Abort(b'%s %s' % (self.command, msg))
 
     def run0(self, cmd, *args, **kwargs):
         output, status = self.run(cmd, *args, **kwargs)
@@ -484,7 +484,7 b' class commandline(object):'
 
     def runlines0(self, cmd, *args, **kwargs):
         output, status = self.runlines(cmd, *args, **kwargs)
-        self.checkexit(status, ''.join(output))
+        self.checkexit(status, b''.join(output))
         return output
 
     @propertycache
@@ -540,7 +540,7 b' class mapfile(dict):'
         if not self.path:
             return
         try:
-            fp = open(self.path, 'rb')
+            fp = open(self.path, b'rb')
         except IOError as err:
             if err.errno != errno.ENOENT:
                 raise
@@ -551,10 +551,10 b' class mapfile(dict):'
                 # Ignore blank lines
                 continue
             try:
-                key, value = line.rsplit(' ', 1)
+                key, value = line.rsplit(b' ', 1)
             except ValueError:
                 raise error.Abort(
-                    _('syntax error in %s(%d): key/value pair expected')
+                    _(b'syntax error in %s(%d): key/value pair expected')
                     % (self.path, i + 1)
                 )
             if key not in self:
@@ -565,13 +565,13 b' class mapfile(dict):'
     def __setitem__(self, key, value):
         if self.fp is None:
             try:
-                self.fp = open(self.path, 'ab')
+                self.fp = open(self.path, b'ab')
             except IOError as err:
                 raise error.Abort(
-                    _('could not open map file %r: %s')
+                    _(b'could not open map file %r: %s')
                     % (self.path, encoding.strtolocal(err.strerror))
                 )
-        self.fp.write(util.tonativeeol('%s %s\n' % (key, value)))
+        self.fp.write(util.tonativeeol(b'%s %s\n' % (key, value)))
         self.fp.flush()
         super(mapfile, self).__setitem__(key, value)
 

hgext/convert/convcmd.py

@@ -52,7 +52,7 b' p4_source = p4.p4_source'
 svn_sink = subversion.svn_sink
 svn_source = subversion.svn_source
 
-orig_encoding = 'ascii'
+orig_encoding = b'ascii'
 
 
 def recode(s):
@@ -90,36 +90,36 b' def mapbranch(branch, branchmap):'
     # destination repository. For such commits, using a literal "default"
     # in branchmap below allows the user to map "default" to an alternate
     # default branch in the destination repository.
-    branch = branchmap.get(branch or 'default', branch)
+    branch = branchmap.get(branch or b'default', branch)
     # At some point we used "None" literal to denote the default branch,
     # attempt to use that for backward compatibility.
     if not branch:
-        branch = branchmap.get('None', branch)
+        branch = branchmap.get(b'None', branch)
     return branch
 
 
 source_converters = [
-    ('cvs', convert_cvs, 'branchsort'),
-    ('git', convert_git, 'branchsort'),
-    ('svn', svn_source, 'branchsort'),
-    ('hg', mercurial_source, 'sourcesort'),
-    ('darcs', darcs_source, 'branchsort'),
-    ('mtn', monotone_source, 'branchsort'),
-    ('gnuarch', gnuarch_source, 'branchsort'),
-    ('bzr', bzr_source, 'branchsort'),
-    ('p4', p4_source, 'branchsort'),
+    (b'cvs', convert_cvs, b'branchsort'),
+    (b'git', convert_git, b'branchsort'),
+    (b'svn', svn_source, b'branchsort'),
+    (b'hg', mercurial_source, b'sourcesort'),
+    (b'darcs', darcs_source, b'branchsort'),
+    (b'mtn', monotone_source, b'branchsort'),
+    (b'gnuarch', gnuarch_source, b'branchsort'),
+    (b'bzr', bzr_source, b'branchsort'),
+    (b'p4', p4_source, b'branchsort'),
 ]
 
 sink_converters = [
-    ('hg', mercurial_sink),
-    ('svn', svn_sink),
+    (b'hg', mercurial_sink),
+    (b'svn', svn_sink),
 ]
 
 
 def convertsource(ui, path, type, revs):
     exceptions = []
     if type and type not in [s[0] for s in source_converters]:
-        raise error.Abort(_('%s: invalid source repository type') % type)
+        raise error.Abort(_(b'%s: invalid source repository type') % type)
     for name, source, sortmode in source_converters:
         try:
             if not type or name == type:
@@ -128,22 +128,22 b' def convertsource(ui, path, type, revs):'
             exceptions.append(inst)
     if not ui.quiet:
         for inst in exceptions:
-            ui.write("%s\n" % pycompat.bytestr(inst.args[0]))
-    raise error.Abort(_('%s: missing or unsupported repository') % path)
+            ui.write(b"%s\n" % pycompat.bytestr(inst.args[0]))
+    raise error.Abort(_(b'%s: missing or unsupported repository') % path)
 
 
 def convertsink(ui, path, type):
     if type and type not in [s[0] for s in sink_converters]:
-        raise error.Abort(_('%s: invalid destination repository type') % type)
+        raise error.Abort(_(b'%s: invalid destination repository type') % type)
     for name, sink in sink_converters:
         try:
             if not type or name == type:
                 return sink(ui, name, path)
         except NoRepo as inst:
-            ui.note(_("convert: %s\n") % inst)
+            ui.note(_(b"convert: %s\n") % inst)
         except MissingTool as inst:
-            raise error.Abort('%s\n' % inst)
-    raise error.Abort(_('%s: unknown repository type') % path)
+            raise error.Abort(b'%s\n' % inst)
+    raise error.Abort(_(b'%s: unknown repository type') % path)
 
 
 class progresssource(object):
@@ -151,7 +151,7 b' class progresssource(object):'
         self.ui = ui
         self.source = source
         self.progress = ui.makeprogress(
-            _('getting files'), unit=_('files'), total=filecount
+            _(b'getting files'), unit=_(b'files'), total=filecount
         )
 
     def getfile(self, file, rev):
@@ -189,12 +189,12 b' class converter(object):'
         if authorfile and os.path.exists(authorfile):
             self.readauthormap(authorfile)
         # Extend/Override with new author map if necessary
-        if opts.get('authormap'):
-            self.readauthormap(opts.get('authormap'))
+        if opts.get(b'authormap'):
+            self.readauthormap(opts.get(b'authormap'))
             self.authorfile = self.dest.authorfile()
 
-        self.splicemap = self.parsesplicemap(opts.get('splicemap'))
-        self.branchmap = mapfile(ui, opts.get('branchmap'))
+        self.splicemap = self.parsesplicemap(opts.get(b'splicemap'))
+        self.branchmap = mapfile(ui, opts.get(b'branchmap'))
 
     def parsesplicemap(self, path):
         """ check and validate the splicemap format and
@@ -211,21 +211,21 b' class converter(object):'
             return {}
         m = {}
         try:
-            fp = open(path, 'rb')
+            fp = open(path, b'rb')
             for i, line in enumerate(util.iterfile(fp)):
                 line = line.splitlines()[0].rstrip()
                 if not line:
                     # Ignore blank lines
                     continue
                 # split line
-                lex = common.shlexer(data=line, whitespace=',')
+                lex = common.shlexer(data=line, whitespace=b',')
                 line = list(lex)
                 # check number of parents
                 if not (2 <= len(line) <= 3):
                     raise error.Abort(
                         _(
-                            'syntax error in %s(%d): child parent1'
-                            '[,parent2] expected'
+                            b'syntax error in %s(%d): child parent1'
+                            b'[,parent2] expected'
                         )
                         % (path, i + 1)
                     )
@@ -239,7 +239,7 b' class converter(object):'
         # if file does not exist or error reading, exit
         except IOError:
             raise error.Abort(
-                _('splicemap file not found or error reading %s:') % path
+                _(b'splicemap file not found or error reading %s:') % path
             )
         return m
 
@@ -251,7 +251,7 b' class converter(object):'
         parents = {}
         numcommits = self.source.numcommits()
         progress = self.ui.makeprogress(
-            _('scanning'), unit=_('revisions'), total=numcommits
+            _(b'scanning'), unit=_(b'revisions'), total=numcommits
         )
         while visit:
             n = visit.pop(0)
@@ -283,8 +283,8 b' class converter(object):'
                     # Could be in source but not converted during this run
                     self.ui.warn(
                         _(
-                            'splice map revision %s is not being '
-                            'converted, ignoring\n'
+                            b'splice map revision %s is not being '
+                            b'converted, ignoring\n'
                         )
                         % c
                     )
@@ -296,7 +296,7 b' class converter(object):'
                     continue
                 # Parent is not in dest and not being converted, not good
                 if p not in parents:
-                    raise error.Abort(_('unknown splice map parent: %s') % p)
+                    raise error.Abort(_(b'unknown splice map parent: %s') % p)
                 pc.append(p)
             parents[c] = pc
 
@@ -369,7 +369,7 b' class converter(object):'
         def makeclosesorter():
             """Close order sort."""
             keyfn = lambda n: (
-                'close' not in self.commitcache[n].extra,
+                b'close' not in self.commitcache[n].extra,
                 self.commitcache[n].sortkey,
             )
 
@@ -392,16 +392,16 b' class converter(object):'
 
             return picknext
 
-        if sortmode == 'branchsort':
+        if sortmode == b'branchsort':
             picknext = makebranchsorter()
-        elif sortmode == 'datesort':
+        elif sortmode == b'datesort':
             picknext = makedatesorter()
-        elif sortmode == 'sourcesort':
+        elif sortmode == b'sourcesort':
             picknext = makesourcesorter()
-        elif sortmode == 'closesort':
+        elif sortmode == b'closesort':
             picknext = makeclosesorter()
         else:
-            raise error.Abort(_('unknown sort mode: %s') % sortmode)
+            raise error.Abort(_(b'unknown sort mode: %s') % sortmode)
 
         children, actives = mapchildren(parents)
 
@@ -420,7 +420,7 b' class converter(object):'
                     pendings[c].remove(n)
                 except ValueError:
                     raise error.Abort(
-                        _('cycle detected between %s and %s')
+                        _(b'cycle detected between %s and %s')
                         % (recode(c), recode(n))
                     )
                 if not pendings[c]:
@@ -429,45 +429,47 b' class converter(object):'
                     pendings[c] = None
 
         if len(s) != len(parents):
-            raise error.Abort(_("not all revisions were sorted"))
+            raise error.Abort(_(b"not all revisions were sorted"))
 
         return s
 
     def writeauthormap(self):
         authorfile = self.authorfile
         if authorfile:
-            self.ui.status(_('writing author map file %s\n') % authorfile)
-            ofile = open(authorfile, 'wb+')
+            self.ui.status(_(b'writing author map file %s\n') % authorfile)
+            ofile = open(authorfile, b'wb+')
             for author in self.authors:
                 ofile.write(
-                    util.tonativeeol("%s=%s\n" % (author, self.authors[author]))
+                    util.tonativeeol(
+                        b"%s=%s\n" % (author, self.authors[author])
+                    )
                 )
             ofile.close()
 
     def readauthormap(self, authorfile):
-        afile = open(authorfile, 'rb')
+        afile = open(authorfile, b'rb')
         for line in afile:
 
             line = line.strip()
-            if not line or line.startswith('#'):
+            if not line or line.startswith(b'#'):
                 continue
 
             try:
-                srcauthor, dstauthor = line.split('=', 1)
+                srcauthor, dstauthor = line.split(b'=', 1)
             except ValueError:
-                msg = _('ignoring bad line in author map file %s: %s\n')
+                msg = _(b'ignoring bad line in author map file %s: %s\n')
                 self.ui.warn(msg % (authorfile, line.rstrip()))
                 continue
 
             srcauthor = srcauthor.strip()
             dstauthor = dstauthor.strip()
             if self.authors.get(srcauthor) in (None, dstauthor):
-                msg = _('mapping author %s to %s\n')
+                msg = _(b'mapping author %s to %s\n')
                 self.ui.debug(msg % (srcauthor, dstauthor))
                 self.authors[srcauthor] = dstauthor
                 continue
 
-            m = _('overriding mapping for author %s, was %s, will be %s\n')
+            m = _(b'overriding mapping for author %s, was %s, will be %s\n')
             self.ui.status(m % (srcauthor, self.authors[srcauthor], dstauthor))
 
         afile.close()
@@ -481,7 +483,7 b' class converter(object):'
 
     def copy(self, rev):
         commit = self.commitcache[rev]
-        full = self.opts.get('full')
+        full = self.opts.get(b'full')
         changes = self.source.getchanges(rev, full)
         if isinstance(changes, bytes):
             if changes == SKIPREV:
@@ -503,8 +505,8 b' class converter(object):'
         try:
             parents = self.splicemap[rev]
             self.ui.status(
-                _('spliced in %s as parents of %s\n')
-                % (_(' and ').join(parents), rev)
+                _(b'spliced in %s as parents of %s\n')
+                % (_(b' and ').join(parents), rev)
             )
             parents = [self.map.get(p, p) for p in parents]
         except KeyError:
@@ -536,34 +538,34 b' class converter(object):'
             self.source.before()
             self.dest.before()
             self.source.setrevmap(self.map)
-            self.ui.status(_("scanning source...\n"))
+            self.ui.status(_(b"scanning source...\n"))
             heads = self.source.getheads()
             parents = self.walktree(heads)
             self.mergesplicemap(parents, self.splicemap)
-            self.ui.status(_("sorting...\n"))
+            self.ui.status(_(b"sorting...\n"))
             t = self.toposort(parents, sortmode)
             num = len(t)
             c = None
 
-            self.ui.status(_("converting...\n"))
+            self.ui.status(_(b"converting...\n"))
             progress = self.ui.makeprogress(
-                _('converting'), unit=_('revisions'), total=len(t)
+                _(b'converting'), unit=_(b'revisions'), total=len(t)
             )
             for i, c in enumerate(t):
                 num -= 1
                 desc = self.commitcache[c].desc
-                if "\n" in desc:
+                if b"\n" in desc:
                     desc = desc.splitlines()[0]
                 # convert log message to local encoding without using
                 # tolocal() because the encoding.encoding convert()
                 # uses is 'utf-8'
-                self.ui.status("%d %s\n" % (num, recode(desc)))
-                self.ui.note(_("source: %s\n") % recode(c))
+                self.ui.status(b"%d %s\n" % (num, recode(desc)))
+                self.ui.note(_(b"source: %s\n") % recode(c))
                 progress.update(i)
                 self.copy(c)
             progress.complete()
 
-            if not self.ui.configbool('convert', 'skiptags'):
+            if not self.ui.configbool(b'convert', b'skiptags'):
                 tags = self.source.gettags()
                 ctags = {}
                 for k in tags:
@@ -610,45 +612,47 b' def convert(ui, src, dest=None, revmapfi'
     opts = pycompat.byteskwargs(opts)
     global orig_encoding
     orig_encoding = encoding.encoding
-    encoding.encoding = 'UTF-8'
+    encoding.encoding = b'UTF-8'
 
     # support --authors as an alias for --authormap
-    if not opts.get('authormap'):
-        opts['authormap'] = opts.get('authors')
+    if not opts.get(b'authormap'):
+        opts[b'authormap'] = opts.get(b'authors')
 
     if not dest:
-        dest = hg.defaultdest(src) + "-hg"
-        ui.status(_("assuming destination %s\n") % dest)
+        dest = hg.defaultdest(src) + b"-hg"
+        ui.status(_(b"assuming destination %s\n") % dest)
 
-    destc = convertsink(ui, dest, opts.get('dest_type'))
+    destc = convertsink(ui, dest, opts.get(b'dest_type'))
     destc = scmutil.wrapconvertsink(destc)
 
     try:
         srcc, defaultsort = convertsource(
-            ui, src, opts.get('source_type'), opts.get('rev')
+            ui, src, opts.get(b'source_type'), opts.get(b'rev')
         )
     except Exception:
         for path in destc.created:
             shutil.rmtree(path, True)
         raise
 
-    sortmodes = ('branchsort', 'datesort', 'sourcesort', 'closesort')
+    sortmodes = (b'branchsort', b'datesort', b'sourcesort', b'closesort')
     sortmode = [m for m in sortmodes if opts.get(m)]
     if len(sortmode) > 1:
-        raise error.Abort(_('more than one sort mode specified'))
+        raise error.Abort(_(b'more than one sort mode specified'))
     if sortmode:
         sortmode = sortmode[0]
     else:
         sortmode = defaultsort
 
-    if sortmode == 'sourcesort' and not srcc.hasnativeorder():
+    if sortmode == b'sourcesort' and not srcc.hasnativeorder():
         raise error.Abort(
-            _('--sourcesort is not supported by this data source')
+            _(b'--sourcesort is not supported by this data source')
         )
-    if sortmode == 'closesort' and not srcc.hasnativeclose():
-        raise error.Abort(_('--closesort is not supported by this data source'))
+    if sortmode == b'closesort' and not srcc.hasnativeclose():
+        raise error.Abort(
+            _(b'--closesort is not supported by this data source')
+        )
 
-    fmap = opts.get('filemap')
+    fmap = opts.get(b'filemap')
     if fmap:
         srcc = filemap.filemap_source(ui, srcc, fmap)
         destc.setfilemapmode(True)

hgext/convert/cvs.py

@@ -39,19 +39,19 b' class convert_cvs(converter_source):'
     def __init__(self, ui, repotype, path, revs=None):
         super(convert_cvs, self).__init__(ui, repotype, path, revs=revs)
 
-        cvs = os.path.join(path, "CVS")
+        cvs = os.path.join(path, b"CVS")
         if not os.path.exists(cvs):
-            raise NoRepo(_("%s does not look like a CVS checkout") % path)
+            raise NoRepo(_(b"%s does not look like a CVS checkout") % path)
 
-        checktool('cvs')
+        checktool(b'cvs')
 
         self.changeset = None
         self.files = {}
         self.tags = {}
         self.lastbranch = {}
         self.socket = None
-        self.cvsroot = open(os.path.join(cvs, "Root"), 'rb').read()[:-1]
-        self.cvsrepo = open(os.path.join(cvs, "Repository"), 'rb').read()[:-1]
+        self.cvsroot = open(os.path.join(cvs, b"Root"), b'rb').read()[:-1]
+        self.cvsrepo = open(os.path.join(cvs, b"Repository"), b'rb').read()[:-1]
         self.encoding = encoding.encoding
 
         self._connect()
@@ -65,7 +65,10 b' class convert_cvs(converter_source):'
         if self.revs:
             if len(self.revs) > 1:
                 raise error.Abort(
-                    _('cvs source does not support specifying ' 'multiple revs')
+                    _(
+                        b'cvs source does not support specifying '
+                        b'multiple revs'
+                    )
                 )
             # TODO: handle tags
             try:
@@ -73,23 +76,23 b' class convert_cvs(converter_source):'
                 maxrev = int(self.revs[0])
             except ValueError:
                 raise error.Abort(
-                    _('revision %s is not a patchset number') % self.revs[0]
+                    _(b'revision %s is not a patchset number') % self.revs[0]
                 )
 
         d = encoding.getcwd()
         try:
             os.chdir(self.path)
 
-            cache = 'update'
-            if not self.ui.configbool('convert', 'cvsps.cache'):
+            cache = b'update'
+            if not self.ui.configbool(b'convert', b'cvsps.cache'):
                 cache = None
             db = cvsps.createlog(self.ui, cache=cache)
             db = cvsps.createchangeset(
                 self.ui,
                 db,
-                fuzz=int(self.ui.config('convert', 'cvsps.fuzz')),
-                mergeto=self.ui.config('convert', 'cvsps.mergeto'),
-                mergefrom=self.ui.config('convert', 'cvsps.mergefrom'),
+                fuzz=int(self.ui.config(b'convert', b'cvsps.fuzz')),
+                mergeto=self.ui.config(b'convert', b'cvsps.mergeto'),
+                mergefrom=self.ui.config(b'convert', b'cvsps.mergefrom'),
             )
 
             for cs in db:
@@ -99,16 +102,16 b' class convert_cvs(converter_source):'
                 cs.author = self.recode(cs.author)
                 self.lastbranch[cs.branch] = id
                 cs.comment = self.recode(cs.comment)
-                if self.ui.configbool('convert', 'localtimezone'):
+                if self.ui.configbool(b'convert', b'localtimezone'):
                     cs.date = makedatetimestamp(cs.date[0])
-                date = dateutil.datestr(cs.date, '%Y-%m-%d %H:%M:%S %1%2')
+                date = dateutil.datestr(cs.date, b'%Y-%m-%d %H:%M:%S %1%2')
                 self.tags.update(dict.fromkeys(cs.tags, id))
 
                 files = {}
                 for f in cs.entries:
-                    files[f.file] = "%s%s" % (
-                        '.'.join([(b"%d" % x) for x in f.revision]),
-                        ['', '(DEAD)'][f.dead],
+                    files[f.file] = b"%s%s" % (
+                        b'.'.join([(b"%d" % x) for x in f.revision]),
+                        [b'', b'(DEAD)'][f.dead],
                     )
 
                 # add current commit to set
@@ -117,7 +120,7 b' class convert_cvs(converter_source):'
                     date=date,
                     parents=[(b"%d" % p.id) for p in cs.parents],
                     desc=cs.comment,
-                    branch=cs.branch or '',
+                    branch=cs.branch or b'',
                 )
                 self.changeset[id] = c
                 self.files[id] = files
@@ -130,38 +133,38 b' class convert_cvs(converter_source):'
         root = self.cvsroot
         conntype = None
         user, host = None, None
-        cmd = ['cvs', 'server']
+        cmd = [b'cvs', b'server']
 
-        self.ui.status(_("connecting to %s\n") % root)
+        self.ui.status(_(b"connecting to %s\n") % root)
 
-        if root.startswith(":pserver:"):
+        if root.startswith(b":pserver:"):
             root = root[9:]
             m = re.match(
                 r'(?:(.*?)(?::(.*?))?@)?([^:\/]*)(?::(\d*))?(.*)', root
             )
             if m:
-                conntype = "pserver"
+                conntype = b"pserver"
                 user, passw, serv, port, root = m.groups()
                 if not user:
-                    user = "anonymous"
+                    user = b"anonymous"
                 if not port:
                     port = 2401
                 else:
                     port = int(port)
-                format0 = ":pserver:%s@%s:%s" % (user, serv, root)
-                format1 = ":pserver:%s@%s:%d%s" % (user, serv, port, root)
+                format0 = b":pserver:%s@%s:%s" % (user, serv, root)
+                format1 = b":pserver:%s@%s:%d%s" % (user, serv, port, root)
 
                 if not passw:
-                    passw = "A"
-                    cvspass = os.path.expanduser("~/.cvspass")
+                    passw = b"A"
+                    cvspass = os.path.expanduser(b"~/.cvspass")
                     try:
-                        pf = open(cvspass, 'rb')
+                        pf = open(cvspass, b'rb')
                         for line in pf.read().splitlines():
-                            part1, part2 = line.split(' ', 1)
+                            part1, part2 = line.split(b' ', 1)
                             # /1 :pserver:[e-mail]:2401/cvsroot/foo
                             # Ah<Z
-                            if part1 == '/1':
-                                part1, part2 = part2.split(' ', 1)
+                            if part1 == b'/1':
+                                part1, part2 = part2.split(b' ', 1)
                                 format = format1
                             # :pserver:[e-mail]:/cvsroot/foo Ah<Z
                             else:
@@ -179,72 +182,72 b' class convert_cvs(converter_source):'
                 sck = socket.socket()
                 sck.connect((serv, port))
                 sck.send(
-                    "\n".join(
+                    b"\n".join(
                         [
-                            "BEGIN AUTH REQUEST",
+                            b"BEGIN AUTH REQUEST",
                             root,
                             user,
                             passw,
-                            "END AUTH REQUEST",
-                            "",
+                            b"END AUTH REQUEST",
+                            b"",
                         ]
                     )
                 )
-                if sck.recv(128) != "I LOVE YOU\n":
-                    raise error.Abort(_("CVS pserver authentication failed"))
+                if sck.recv(128) != b"I LOVE YOU\n":
+                    raise error.Abort(_(b"CVS pserver authentication failed"))
 
-                self.writep = self.readp = sck.makefile('r+')
+                self.writep = self.readp = sck.makefile(b'r+')
 
-        if not conntype and root.startswith(":local:"):
-            conntype = "local"
+        if not conntype and root.startswith(b":local:"):
+            conntype = b"local"
             root = root[7:]
 
         if not conntype:
             # :ext:user@host/home/user/path/to/cvsroot
-            if root.startswith(":ext:"):
+            if root.startswith(b":ext:"):
                 root = root[5:]
             m = re.match(br'(?:([^@:/]+)@)?([^:/]+):?(.*)', root)
             # Do not take Windows path "c:\foo\bar" for a connection strings
             if os.path.isdir(root) or not m:
-                conntype = "local"
+                conntype = b"local"
             else:
-                conntype = "rsh"
+                conntype = b"rsh"
                 user, host, root = m.group(1), m.group(2), m.group(3)
 
-        if conntype != "pserver":
-            if conntype == "rsh":
-                rsh = encoding.environ.get("CVS_RSH") or "ssh"
+        if conntype != b"pserver":
+            if conntype == b"rsh":
+                rsh = encoding.environ.get(b"CVS_RSH") or b"ssh"
                 if user:
-                    cmd = [rsh, '-l', user, host] + cmd
+                    cmd = [rsh, b'-l', user, host] + cmd
                 else:
                     cmd = [rsh, host] + cmd
 
             # popen2 does not support argument lists under Windows
             cmd = [procutil.shellquote(arg) for arg in cmd]
-            cmd = procutil.quotecommand(' '.join(cmd))
+            cmd = procutil.quotecommand(b' '.join(cmd))
             self.writep, self.readp = procutil.popen2(cmd)
 
         self.realroot = root
 
-        self.writep.write("Root %s\n" % root)
+        self.writep.write(b"Root %s\n" % root)
         self.writep.write(
-            "Valid-responses ok error Valid-requests Mode"
-            " M Mbinary E Checked-in Created Updated"
-            " Merged Removed\n"
+            b"Valid-responses ok error Valid-requests Mode"
+            b" M Mbinary E Checked-in Created Updated"
+            b" Merged Removed\n"
         )
-        self.writep.write("valid-requests\n")
+        self.writep.write(b"valid-requests\n")
         self.writep.flush()
         r = self.readp.readline()
-        if not r.startswith("Valid-requests"):
+        if not r.startswith(b"Valid-requests"):
             raise error.Abort(
                 _(
-                    'unexpected response from CVS server '
-                    '(expected "Valid-requests", but got %r)'
+                    b'unexpected response from CVS server '
+                    b'(expected "Valid-requests", but got %r)'
                 )
                 % r
             )
-        if "UseUnchanged" in r:
-            self.writep.write("UseUnchanged\n")
+        if b"UseUnchanged" in r:
+            self.writep.write(b"UseUnchanged\n")
             self.writep.flush()
             self.readp.readline()
 
@@ -262,55 +265,55 b' class convert_cvs(converter_source):'
                 data = fp.read(min(count, chunksize))
                 if not data:
                     raise error.Abort(
-                        _("%d bytes missing from remote file") % count
+                        _(b"%d bytes missing from remote file") % count
                     )
                 count -= len(data)
                 output.write(data)
             return output.getvalue()
 
         self._parse()
-        if rev.endswith("(DEAD)"):
+        if rev.endswith(b"(DEAD)"):
             return None, None
 
-        args = ("-N -P -kk -r %s --" % rev).split()
-        args.append(self.cvsrepo + '/' + name)
+        args = (b"-N -P -kk -r %s --" % rev).split()
+        args.append(self.cvsrepo + b'/' + name)
         for x in args:
-            self.writep.write("Argument %s\n" % x)
-        self.writep.write("Directory .\n%s\nco\n" % self.realroot)
+            self.writep.write(b"Argument %s\n" % x)
+        self.writep.write(b"Directory .\n%s\nco\n" % self.realroot)
         self.writep.flush()
 
-        data = ""
+        data = b""
         mode = None
         while True:
             line = self.readp.readline()
-            if line.startswith("Created ") or line.startswith("Updated "):
+            if line.startswith(b"Created ") or line.startswith(b"Updated "):
                 self.readp.readline()  # path
                 self.readp.readline()  # entries
                 mode = self.readp.readline()[:-1]
                 count = int(self.readp.readline()[:-1])
                 data = chunkedread(self.readp, count)
-            elif line.startswith(" "):
+            elif line.startswith(b" "):
                 data += line[1:]
-            elif line.startswith("M "):
+            elif line.startswith(b"M "):
                 pass
-            elif line.startswith("Mbinary "):
+            elif line.startswith(b"Mbinary "):
                 count = int(self.readp.readline()[:-1])
                 data = chunkedread(self.readp, count)
             else:
-                if line == "ok\n":
+                if line == b"ok\n":
                     if mode is None:
-                        raise error.Abort(_('malformed response from CVS'))
-                    return (data, "x" in mode and "x" or "")
-                elif line.startswith("E "):
-                    self.ui.warn(_("cvs server: %s\n") % line[2:])
-                elif line.startswith("Remove"):
+                        raise error.Abort(_(b'malformed response from CVS'))
+                    return (data, b"x" in mode and b"x" or b"")
+                elif line.startswith(b"E "):
+                    self.ui.warn(_(b"cvs server: %s\n") % line[2:])
+                elif line.startswith(b"Remove"):
                     self.readp.readline()
                 else:
-                    raise error.Abort(_("unknown CVS response: %s") % line)
+                    raise error.Abort(_(b"unknown CVS response: %s") % line)
 
     def getchanges(self, rev, full):
         if full:
-            raise error.Abort(_("convert from cvs does not support --full"))
+            raise error.Abort(_(b"convert from cvs does not support --full"))
         self._parse()
         return sorted(self.files[rev].iteritems()), {}, set()
 

hgext/convert/cvsps.py

@@ -92,18 +92,18 b' def getrepopath(cvspath):'
     # of the '/' char after the '@' is located. The solution is the rest of the
     # string after that '/' sign including it
 
-    parts = cvspath.split(':')
-    atposition = parts[-1].find('@')
+    parts = cvspath.split(b':')
+    atposition = parts[-1].find(b'@')
     start = 0
 
     if atposition != -1:
         start = atposition
 
-    repopath = parts[-1][parts[-1].find('/', start) :]
+    repopath = parts[-1][parts[-1].find(b'/', start) :]
     return repopath
 
 
-def createlog(ui, directory=None, root="", rlog=True, cache=None):
+def createlog(ui, directory=None, root=b"", rlog=True, cache=None):
     '''Collect the CVS rlog'''
 
     # Because we store many duplicate commit log messages, reusing strings
@@ -111,10 +111,10 b' def createlog(ui, directory=None, root="'
     _scache = {}
 
     def scache(s):
-        "return a shared version of a string"
+        b"return a shared version of a string"
         return _scache.setdefault(s, s)
 
-    ui.status(_('collecting CVS rlog\n'))
+    ui.status(_(b'collecting CVS rlog\n'))
 
     log = []  # list of logentry objects containing the CVS state
 
@@ -144,39 +144,39 b' def createlog(ui, directory=None, root="'
 
     file_added_re = re.compile(br'file [^/]+ was (initially )?added on branch')
 
-    prefix = ''  # leading path to strip of what we get from CVS
+    prefix = b''  # leading path to strip of what we get from CVS
 
     if directory is None:
         # Current working directory
 
         # Get the real directory in the repository
         try:
-            with open(os.path.join(b'CVS', b'Repository'), 'rb') as f:
+            with open(os.path.join(b'CVS', b'Repository'), b'rb') as f:
                 prefix = f.read().strip()
             directory = prefix
-            if prefix == ".":
-                prefix = ""
+            if prefix == b".":
+                prefix = b""
         except IOError:
-            raise logerror(_('not a CVS sandbox'))
+            raise logerror(_(b'not a CVS sandbox'))
 
         if prefix and not prefix.endswith(pycompat.ossep):
             prefix += pycompat.ossep
 
         # Use the Root file in the sandbox, if it exists
         try:
-            root = open(os.path.join('CVS', 'Root'), 'rb').read().strip()
+            root = open(os.path.join(b'CVS', b'Root'), b'rb').read().strip()
         except IOError:
             pass
 
     if not root:
-        root = encoding.environ.get('CVSROOT', '')
+        root = encoding.environ.get(b'CVSROOT', b'')
 
     # read log cache if one exists
     oldlog = []
     date = None
 
     if cache:
-        cachedir = os.path.expanduser('~/.hg.cvsps')
+        cachedir = os.path.expanduser(b'~/.hg.cvsps')
         if not os.path.exists(cachedir):
             os.mkdir(cachedir)
 
@@ -189,50 +189,50 b' def createlog(ui, directory=None, root="'
         # and
         #    /pserver/user/server/path
         # are mapped to different cache file names.
-        cachefile = root.split(":") + [directory, "cache"]
-        cachefile = ['-'.join(re.findall(br'\w+', s)) for s in cachefile if s]
+        cachefile = root.split(b":") + [directory, b"cache"]
+        cachefile = [b'-'.join(re.findall(br'\w+', s)) for s in cachefile if s]
         cachefile = os.path.join(
-            cachedir, '.'.join([s for s in cachefile if s])
+            cachedir, b'.'.join([s for s in cachefile if s])
         )
 
-    if cache == 'update':
+    if cache == b'update':
         try:
-            ui.note(_('reading cvs log cache %s\n') % cachefile)
-            oldlog = pickle.load(open(cachefile, 'rb'))
+            ui.note(_(b'reading cvs log cache %s\n') % cachefile)
+            oldlog = pickle.load(open(cachefile, b'rb'))
             for e in oldlog:
                 if not (
-                    util.safehasattr(e, 'branchpoints')
-                    and util.safehasattr(e, 'commitid')
-                    and util.safehasattr(e, 'mergepoint')
+                    util.safehasattr(e, b'branchpoints')
+                    and util.safehasattr(e, b'commitid')
+                    and util.safehasattr(e, b'mergepoint')
                 ):
-                    ui.status(_('ignoring old cache\n'))
+                    ui.status(_(b'ignoring old cache\n'))
                     oldlog = []
                     break
 
-            ui.note(_('cache has %d log entries\n') % len(oldlog))
+            ui.note(_(b'cache has %d log entries\n') % len(oldlog))
         except Exception as e:
-            ui.note(_('error reading cache: %r\n') % e)
+            ui.note(_(b'error reading cache: %r\n') % e)
 
         if oldlog:
             date = oldlog[-1].date  # last commit date as a (time,tz) tuple
-            date = dateutil.datestr(date, '%Y/%m/%d %H:%M:%S %1%2')
+            date = dateutil.datestr(date, b'%Y/%m/%d %H:%M:%S %1%2')
 
     # build the CVS commandline
-    cmd = ['cvs', '-q']
+    cmd = [b'cvs', b'-q']
     if root:
-        cmd.append('-d%s' % root)
+        cmd.append(b'-d%s' % root)
         p = util.normpath(getrepopath(root))
-        if not p.endswith('/'):
-            p += '/'
+        if not p.endswith(b'/'):
+            p += b'/'
         if prefix:
             # looks like normpath replaces "" by "."
             prefix = p + util.normpath(prefix)
         else:
             prefix = p
-    cmd.append(['log', 'rlog'][rlog])
+    cmd.append([b'log', b'rlog'][rlog])
     if date:
         # no space between option and date string
-        cmd.append('-d>%s' % date)
+        cmd.append(b'-d>%s' % date)
     cmd.append(directory)
 
     # state machine begins here
@@ -243,17 +243,17 b' def createlog(ui, directory=None, root="'
     store = False  # set when a new record can be appended
 
     cmd = [procutil.shellquote(arg) for arg in cmd]
-    ui.note(_("running %s\n") % (' '.join(cmd)))
-    ui.debug("prefix=%r directory=%r root=%r\n" % (prefix, directory, root))
+    ui.note(_(b"running %s\n") % (b' '.join(cmd)))
+    ui.debug(b"prefix=%r directory=%r root=%r\n" % (prefix, directory, root))
 
-    pfp = procutil.popen(' '.join(cmd), 'rb')
+    pfp = procutil.popen(b' '.join(cmd), b'rb')
     peek = util.fromnativeeol(pfp.readline())
     while True:
         line = peek
-        if line == '':
+        if line == b'':
             break
         peek = util.fromnativeeol(pfp.readline())
-        if line.endswith('\n'):
+        if line.endswith(b'\n'):
             line = line[:-1]
         # ui.debug('state=%d line=%r\n' % (state, line))
 
@@ -267,12 +267,12 b' def createlog(ui, directory=None, root="'
                     filename = util.normpath(rcs[:-2])
                     if filename.startswith(prefix):
                         filename = filename[len(prefix) :]
-                    if filename.startswith('/'):
+                    if filename.startswith(b'/'):
                         filename = filename[1:]
-                    if filename.startswith('Attic/'):
+                    if filename.startswith(b'Attic/'):
                         filename = filename[6:]
                     else:
-                        filename = filename.replace('/Attic/', '/')
+                        filename = filename.replace(b'/Attic/', b'/')
                     state = 2
                     continue
                 state = 1
@@ -289,7 +289,7 b' def createlog(ui, directory=None, root="'
         elif state == 1:
             # expect 'Working file' (only when using log instead of rlog)
             match = re_10.match(line)
-            assert match, _('RCS file must be followed by working file')
+            assert match, _(b'RCS file must be followed by working file')
             filename = util.normpath(match.group(1))
             state = 2
 
@@ -303,7 +303,7 b' def createlog(ui, directory=None, root="'
             # read the symbolic names and store as tags
             match = re_30.match(line)
             if match:
-                rev = [int(x) for x in match.group(2).split('.')]
+                rev = [int(x) for x in match.group(2).split(b'.')]
 
                 # Convert magic branch number to an odd-numbered one
                 revn = len(rev)
@@ -327,7 +327,7 b' def createlog(ui, directory=None, root="'
                 state = 5
             else:
                 assert not re_32.match(line), _(
-                    'must have at least ' 'some revisions'
+                    b'must have at least ' b'some revisions'
                 )
 
         elif state == 5:
@@ -335,11 +335,11 b' def createlog(ui, directory=None, root="'
             # we create the logentry here from values stored in states 0 to 4,
             # as this state is re-entered for subsequent revisions of a file.
             match = re_50.match(line)
-            assert match, _('expected revision number')
+            assert match, _(b'expected revision number')
             e = logentry(
                 rcs=scache(rcs),
                 file=scache(filename),
-                revision=tuple([int(x) for x in match.group(1).split('.')]),
+                revision=tuple([int(x) for x in match.group(1).split(b'.')]),
                 branches=[],
                 parent=None,
                 commitid=None,
@@ -352,21 +352,25 b' def createlog(ui, directory=None, root="'
         elif state == 6:
             # expecting date, author, state, lines changed
             match = re_60.match(line)
-            assert match, _('revision must be followed by date line')
+            assert match, _(b'revision must be followed by date line')
             d = match.group(1)
-            if d[2] == '/':
+            if d[2] == b'/':
                 # Y2K
-                d = '19' + d
+                d = b'19' + d
 
             if len(d.split()) != 3:
                 # cvs log dates always in GMT
-                d = d + ' UTC'
+                d = d + b' UTC'
             e.date = dateutil.parsedate(
                 d,
-                ['%y/%m/%d %H:%M:%S', '%Y/%m/%d %H:%M:%S', '%Y-%m-%d %H:%M:%S'],
+                [
+                    b'%y/%m/%d %H:%M:%S',
+                    b'%Y/%m/%d %H:%M:%S',
+                    b'%Y-%m-%d %H:%M:%S',
+                ],
             )
             e.author = scache(match.group(2))
-            e.dead = match.group(3).lower() == 'dead'
+            e.dead = match.group(3).lower() == b'dead'
 
             if match.group(5):
                 if match.group(6):
@@ -382,14 +386,14 b' def createlog(ui, directory=None, root="'
                 e.commitid = match.group(8)
 
             if match.group(9):  # cvsnt mergepoint
-                myrev = match.group(10).split('.')
+                myrev = match.group(10).split(b'.')
                 if len(myrev) == 2:  # head
-                    e.mergepoint = 'HEAD'
+                    e.mergepoint = b'HEAD'
                 else:
-                    myrev = '.'.join(myrev[:-2] + ['0', myrev[-2]])
+                    myrev = b'.'.join(myrev[:-2] + [b'0', myrev[-2]])
                     branches = [b for b in branchmap if branchmap[b] == myrev]
                     assert len(branches) == 1, (
-                        'unknown branch: %s' % e.mergepoint
+                        b'unknown branch: %s' % e.mergepoint
                     )
                     e.mergepoint = branches[0]
 
@@ -402,8 +406,8 b' def createlog(ui, directory=None, root="'
             m = re_70.match(line)
             if m:
                 e.branches = [
-                    tuple([int(y) for y in x.strip().split('.')])
-                    for x in m.group(1).split(';')
+                    tuple([int(y) for y in x.strip().split(b'.')])
+                    for x in m.group(1).split(b';')
                 ]
                 state = 8
             elif re_31.match(line) and re_50.match(peek):
@@ -419,7 +423,7 b' def createlog(ui, directory=None, root="'
             # store commit log message
             if re_31.match(line):
                 cpeek = peek
-                if cpeek.endswith('\n'):
+                if cpeek.endswith(b'\n'):
                     cpeek = cpeek[:-1]
                 if re_50.match(cpeek):
                     state = 5
@@ -447,7 +451,7 b' def createlog(ui, directory=None, root="'
             and file_added_re.match(e.comment[0])
         ):
             ui.debug(
-                'found synthetic revision in %s: %r\n' % (e.rcs, e.comment[0])
+                b'found synthetic revision in %s: %r\n' % (e.rcs, e.comment[0])
             )
             e.synthetic = True
 
@@ -455,7 +459,7 b' def createlog(ui, directory=None, root="'
             # clean up the results and save in the log.
             store = False
             e.tags = sorted([scache(x) for x in tags.get(e.revision, [])])
-            e.comment = scache('\n'.join(e.comment))
+            e.comment = scache(b'\n'.join(e.comment))
 
             revn = len(e.revision)
             if revn > 3 and (revn % 2) == 0:
@@ -466,7 +470,7 b' def createlog(ui, directory=None, root="'
             # find the branches starting from this revision
             branchpoints = set()
             for branch, revision in branchmap.iteritems():
-                revparts = tuple([int(i) for i in revision.split('.')])
+                revparts = tuple([int(i) for i in revision.split(b'.')])
                 if len(revparts) < 2:  # bad tags
                     continue
                 if revparts[-2] == 0 and revparts[-1] % 2 == 0:
@@ -480,11 +484,12 b' def createlog(ui, directory=None, root="'
 
             log.append(e)
 
-            rcsmap[e.rcs.replace('/Attic/', '/')] = e.rcs
+            rcsmap[e.rcs.replace(b'/Attic/', b'/')] = e.rcs
 
             if len(log) % 100 == 0:
                 ui.status(
-                    stringutil.ellipsis('%d %s' % (len(log), e.file), 80) + '\n'
+                    stringutil.ellipsis(b'%d %s' % (len(log), e.file), 80)
+                    + b'\n'
                 )
 
     log.sort(key=lambda x: (x.rcs, x.revision))
@@ -492,7 +497,7 b' def createlog(ui, directory=None, root="'
     # find parent revisions of individual files
     versions = {}
     for e in sorted(oldlog, key=lambda x: (x.rcs, x.revision)):
-        rcs = e.rcs.replace('/Attic/', '/')
+        rcs = e.rcs.replace(b'/Attic/', b'/')
         if rcs in rcsmap:
             e.rcs = rcsmap[rcs]
         branch = e.revision[:-1]
@@ -515,28 +520,28 b' def createlog(ui, directory=None, root="'
             if oldlog and oldlog[-1].date >= log[0].date:
                 raise logerror(
                     _(
-                        'log cache overlaps with new log entries,'
-                        ' re-run without cache.'
+                        b'log cache overlaps with new log entries,'
+                        b' re-run without cache.'
                     )
                 )
 
             log = oldlog + log
 
             # write the new cachefile
-            ui.note(_('writing cvs log cache %s\n') % cachefile)
-            pickle.dump(log, open(cachefile, 'wb'))
+            ui.note(_(b'writing cvs log cache %s\n') % cachefile)
+            pickle.dump(log, open(cachefile, b'wb'))
         else:
             log = oldlog
 
-    ui.status(_('%d log entries\n') % len(log))
+    ui.status(_(b'%d log entries\n') % len(log))
 
-    encodings = ui.configlist('convert', 'cvsps.logencoding')
+    encodings = ui.configlist(b'convert', b'cvsps.logencoding')
     if encodings:
 
         def revstr(r):
             # this is needed, because logentry.revision is a tuple of "int"
             # (e.g. (1, 2) for "1.2")
-            return '.'.join(pycompat.maplist(pycompat.bytestr, r))
+            return b'.'.join(pycompat.maplist(pycompat.bytestr, r))
 
         for entry in log:
             comment = entry.comment
@@ -547,7 +552,7 b' def createlog(ui, directory=None, root="'
                     )
                     if ui.debugflag:
                         ui.debug(
-                            "transcoding by %s: %s of %s\n"
+                            b"transcoding by %s: %s of %s\n"
                             % (e, revstr(entry.revision), entry.file)
                         )
                     break
@@ -557,20 +562,22 b' def createlog(ui, directory=None, root="'
                     raise error.Abort(
                         inst,
                         hint=_(
-                            'check convert.cvsps.logencoding' ' configuration'
+                            b'check convert.cvsps.logencoding' b' configuration'
                         ),
                     )
             else:
                 raise error.Abort(
                     _(
-                        "no encoding can transcode"
-                        " CVS log message for %s of %s"
+                        b"no encoding can transcode"
+                        b" CVS log message for %s of %s"
                     )
                     % (revstr(entry.revision), entry.file),
-                    hint=_('check convert.cvsps.logencoding' ' configuration'),
+                    hint=_(
+                        b'check convert.cvsps.logencoding' b' configuration'
+                    ),
                 )
 
-    hook.hook(ui, None, "cvslog", True, log=log)
+    hook.hook(ui, None, b"cvslog", True, log=log)
 
     return log
 
@@ -597,14 +604,16 b' class changeset(object):'
         self.__dict__.update(entries)
 
     def __repr__(self):
-        items = ("%s=%r" % (k, self.__dict__[k]) for k in sorted(self.__dict__))
-        return "%s(%s)" % (type(self).__name__, ", ".join(items))
+        items = (
+            b"%s=%r" % (k, self.__dict__[k]) for k in sorted(self.__dict__)
+        )
+        return b"%s(%s)" % (type(self).__name__, b", ".join(items))
 
 
 def createchangeset(ui, log, fuzz=60, mergefrom=None, mergeto=None):
     '''Convert log into changesets.'''
 
-    ui.status(_('creating changesets\n'))
+    ui.status(_(b'creating changesets\n'))
 
     # try to order commitids by date
     mindate = {}
@@ -619,10 +628,10 b' def createchangeset(ui, log, fuzz=60, me'
     log.sort(
         key=lambda x: (
             mindate.get(x.commitid, (-1, 0)),
-            x.commitid or '',
+            x.commitid or b'',
             x.comment,
             x.author,
-            x.branch or '',
+            x.branch or b'',
             x.date,
             x.branchpoints,
         )
@@ -682,8 +691,8 b' def createchangeset(ui, log, fuzz=60, me'
 
             files = set()
             if len(changesets) % 100 == 0:
-                t = '%d %s' % (len(changesets), repr(e.comment)[1:-1])
-                ui.status(stringutil.ellipsis(t, 80) + '\n')
+                t = b'%d %s' % (len(changesets), repr(e.comment)[1:-1])
+                ui.status(stringutil.ellipsis(t, 80) + b'\n')
 
         c.entries.append(e)
         files.add(e.file)
@@ -705,9 +714,9 b' def createchangeset(ui, log, fuzz=60, me'
     # Sort files in each changeset
 
     def entitycompare(l, r):
-        'Mimic cvsps sorting order'
-        l = l.file.split('/')
-        r = r.file.split('/')
+        b'Mimic cvsps sorting order'
+        l = l.file.split(b'/')
+        r = r.file.split(b'/')
         nl = len(l)
         nr = len(r)
         n = min(nl, nr)
@@ -842,7 +851,7 b' def createchangeset(ui, log, fuzz=60, me'
             # Ensure no changeset has a synthetic changeset as a parent.
             while p.synthetic:
                 assert len(p.parents) <= 1, _(
-                    'synthetic changeset cannot have multiple parents'
+                    b'synthetic changeset cannot have multiple parents'
                 )
                 if p.parents:
                     p = p.parents[0]
@@ -854,7 +863,7 b' def createchangeset(ui, log, fuzz=60, me'
                 c.parents.append(p)
 
         if c.mergepoint:
-            if c.mergepoint == 'HEAD':
+            if c.mergepoint == b'HEAD':
                 c.mergepoint = None
             c.parents.append(changesets[branches[c.mergepoint]])
 
@@ -862,15 +871,15 b' def createchangeset(ui, log, fuzz=60, me'
             m = mergefrom.search(c.comment)
             if m:
                 m = m.group(1)
-                if m == 'HEAD':
+                if m == b'HEAD':
                     m = None
                 try:
                     candidate = changesets[branches[m]]
                 except KeyError:
                     ui.warn(
                         _(
-                            "warning: CVS commit message references "
-                            "non-existent branch %r:\n%s\n"
+                            b"warning: CVS commit message references "
+                            b"non-existent branch %r:\n%s\n"
                         )
                         % (pycompat.bytestr(m), c.comment)
                     )
@@ -882,7 +891,7 b' def createchangeset(ui, log, fuzz=60, me'
             if m:
                 if m.groups():
                     m = m.group(1)
-                    if m == 'HEAD':
+                    if m == b'HEAD':
                         m = None
                 else:
                     m = None  # if no group found then merge to HEAD
@@ -892,7 +901,7 b' def createchangeset(ui, log, fuzz=60, me'
                         author=c.author,
                         branch=m,
                         date=c.date,
-                        comment='convert-repo: CVS merge from branch %s'
+                        comment=b'convert-repo: CVS merge from branch %s'
                         % c.branch,
                         entries=[],
                         tags=[],
@@ -927,13 +936,13 b' def createchangeset(ui, log, fuzz=60, me'
         for l, r in odd:
             if l.id is not None and r.id is not None:
                 ui.warn(
-                    _('changeset %d is both before and after %d\n')
+                    _(b'changeset %d is both before and after %d\n')
                     % (l.id, r.id)
                 )
 
-    ui.status(_('%d changeset entries\n') % len(changesets))
+    ui.status(_(b'%d changeset entries\n') % len(changesets))
 
-    hook.hook(ui, None, "cvschangesets", True, changesets=changesets)
+    hook.hook(ui, None, b"cvschangesets", True, changesets=changesets)
 
     return changesets
 
@@ -944,27 +953,27 b' def debugcvsps(ui, *args, **opts):'
     commit log entries and dates.
     '''
     opts = pycompat.byteskwargs(opts)
-    if opts["new_cache"]:
-        cache = "write"
-    elif opts["update_cache"]:
-        cache = "update"
+    if opts[b"new_cache"]:
+        cache = b"write"
+    elif opts[b"update_cache"]:
+        cache = b"update"
     else:
         cache = None
 
-    revisions = opts["revisions"]
+    revisions = opts[b"revisions"]
 
     try:
         if args:
             log = []
             for d in args:
-                log += createlog(ui, d, root=opts["root"], cache=cache)
+                log += createlog(ui, d, root=opts[b"root"], cache=cache)
         else:
-            log = createlog(ui, root=opts["root"], cache=cache)
+            log = createlog(ui, root=opts[b"root"], cache=cache)
     except logerror as e:
-        ui.write("%r\n" % e)
+        ui.write(b"%r\n" % e)
         return
 
-    changesets = createchangeset(ui, log, opts["fuzz"])
+    changesets = createchangeset(ui, log, opts[b"fuzz"])
     del log
 
     # Print changesets (optionally filtered)
@@ -974,7 +983,7 b' def debugcvsps(ui, *args, **opts):'
     ancestors = {}  # parent branch
     for cs in changesets:
 
-        if opts["ancestors"]:
+        if opts[b"ancestors"]:
             if cs.branch not in branches and cs.parents and cs.parents[0].id:
                 ancestors[cs.branch] = (
                     changesets[cs.parents[0].id - 1].branch,
@@ -983,72 +992,75 b' def debugcvsps(ui, *args, **opts):'
             branches[cs.branch] = cs.id
 
         # limit by branches
-        if opts["branches"] and (cs.branch or 'HEAD') not in opts["branches"]:
+        if (
+            opts[b"branches"]
+            and (cs.branch or b'HEAD') not in opts[b"branches"]
+        ):
             continue
 
         if not off:
             # Note: trailing spaces on several lines here are needed to have
             #       bug-for-bug compatibility with cvsps.
-            ui.write('---------------------\n')
-            ui.write(('PatchSet %d \n' % cs.id))
+            ui.write(b'---------------------\n')
+            ui.write((b'PatchSet %d \n' % cs.id))
             ui.write(
                 (
-                    'Date: %s\n'
-                    % dateutil.datestr(cs.date, '%Y/%m/%d %H:%M:%S %1%2')
+                    b'Date: %s\n'
+                    % dateutil.datestr(cs.date, b'%Y/%m/%d %H:%M:%S %1%2')
                 )
             )
-            ui.write(('Author: %s\n' % cs.author))
-            ui.write(('Branch: %s\n' % (cs.branch or 'HEAD')))
+            ui.write((b'Author: %s\n' % cs.author))
+            ui.write((b'Branch: %s\n' % (cs.branch or b'HEAD')))
             ui.write(
                 (
-                    'Tag%s: %s \n'
+                    b'Tag%s: %s \n'
                     % (
-                        ['', 's'][len(cs.tags) > 1],
-                        ','.join(cs.tags) or '(none)',
+                        [b'', b's'][len(cs.tags) > 1],
+                        b','.join(cs.tags) or b'(none)',
                     )
                 )
             )
             if cs.branchpoints:
                 ui.write(
-                    'Branchpoints: %s \n' % ', '.join(sorted(cs.branchpoints))
+                    b'Branchpoints: %s \n' % b', '.join(sorted(cs.branchpoints))
                 )
-            if opts["parents"] and cs.parents:
+            if opts[b"parents"] and cs.parents:
                 if len(cs.parents) > 1:
                     ui.write(
                         (
-                            'Parents: %s\n'
-                            % (','.join([(b"%d" % p.id) for p in cs.parents]))
+                            b'Parents: %s\n'
+                            % (b','.join([(b"%d" % p.id) for p in cs.parents]))
                         )
                     )
                 else:
-                    ui.write(('Parent: %d\n' % cs.parents[0].id))
+                    ui.write((b'Parent: %d\n' % cs.parents[0].id))
 
-            if opts["ancestors"]:
+            if opts[b"ancestors"]:
                 b = cs.branch
                 r = []
                 while b:
                     b, c = ancestors[b]
-                    r.append('%s:%d:%d' % (b or "HEAD", c, branches[b]))
+                    r.append(b'%s:%d:%d' % (b or b"HEAD", c, branches[b]))
                 if r:
-                    ui.write(('Ancestors: %s\n' % (','.join(r))))
+                    ui.write((b'Ancestors: %s\n' % (b','.join(r))))
 
-            ui.write('Log:\n')
-            ui.write('%s\n\n' % cs.comment)
-            ui.write('Members: \n')
+            ui.write(b'Log:\n')
+            ui.write(b'%s\n\n' % cs.comment)
+            ui.write(b'Members: \n')
             for f in cs.entries:
                 fn = f.file
-                if fn.startswith(opts["prefix"]):
-                    fn = fn[len(opts["prefix"]) :]
+                if fn.startswith(opts[b"prefix"]):
+                    fn = fn[len(opts[b"prefix"]) :]
                 ui.write(
-                    '\t%s:%s->%s%s \n'
+                    b'\t%s:%s->%s%s \n'
                     % (
                         fn,
-                        '.'.join([b"%d" % x for x in f.parent]) or 'INITIAL',
-                        '.'.join([(b"%d" % x) for x in f.revision]),
-                        ['', '(DEAD)'][f.dead],
+                        b'.'.join([b"%d" % x for x in f.parent]) or b'INITIAL',
+                        b'.'.join([(b"%d" % x) for x in f.revision]),
+                        [b'', b'(DEAD)'][f.dead],
                     )
                 )
-            ui.write('\n')
+            ui.write(b'\n')
 
         # have we seen the start tag?
         if revisions and off:

hgext/convert/darcs.py

@@ -46,22 +46,22 b' except ImportError:'
 class darcs_source(common.converter_source, common.commandline):
     def __init__(self, ui, repotype, path, revs=None):
         common.converter_source.__init__(self, ui, repotype, path, revs=revs)
-        common.commandline.__init__(self, ui, 'darcs')
+        common.commandline.__init__(self, ui, b'darcs')
 
         # check for _darcs, ElementTree so that we can easily skip
         # test-convert-darcs if ElementTree is not around
-        if not os.path.exists(os.path.join(path, '_darcs')):
-            raise NoRepo(_("%s does not look like a darcs repository") % path)
+        if not os.path.exists(os.path.join(path, b'_darcs')):
+            raise NoRepo(_(b"%s does not look like a darcs repository") % path)
 
-        common.checktool('darcs')
-        version = self.run0('--version').splitlines()[0].strip()
-        if version < '2.1':
+        common.checktool(b'darcs')
+        version = self.run0(b'--version').splitlines()[0].strip()
+        if version < b'2.1':
             raise error.Abort(
-                _('darcs version 2.1 or newer needed (found %r)') % version
+                _(b'darcs version 2.1 or newer needed (found %r)') % version
             )
 
-        if "ElementTree" not in globals():
-            raise error.Abort(_("Python ElementTree module is not available"))
+        if b"ElementTree" not in globals():
+            raise error.Abort(_(b"Python ElementTree module is not available"))
 
         self.path = os.path.realpath(path)
 
@@ -73,30 +73,33 b' class darcs_source(common.converter_sour'
         # Check darcs repository format
         format = self.format()
         if format:
-            if format in ('darcs-1.0', 'hashed'):
+            if format in (b'darcs-1.0', b'hashed'):
                 raise NoRepo(
-                    _("%s repository format is unsupported, " "please upgrade")
+                    _(
+                        b"%s repository format is unsupported, "
+                        b"please upgrade"
+                    )
                     % format
                 )
         else:
-            self.ui.warn(_('failed to detect repository format!'))
+            self.ui.warn(_(b'failed to detect repository format!'))
 
     def before(self):
         self.tmppath = pycompat.mkdtemp(
-            prefix='convert-' + os.path.basename(self.path) + '-'
+            prefix=b'convert-' + os.path.basename(self.path) + b'-'
         )
-        output, status = self.run('init', repodir=self.tmppath)
+        output, status = self.run(b'init', repodir=self.tmppath)
         self.checkexit(status)
 
         tree = self.xml(
-            'changes', xml_output=True, summary=True, repodir=self.path
+            b'changes', xml_output=True, summary=True, repodir=self.path
         )
         tagname = None
         child = None
-        for elt in tree.findall('patch'):
-            node = elt.get('hash')
-            name = elt.findtext('name', '')
-            if name.startswith('TAG '):
+        for elt in tree.findall(b'patch'):
+            node = elt.get(b'hash')
+            name = elt.findtext(b'name', b'')
+            if name.startswith(b'TAG '):
                 tagname = name[4:].strip()
             elif tagname is not None:
                 self.tags[tagname] = node
@@ -107,7 +110,7 b' class darcs_source(common.converter_sour'
         self.parents[child] = []
 
     def after(self):
-        self.ui.debug('cleaning up %s\n' % self.tmppath)
+        self.ui.debug(b'cleaning up %s\n' % self.tmppath)
         shutil.rmtree(self.tmppath, ignore_errors=True)
 
     def recode(self, s, encoding=None):
@@ -125,7 +128,7 b' class darcs_source(common.converter_sour'
         # While we are decoding the XML as latin-1 to be as liberal as
         # possible, etree will still raise an exception if any
         # non-printable characters are in the XML changelog.
-        parser = XMLParser(encoding='latin-1')
+        parser = XMLParser(encoding=b'latin-1')
         p = self._run(cmd, **kwargs)
         etree.parse(p.stdout, parser=parser)
         p.wait()
@@ -133,20 +136,20 b' class darcs_source(common.converter_sour'
         return etree.getroot()
 
     def format(self):
-        output, status = self.run('show', 'repo', repodir=self.path)
+        output, status = self.run(b'show', b'repo', repodir=self.path)
         self.checkexit(status)
         m = re.search(r'^\s*Format:\s*(.*)$', output, re.MULTILINE)
         if not m:
             return None
-        return ','.join(sorted(f.strip() for f in m.group(1).split(',')))
+        return b','.join(sorted(f.strip() for f in m.group(1).split(b',')))
 
     def manifest(self):
         man = []
         output, status = self.run(
-            'show', 'files', no_directories=True, repodir=self.tmppath
+            b'show', b'files', no_directories=True, repodir=self.tmppath
         )
         self.checkexit(status)
-        for line in output.split('\n'):
+        for line in output.split(b'\n'):
             path = line[2:]
             if path:
                 man.append(path)
@@ -157,14 +160,14 b' class darcs_source(common.converter_sour'
 
     def getcommit(self, rev):
         elt = self.changes[rev]
-        dateformat = '%a %b %d %H:%M:%S %Z %Y'
-        date = dateutil.strdate(elt.get('local_date'), dateformat)
-        desc = elt.findtext('name') + '\n' + elt.findtext('comment', '')
+        dateformat = b'%a %b %d %H:%M:%S %Z %Y'
+        date = dateutil.strdate(elt.get(b'local_date'), dateformat)
+        desc = elt.findtext(b'name') + b'\n' + elt.findtext(b'comment', b'')
         # etree can return unicode objects for name, comment, and author,
         # so recode() is used to ensure str objects are emitted.
-        newdateformat = '%Y-%m-%d %H:%M:%S %1%2'
+        newdateformat = b'%Y-%m-%d %H:%M:%S %1%2'
         return common.commit(
-            author=self.recode(elt.get('author')),
+            author=self.recode(elt.get(b'author')),
             date=dateutil.datestr(date, newdateformat),
             desc=self.recode(desc).strip(),
             parents=self.parents[rev],
@@ -172,34 +175,34 b' class darcs_source(common.converter_sour'
 
     def pull(self, rev):
         output, status = self.run(
-            'pull',
+            b'pull',
             self.path,
             all=True,
-            match='hash %s' % rev,
+            match=b'hash %s' % rev,
             no_test=True,
             no_posthook=True,
-            external_merge='/bin/false',
+            external_merge=b'/bin/false',
             repodir=self.tmppath,
         )
         if status:
-            if output.find('We have conflicts in') == -1:
+            if output.find(b'We have conflicts in') == -1:
                 self.checkexit(status, output)
-            output, status = self.run('revert', all=True, repodir=self.tmppath)
+            output, status = self.run(b'revert', all=True, repodir=self.tmppath)
             self.checkexit(status, output)
 
     def getchanges(self, rev, full):
         if full:
-            raise error.Abort(_("convert from darcs does not support --full"))
+            raise error.Abort(_(b"convert from darcs does not support --full"))
         copies = {}
         changes = []
         man = None
-        for elt in self.changes[rev].find('summary').getchildren():
-            if elt.tag in ('add_directory', 'remove_directory'):
+        for elt in self.changes[rev].find(b'summary').getchildren():
+            if elt.tag in (b'add_directory', b'remove_directory'):
                 continue
-            if elt.tag == 'move':
+            if elt.tag == b'move':
                 if man is None:
                     man = self.manifest()
-                source, dest = elt.get('from'), elt.get('to')
+                source, dest = elt.get(b'from'), elt.get(b'to')
                 if source in man:
                     # File move
                     changes.append((source, rev))
@@ -207,11 +210,11 b' class darcs_source(common.converter_sour'
                     copies[dest] = source
                 else:
                     # Directory move, deduce file moves from manifest
-                    source = source + '/'
+                    source = source + b'/'
                     for f in man:
                         if not f.startswith(source):
                             continue
-                        fdest = dest + '/' + f[len(source) :]
+                        fdest = dest + b'/' + f[len(source) :]
                         changes.append((f, rev))
                         changes.append((fdest, rev))
                         copies[fdest] = f
@@ -223,7 +226,7 b' class darcs_source(common.converter_sour'
 
     def getfile(self, name, rev):
         if rev != self.lastrev:
-            raise error.Abort(_('internal calling inconsistency'))
+            raise error.Abort(_(b'internal calling inconsistency'))
         path = os.path.join(self.tmppath, name)
         try:
             data = util.readfile(path)
@@ -232,7 +235,7 b' class darcs_source(common.converter_sour'
             if inst.errno == errno.ENOENT:
                 return None, None
             raise
-        mode = (mode & 0o111) and 'x' or ''
+        mode = (mode & 0o111) and b'x' or b''
         return data, mode
 
     def gettags(self):

hgext/convert/filemap.py

@@ -30,8 +30,8 b' def rpairs(path):'
     i = len(path)
     while i != -1:
         yield path[:i], path[i + 1 :]
-        i = path.rfind('/', 0, i)
-    yield '.', path
+        i = path.rfind(b'/', 0, i)
+    yield b'.', path
 
 
 def normalize(path):
@@ -55,7 +55,7 b' class filemapper(object):'
         self.targetprefixes = None
         if path:
             if self.parse(path):
-                raise error.Abort(_('errors in filemap'))
+                raise error.Abort(_(b'errors in filemap'))
 
     def parse(self, path):
         errs = 0
@@ -63,48 +63,48 b' class filemapper(object):'
         def check(name, mapping, listname):
             if not name:
                 self.ui.warn(
-                    _('%s:%d: path to %s is missing\n')
+                    _(b'%s:%d: path to %s is missing\n')
                     % (lex.infile, lex.lineno, listname)
                 )
                 return 1
             if name in mapping:
                 self.ui.warn(
-                    _('%s:%d: %r already in %s list\n')
+                    _(b'%s:%d: %r already in %s list\n')
                     % (lex.infile, lex.lineno, name, listname)
                 )
                 return 1
-            if name.startswith('/') or name.endswith('/') or '//' in name:
+            if name.startswith(b'/') or name.endswith(b'/') or b'//' in name:
                 self.ui.warn(
-                    _('%s:%d: superfluous / in %s %r\n')
+                    _(b'%s:%d: superfluous / in %s %r\n')
                     % (lex.infile, lex.lineno, listname, pycompat.bytestr(name))
                 )
                 return 1
             return 0
 
         lex = common.shlexer(
-            filepath=path, wordchars='!@#$%^&*()-=+[]{}|;:,./<>?'
+            filepath=path, wordchars=b'!@#$%^&*()-=+[]{}|;:,./<>?'
         )
         cmd = lex.get_token()
         while cmd:
-            if cmd == 'include':
+            if cmd == b'include':
                 name = normalize(lex.get_token())
-                errs += check(name, self.exclude, 'exclude')
+                errs += check(name, self.exclude, b'exclude')
                 self.include[name] = name
-            elif cmd == 'exclude':
+            elif cmd == b'exclude':
                 name = normalize(lex.get_token())
-                errs += check(name, self.include, 'include')
-                errs += check(name, self.rename, 'rename')
+                errs += check(name, self.include, b'include')
+                errs += check(name, self.rename, b'rename')
                 self.exclude[name] = name
-            elif cmd == 'rename':
+            elif cmd == b'rename':
                 src = normalize(lex.get_token())
                 dest = normalize(lex.get_token())
-                errs += check(src, self.exclude, 'exclude')
+                errs += check(src, self.exclude, b'exclude')
                 self.rename[src] = dest
-            elif cmd == 'source':
+            elif cmd == b'source':
                 errs += self.parse(normalize(lex.get_token()))
             else:
                 self.ui.warn(
-                    _('%s:%d: unknown directive %r\n')
+                    _(b'%s:%d: unknown directive %r\n')
                     % (lex.infile, lex.lineno, pycompat.bytestr(cmd))
                 )
                 errs += 1
@@ -118,7 +118,7 b' class filemapper(object):'
                 return mapping[pre], pre, suf
             except KeyError:
                 pass
-        return '', name, ''
+        return b'', name, b''
 
     def istargetfile(self, filename):
         """Return true if the given target filename is covered as a destination
@@ -131,7 +131,7 b' class filemapper(object):'
 
         # If "." is a target, then all target files are considered from the
         # source.
-        if not self.targetprefixes or '.' in self.targetprefixes:
+        if not self.targetprefixes or b'.' in self.targetprefixes:
             return True
 
         filename = normalize(filename)
@@ -152,17 +152,17 b' class filemapper(object):'
         if self.exclude:
             exc = self.lookup(name, self.exclude)[0]
         else:
-            exc = ''
+            exc = b''
         if (not self.include and exc) or (len(inc) <= len(exc)):
             return None
         newpre, pre, suf = self.lookup(name, self.rename)
         if newpre:
-            if newpre == '.':
+            if newpre == b'.':
                 return suf
             if suf:
-                if newpre.endswith('/'):
+                if newpre.endswith(b'/'):
                     return newpre + suf
-                return newpre + '/' + suf
+                return newpre + b'/' + suf
             return newpre
         return name
 
@@ -204,7 +204,7 b' class filemap_source(common.converter_so'
         self.seenchildren = {}
         # experimental config: convert.ignoreancestorcheck
         self.ignoreancestorcheck = self.ui.configbool(
-            'convert', 'ignoreancestorcheck'
+            b'convert', b'ignoreancestorcheck'
         )
 
     def before(self):
@@ -256,7 +256,7 b' class filemap_source(common.converter_so'
                 try:
                     self.origparents[rev] = self.getcommit(rev).parents
                 except error.RepoLookupError:
-                    self.ui.debug("unknown revmap source: %s\n" % rev)
+                    self.ui.debug(b"unknown revmap source: %s\n" % rev)
                     continue
             if arg is not None:
                 self.children[arg] = self.children.get(arg, 0) + 1
@@ -316,7 +316,7 b' class filemap_source(common.converter_so'
         try:
             files = self.base.getchangedfiles(rev, i)
         except NotImplementedError:
-            raise error.Abort(_("source repository doesn't support --filemap"))
+            raise error.Abort(_(b"source repository doesn't support --filemap"))
         for f in files:
             if self.filemapper(f):
                 return True
@@ -331,7 +331,7 b' class filemap_source(common.converter_so'
         # close marker is significant (i.e. all of the branch ancestors weren't
         # eliminated).  Therefore if there *is* a close marker, getchanges()
         # doesn't consider it significant, and this revision should be dropped.
-        return not files and 'close' not in self.commits[rev].extra
+        return not files and b'close' not in self.commits[rev].extra
 
     def mark_not_wanted(self, rev, p):
         # Mark rev as not interesting and update data structures.
@@ -363,7 +363,9 b' class filemap_source(common.converter_so'
             if p in self.wantedancestors:
                 wrev.update(self.wantedancestors[p])
             else:
-                self.ui.warn(_('warning: %s parent %s is missing\n') % (rev, p))
+                self.ui.warn(
+                    _(b'warning: %s parent %s is missing\n') % (rev, p)
+                )
         wrev.add(rev)
         self.wantedancestors[rev] = wrev
 
@@ -423,7 +425,7 b' class filemap_source(common.converter_so'
         self.origparents[rev] = parents
 
         closed = False
-        if 'close' in self.commits[rev].extra:
+        if b'close' in self.commits[rev].extra:
             # A branch closing revision is only useful if one of its
             # parents belong to the branch being closed
             pbranches = [self._cachedcommit(p).branch for p in mparents]

hgext/convert/git.py

@@ -26,22 +26,22 b' class submodule(object):'
         self.url = url
 
     def hgsub(self):
-        return "%s = [git]%s" % (self.path, self.url)
+        return b"%s = [git]%s" % (self.path, self.url)
 
     def hgsubstate(self):
-        return "%s %s" % (self.node, self.path)
+        return b"%s %s" % (self.node, self.path)
 
 
 # Keys in extra fields that should not be copied if the user requests.
 bannedextrakeys = {
     # Git commit object built-ins.
-    'tree',
-    'parent',
-    'author',
-    'committer',
+    b'tree',
+    b'parent',
+    b'author',
+    b'committer',
     # Mercurial built-ins.
-    'branch',
-    'close',
+    b'branch',
+    b'close',
 }
 
 
@@ -51,7 +51,7 b' class convert_git(common.converter_sourc'
     # both issues.
 
     def _gitcmd(self, cmd, *args, **kwargs):
-        return cmd('--git-dir=%s' % self.path, *args, **kwargs)
+        return cmd(b'--git-dir=%s' % self.path, *args, **kwargs)
 
     def gitrun0(self, *args, **kwargs):
         return self._gitcmd(self.run0, *args, **kwargs)
@@ -70,100 +70,104 b' class convert_git(common.converter_sourc'
 
     def __init__(self, ui, repotype, path, revs=None):
         super(convert_git, self).__init__(ui, repotype, path, revs=revs)
-        common.commandline.__init__(self, ui, 'git')
+        common.commandline.__init__(self, ui, b'git')
 
         # Pass an absolute path to git to prevent from ever being interpreted
         # as a URL
         path = os.path.abspath(path)
 
-        if os.path.isdir(path + "/.git"):
-            path += "/.git"
-        if not os.path.exists(path + "/objects"):
+        if os.path.isdir(path + b"/.git"):
+            path += b"/.git"
+        if not os.path.exists(path + b"/objects"):
             raise common.NoRepo(
-                _("%s does not look like a Git repository") % path
+                _(b"%s does not look like a Git repository") % path
             )
 
         # The default value (50) is based on the default for 'git diff'.
-        similarity = ui.configint('convert', 'git.similarity')
+        similarity = ui.configint(b'convert', b'git.similarity')
         if similarity < 0 or similarity > 100:
-            raise error.Abort(_('similarity must be between 0 and 100'))
+            raise error.Abort(_(b'similarity must be between 0 and 100'))
         if similarity > 0:
-            self.simopt = ['-C%d%%' % similarity]
-            findcopiesharder = ui.configbool('convert', 'git.findcopiesharder')
+            self.simopt = [b'-C%d%%' % similarity]
+            findcopiesharder = ui.configbool(
+                b'convert', b'git.findcopiesharder'
+            )
             if findcopiesharder:
-                self.simopt.append('--find-copies-harder')
+                self.simopt.append(b'--find-copies-harder')
 
-            renamelimit = ui.configint('convert', 'git.renamelimit')
-            self.simopt.append('-l%d' % renamelimit)
+            renamelimit = ui.configint(b'convert', b'git.renamelimit')
+            self.simopt.append(b'-l%d' % renamelimit)
         else:
             self.simopt = []
 
-        common.checktool('git', 'git')
+        common.checktool(b'git', b'git')
 
         self.path = path
         self.submodules = []
 
-        self.catfilepipe = self.gitpipe('cat-file', '--batch')
+        self.catfilepipe = self.gitpipe(b'cat-file', b'--batch')
 
-        self.copyextrakeys = self.ui.configlist('convert', 'git.extrakeys')
+        self.copyextrakeys = self.ui.configlist(b'convert', b'git.extrakeys')
         banned = set(self.copyextrakeys) & bannedextrakeys
         if banned:
             raise error.Abort(
-                _('copying of extra key is forbidden: %s')
-                % _(', ').join(sorted(banned))
+                _(b'copying of extra key is forbidden: %s')
+                % _(b', ').join(sorted(banned))
             )
 
-        committeractions = self.ui.configlist('convert', 'git.committeractions')
+        committeractions = self.ui.configlist(
+            b'convert', b'git.committeractions'
+        )
 
         messagedifferent = None
         messagealways = None
         for a in committeractions:
-            if a.startswith(('messagedifferent', 'messagealways')):
+            if a.startswith((b'messagedifferent', b'messagealways')):
                 k = a
                 v = None
-                if '=' in a:
-                    k, v = a.split('=', 1)
+                if b'=' in a:
+                    k, v = a.split(b'=', 1)
 
-                if k == 'messagedifferent':
-                    messagedifferent = v or 'committer:'
-                elif k == 'messagealways':
-                    messagealways = v or 'committer:'
+                if k == b'messagedifferent':
+                    messagedifferent = v or b'committer:'
+                elif k == b'messagealways':
+                    messagealways = v or b'committer:'
 
         if messagedifferent and messagealways:
             raise error.Abort(
                 _(
-                    'committeractions cannot define both '
-                    'messagedifferent and messagealways'
+                    b'committeractions cannot define both '
+                    b'messagedifferent and messagealways'
                 )
             )
 
-        dropcommitter = 'dropcommitter' in committeractions
-        replaceauthor = 'replaceauthor' in committeractions
+        dropcommitter = b'dropcommitter' in committeractions
+        replaceauthor = b'replaceauthor' in committeractions
 
         if dropcommitter and replaceauthor:
             raise error.Abort(
                 _(
-                    'committeractions cannot define both '
-                    'dropcommitter and replaceauthor'
+                    b'committeractions cannot define both '
+                    b'dropcommitter and replaceauthor'
                 )
             )
 
         if dropcommitter and messagealways:
             raise error.Abort(
                 _(
-                    'committeractions cannot define both '
-                    'dropcommitter and messagealways'
+                    b'committeractions cannot define both '
+                    b'dropcommitter and messagealways'
                 )
             )
 
         if not messagedifferent and not messagealways:
-            messagedifferent = 'committer:'
+            messagedifferent = b'committer:'
 
         self.committeractions = {
-            'dropcommitter': dropcommitter,
-            'replaceauthor': replaceauthor,
-            'messagedifferent': messagedifferent,
-            'messagealways': messagealways,
+            b'dropcommitter': dropcommitter,
+            b'replaceauthor': replaceauthor,
+            b'messagedifferent': messagedifferent,
+            b'messagealways': messagealways,
         }
 
     def after(self):
@@ -172,35 +176,38 b' class convert_git(common.converter_sourc'
 
     def getheads(self):
         if not self.revs:
-            output, status = self.gitrun('rev-parse', '--branches', '--remotes')
+            output, status = self.gitrun(
+                b'rev-parse', b'--branches', b'--remotes'
+            )
             heads = output.splitlines()
             if status:
-                raise error.Abort(_('cannot retrieve git heads'))
+                raise error.Abort(_(b'cannot retrieve git heads'))
         else:
             heads = []
             for rev in self.revs:
-                rawhead, ret = self.gitrun('rev-parse', '--verify', rev)
+                rawhead, ret = self.gitrun(b'rev-parse', b'--verify', rev)
                 heads.append(rawhead[:-1])
                 if ret:
-                    raise error.Abort(_('cannot retrieve git head "%s"') % rev)
+                    raise error.Abort(_(b'cannot retrieve git head "%s"') % rev)
         return heads
 
     def catfile(self, rev, ftype):
         if rev == nodemod.nullhex:
             raise IOError
-        self.catfilepipe[0].write(rev + '\n')
+        self.catfilepipe[0].write(rev + b'\n')
         self.catfilepipe[0].flush()
         info = self.catfilepipe[1].readline().split()
         if info[1] != ftype:
             raise error.Abort(
-                _('cannot read %r object at %s')
+                _(b'cannot read %r object at %s')
                 % (pycompat.bytestr(ftype), rev)
             )
         size = int(info[2])
         data = self.catfilepipe[1].read(size)
         if len(data) < size:
             raise error.Abort(
-                _('cannot read %r object at %s: unexpected size') % (ftype, rev)
+                _(b'cannot read %r object at %s: unexpected size')
+                % (ftype, rev)
             )
         # read the trailing newline
         self.catfilepipe[1].read(1)
@@ -209,14 +216,14 b' class convert_git(common.converter_sourc'
     def getfile(self, name, rev):
         if rev == nodemod.nullhex:
             return None, None
-        if name == '.hgsub':
-            data = '\n'.join([m.hgsub() for m in self.submoditer()])
-            mode = ''
-        elif name == '.hgsubstate':
-            data = '\n'.join([m.hgsubstate() for m in self.submoditer()])
-            mode = ''
+        if name == b'.hgsub':
+            data = b'\n'.join([m.hgsub() for m in self.submoditer()])
+            mode = b''
+        elif name == b'.hgsubstate':
+            data = b'\n'.join([m.hgsubstate() for m in self.submoditer()])
+            mode = b''
         else:
-            data = self.catfile(rev, "blob")
+            data = self.catfile(rev, b"blob")
             mode = self.modecache[(name, rev)]
         return data, mode
 
@@ -236,21 +243,23 b' class convert_git(common.converter_sourc'
         c = config.config()
         # Each item in .gitmodules starts with whitespace that cant be parsed
         c.parse(
-            '.gitmodules',
-            '\n'.join(line.strip() for line in content.split('\n')),
+            b'.gitmodules',
+            b'\n'.join(line.strip() for line in content.split(b'\n')),
         )
         for sec in c.sections():
             s = c[sec]
-            if 'url' in s and 'path' in s:
-                self.submodules.append(submodule(s['path'], '', s['url']))
+            if b'url' in s and b'path' in s:
+                self.submodules.append(submodule(s[b'path'], b'', s[b'url']))
 
     def retrievegitmodules(self, version):
-        modules, ret = self.gitrun('show', '%s:%s' % (version, '.gitmodules'))
+        modules, ret = self.gitrun(
+            b'show', b'%s:%s' % (version, b'.gitmodules')
+        )
         if ret:
             # This can happen if a file is in the repo that has permissions
             # 160000, but there is no .gitmodules file.
             self.ui.warn(
-                _("warning: cannot read submodules config file in " "%s\n")
+                _(b"warning: cannot read submodules config file in " b"%s\n")
                 % version
             )
             return
@@ -259,74 +268,76 b' class convert_git(common.converter_sourc'
             self.parsegitmodules(modules)
         except error.ParseError:
             self.ui.warn(
-                _("warning: unable to parse .gitmodules in %s\n") % version
+                _(b"warning: unable to parse .gitmodules in %s\n") % version
             )
             return
 
         for m in self.submodules:
-            node, ret = self.gitrun('rev-parse', '%s:%s' % (version, m.path))
+            node, ret = self.gitrun(b'rev-parse', b'%s:%s' % (version, m.path))
             if ret:
                 continue
             m.node = node.strip()
 
     def getchanges(self, version, full):
         if full:
-            raise error.Abort(_("convert from git does not support --full"))
+            raise error.Abort(_(b"convert from git does not support --full"))
         self.modecache = {}
         cmd = (
-            ['diff-tree', '-z', '--root', '-m', '-r'] + self.simopt + [version]
+            [b'diff-tree', b'-z', b'--root', b'-m', b'-r']
+            + self.simopt
+            + [version]
         )
         output, status = self.gitrun(*cmd)
         if status:
-            raise error.Abort(_('cannot read changes in %s') % version)
+            raise error.Abort(_(b'cannot read changes in %s') % version)
         changes = []
         copies = {}
         seen = set()
         entry = None
         subexists = [False]
         subdeleted = [False]
-        difftree = output.split('\x00')
+        difftree = output.split(b'\x00')
         lcount = len(difftree)
         i = 0
 
-        skipsubmodules = self.ui.configbool('convert', 'git.skipsubmodules')
+        skipsubmodules = self.ui.configbool(b'convert', b'git.skipsubmodules')
 
         def add(entry, f, isdest):
             seen.add(f)
             h = entry[3]
-            p = entry[1] == "100755"
-            s = entry[1] == "120000"
-            renamesource = not isdest and entry[4][0] == 'R'
+            p = entry[1] == b"100755"
+            s = entry[1] == b"120000"
+            renamesource = not isdest and entry[4][0] == b'R'
 
-            if f == '.gitmodules':
+            if f == b'.gitmodules':
                 if skipsubmodules:
                     return
 
                 subexists[0] = True
-                if entry[4] == 'D' or renamesource:
+                if entry[4] == b'D' or renamesource:
                     subdeleted[0] = True
-                    changes.append(('.hgsub', nodemod.nullhex))
+                    changes.append((b'.hgsub', nodemod.nullhex))
                 else:
-                    changes.append(('.hgsub', ''))
-            elif entry[1] == '160000' or entry[0] == ':160000':
+                    changes.append((b'.hgsub', b''))
+            elif entry[1] == b'160000' or entry[0] == b':160000':
                 if not skipsubmodules:
                     subexists[0] = True
             else:
                 if renamesource:
                     h = nodemod.nullhex
-                self.modecache[(f, h)] = (p and "x") or (s and "l") or ""
+                self.modecache[(f, h)] = (p and b"x") or (s and b"l") or b""
                 changes.append((f, h))
 
         while i < lcount:
             l = difftree[i]
             i += 1
             if not entry:
-                if not l.startswith(':'):
+                if not l.startswith(b':'):
                     continue
                 entry = tuple(pycompat.bytestr(p) for p in l.split())
                 continue
             f = l
-            if entry[4][0] == 'C':
+            if entry[4][0] == b'C':
                 copysrc = f
                 copydest = difftree[i]
                 i += 1
@@ -336,7 +347,7 b' class convert_git(common.converter_sourc'
                 add(entry, f, False)
             # A file can be copied multiple times, or modified and copied
             # simultaneously. So f can be repeated even if fdest isn't.
-            if entry[4][0] == 'R':
+            if entry[4][0] == b'R':
                 # rename: next line is the destination
                 fdest = difftree[i]
                 i += 1
@@ -344,21 +355,21 b' class convert_git(common.converter_sourc'
                     add(entry, fdest, True)
                     # .gitmodules isn't imported at all, so it being copied to
                     # and fro doesn't really make sense
-                    if f != '.gitmodules' and fdest != '.gitmodules':
+                    if f != b'.gitmodules' and fdest != b'.gitmodules':
                         copies[fdest] = f
             entry = None
 
         if subexists[0]:
             if subdeleted[0]:
-                changes.append(('.hgsubstate', nodemod.nullhex))
+                changes.append((b'.hgsubstate', nodemod.nullhex))
             else:
                 self.retrievegitmodules(version)
-                changes.append(('.hgsubstate', ''))
+                changes.append((b'.hgsubstate', b''))
         return (changes, copies, set())
 
     def getcommit(self, version):
-        c = self.catfile(version, "commit")  # read the commit hash
-        end = c.find("\n\n")
+        c = self.catfile(version, b"commit")  # read the commit hash
+        end = c.find(b"\n\n")
         message = c[end + 2 :]
         message = self.recode(message)
         l = c[:end].splitlines()
@@ -366,43 +377,43 b' class convert_git(common.converter_sourc'
         author = committer = None
         extra = {}
         for e in l[1:]:
-            n, v = e.split(" ", 1)
-            if n == "author":
+            n, v = e.split(b" ", 1)
+            if n == b"author":
                 p = v.split()
                 tm, tz = p[-2:]
-                author = " ".join(p[:-2])
-                if author[0] == "<":
+                author = b" ".join(p[:-2])
+                if author[0] == b"<":
                     author = author[1:-1]
                 author = self.recode(author)
-            if n == "committer":
+            if n == b"committer":
                 p = v.split()
                 tm, tz = p[-2:]
-                committer = " ".join(p[:-2])
-                if committer[0] == "<":
+                committer = b" ".join(p[:-2])
+                if committer[0] == b"<":
                     committer = committer[1:-1]
                 committer = self.recode(committer)
-            if n == "parent":
+            if n == b"parent":
                 parents.append(v)
             if n in self.copyextrakeys:
                 extra[n] = v
 
-        if self.committeractions['dropcommitter']:
+        if self.committeractions[b'dropcommitter']:
             committer = None
-        elif self.committeractions['replaceauthor']:
+        elif self.committeractions[b'replaceauthor']:
             author = committer
 
         if committer:
-            messagealways = self.committeractions['messagealways']
-            messagedifferent = self.committeractions['messagedifferent']
+            messagealways = self.committeractions[b'messagealways']
+            messagedifferent = self.committeractions[b'messagedifferent']
             if messagealways:
-                message += '\n%s %s\n' % (messagealways, committer)
+                message += b'\n%s %s\n' % (messagealways, committer)
             elif messagedifferent and author != committer:
-                message += '\n%s %s\n' % (messagedifferent, committer)
+                message += b'\n%s %s\n' % (messagedifferent, committer)
 
-        tzs, tzh, tzm = tz[-5:-4] + "1", tz[-4:-2], tz[-2:]
+        tzs, tzh, tzm = tz[-5:-4] + b"1", tz[-4:-2], tz[-2:]
         tz = -int(tzs) * (int(tzh) * 3600 + int(tzm))
-        date = tm + " " + (b"%d" % tz)
-        saverev = self.ui.configbool('convert', 'git.saverev')
+        date = tm + b" " + (b"%d" % tz)
+        saverev = self.ui.configbool(b'convert', b'git.saverev')
 
         c = common.commit(
             parents=parents,
@@ -416,27 +427,27 b' class convert_git(common.converter_sourc'
         return c
 
     def numcommits(self):
-        output, ret = self.gitrunlines('rev-list', '--all')
+        output, ret = self.gitrunlines(b'rev-list', b'--all')
         if ret:
             raise error.Abort(
-                _('cannot retrieve number of commits in %s') % self.path
+                _(b'cannot retrieve number of commits in %s') % self.path
             )
         return len(output)
 
     def gettags(self):
         tags = {}
         alltags = {}
-        output, status = self.gitrunlines('ls-remote', '--tags', self.path)
+        output, status = self.gitrunlines(b'ls-remote', b'--tags', self.path)
 
         if status:
-            raise error.Abort(_('cannot read tags from %s') % self.path)
-        prefix = 'refs/tags/'
+            raise error.Abort(_(b'cannot read tags from %s') % self.path)
+        prefix = b'refs/tags/'
 
         # Build complete list of tags, both annotated and bare ones
         for line in output:
             line = line.strip()
-            if line.startswith("error:") or line.startswith("fatal:"):
-                raise error.Abort(_('cannot read tags from %s') % self.path)
+            if line.startswith(b"error:") or line.startswith(b"fatal:"):
+                raise error.Abort(_(b'cannot read tags from %s') % self.path)
             node, tag = line.split(None, 1)
             if not tag.startswith(prefix):
                 continue
@@ -444,10 +455,10 b' class convert_git(common.converter_sourc'
 
         # Filter out tag objects for annotated tag refs
         for tag in alltags:
-            if tag.endswith('^{}'):
+            if tag.endswith(b'^{}'):
                 tags[tag[:-3]] = alltags[tag]
             else:
-                if tag + '^{}' in alltags:
+                if tag + b'^{}' in alltags:
                     continue
                 else:
                     tags[tag] = alltags[tag]
@@ -458,28 +469,28 b' class convert_git(common.converter_sourc'
         changes = []
         if i is None:
             output, status = self.gitrunlines(
-                'diff-tree', '--root', '-m', '-r', version
+                b'diff-tree', b'--root', b'-m', b'-r', version
             )
             if status:
-                raise error.Abort(_('cannot read changes in %s') % version)
+                raise error.Abort(_(b'cannot read changes in %s') % version)
             for l in output:
-                if "\t" not in l:
+                if b"\t" not in l:
                     continue
-                m, f = l[:-1].split("\t")
+                m, f = l[:-1].split(b"\t")
                 changes.append(f)
         else:
             output, status = self.gitrunlines(
-                'diff-tree',
-                '--name-only',
-                '--root',
-                '-r',
+                b'diff-tree',
+                b'--name-only',
+                b'--root',
+                b'-r',
                 version,
-                '%s^%d' % (version, i + 1),
-                '--',
+                b'%s^%d' % (version, i + 1),
+                b'--',
             )
             if status:
-                raise error.Abort(_('cannot read changes in %s') % version)
-            changes = [f.rstrip('\n') for f in output]
+                raise error.Abort(_(b'cannot read changes in %s') % version)
+            changes = [f.rstrip(b'\n') for f in output]
 
         return changes
 
@@ -487,19 +498,19 b' class convert_git(common.converter_sourc'
         bookmarks = {}
 
         # Handle local and remote branches
-        remoteprefix = self.ui.config('convert', 'git.remoteprefix')
+        remoteprefix = self.ui.config(b'convert', b'git.remoteprefix')
         reftypes = [
             # (git prefix, hg prefix)
-            ('refs/remotes/origin/', remoteprefix + '/'),
-            ('refs/heads/', ''),
+            (b'refs/remotes/origin/', remoteprefix + b'/'),
+            (b'refs/heads/', b''),
         ]
 
         exclude = {
-            'refs/remotes/origin/HEAD',
+            b'refs/remotes/origin/HEAD',
         }
 
         try:
-            output, status = self.gitrunlines('show-ref')
+            output, status = self.gitrunlines(b'show-ref')
             for line in output:
                 line = line.strip()
                 rev, name = line.split(None, 1)
@@ -507,13 +518,13 b' class convert_git(common.converter_sourc'
                 for gitprefix, hgprefix in reftypes:
                     if not name.startswith(gitprefix) or name in exclude:
                         continue
-                    name = '%s%s' % (hgprefix, name[len(gitprefix) :])
+                    name = b'%s%s' % (hgprefix, name[len(gitprefix) :])
                     bookmarks[name] = rev
         except Exception:
             pass
 
         return bookmarks
 
-    def checkrevformat(self, revstr, mapname='splicemap'):
+    def checkrevformat(self, revstr, mapname=b'splicemap'):
         """ git revision string is a 40 byte hex """
         self.checkhexformat(revstr, mapname)

hgext/convert/gnuarch.py

@@ -31,9 +31,9 b' class gnuarch_source(common.converter_so'
     class gnuarch_rev(object):
         def __init__(self, rev):
             self.rev = rev
-            self.summary = ''
+            self.summary = b''
             self.date = None
-            self.author = ''
+            self.author = b''
             self.continuationof = None
             self.add_files = []
             self.mod_files = []
@@ -44,20 +44,20 b' class gnuarch_source(common.converter_so'
     def __init__(self, ui, repotype, path, revs=None):
         super(gnuarch_source, self).__init__(ui, repotype, path, revs=revs)
 
-        if not os.path.exists(os.path.join(path, '{arch}')):
+        if not os.path.exists(os.path.join(path, b'{arch}')):
             raise common.NoRepo(
-                _("%s does not look like a GNU Arch repository") % path
+                _(b"%s does not look like a GNU Arch repository") % path
             )
 
         # Could use checktool, but we want to check for baz or tla.
         self.execmd = None
-        if procutil.findexe('baz'):
-            self.execmd = 'baz'
+        if procutil.findexe(b'baz'):
+            self.execmd = b'baz'
         else:
-            if procutil.findexe('tla'):
-                self.execmd = 'tla'
+            if procutil.findexe(b'tla'):
+                self.execmd = b'tla'
             else:
-                raise error.Abort(_('cannot find a GNU Arch tool'))
+                raise error.Abort(_(b'cannot find a GNU Arch tool'))
 
         common.commandline.__init__(self, ui, self.execmd)
 
@@ -76,19 +76,19 b' class gnuarch_source(common.converter_so'
     def before(self):
         # Get registered archives
         self.archives = [
-            i.rstrip('\n') for i in self.runlines0('archives', '-n')
+            i.rstrip(b'\n') for i in self.runlines0(b'archives', b'-n')
         ]
 
-        if self.execmd == 'tla':
-            output = self.run0('tree-version', self.path)
+        if self.execmd == b'tla':
+            output = self.run0(b'tree-version', self.path)
         else:
-            output = self.run0('tree-version', '-d', self.path)
+            output = self.run0(b'tree-version', b'-d', self.path)
         self.treeversion = output.strip()
 
         # Get name of temporary directory
-        version = self.treeversion.split('/')
+        version = self.treeversion.split(b'/')
         self.tmppath = os.path.join(
-            pycompat.fsencode(tempfile.gettempdir()), 'hg-%s' % version[1]
+            pycompat.fsencode(tempfile.gettempdir()), b'hg-%s' % version[1]
         )
 
         # Generate parents dictionary
@@ -96,23 +96,25 b' class gnuarch_source(common.converter_so'
         treeversion = self.treeversion
         child = None
         while treeversion:
-            self.ui.status(_('analyzing tree version %s...\n') % treeversion)
+            self.ui.status(_(b'analyzing tree version %s...\n') % treeversion)
 
-            archive = treeversion.split('/')[0]
+            archive = treeversion.split(b'/')[0]
             if archive not in self.archives:
                 self.ui.status(
                     _(
-                        'tree analysis stopped because it points to '
-                        'an unregistered archive %s...\n'
+                        b'tree analysis stopped because it points to '
+                        b'an unregistered archive %s...\n'
                     )
                     % archive
                 )
                 break
 
             # Get the complete list of revisions for that tree version
-            output, status = self.runlines('revisions', '-r', '-f', treeversion)
+            output, status = self.runlines(
+                b'revisions', b'-r', b'-f', treeversion
+            )
             self.checkexit(
-                status, 'failed retrieving revisions for %s' % treeversion
+                status, b'failed retrieving revisions for %s' % treeversion
             )
 
             # No new iteration unless a revision has a continuation-of header
@@ -124,9 +126,9 b' class gnuarch_source(common.converter_so'
                 self.parents[rev] = []
 
                 # Read author, date and summary
-                catlog, status = self.run('cat-log', '-d', self.path, rev)
+                catlog, status = self.run(b'cat-log', b'-d', self.path, rev)
                 if status:
-                    catlog = self.run0('cat-archive-log', rev)
+                    catlog = self.run0(b'cat-archive-log', rev)
                 self._parsecatlog(catlog, rev)
 
                 # Populate the parents map
@@ -140,18 +142,18 b' class gnuarch_source(common.converter_so'
                 # or if we have to 'jump' to a different treeversion given
                 # by the continuation-of header.
                 if self.changes[rev].continuationof:
-                    treeversion = '--'.join(
-                        self.changes[rev].continuationof.split('--')[:-1]
+                    treeversion = b'--'.join(
+                        self.changes[rev].continuationof.split(b'--')[:-1]
                     )
                     break
 
                 # If we reached a base-0 revision w/o any continuation-of
                 # header, it means the tree history ends here.
-                if rev[-6:] == 'base-0':
+                if rev[-6:] == b'base-0':
                     break
 
     def after(self):
-        self.ui.debug('cleaning up %s\n' % self.tmppath)
+        self.ui.debug(b'cleaning up %s\n' % self.tmppath)
         shutil.rmtree(self.tmppath, ignore_errors=True)
 
     def getheads(self):
@@ -159,7 +161,7 b' class gnuarch_source(common.converter_so'
 
     def getfile(self, name, rev):
         if rev != self.lastrev:
-            raise error.Abort(_('internal calling inconsistency'))
+            raise error.Abort(_(b'internal calling inconsistency'))
 
         if not os.path.lexists(os.path.join(self.tmppath, name)):
             return None, None
@@ -168,7 +170,7 b' class gnuarch_source(common.converter_so'
 
     def getchanges(self, rev, full):
         if full:
-            raise error.Abort(_("convert from arch does not support --full"))
+            raise error.Abort(_(b"convert from arch does not support --full"))
         self._update(rev)
         changes = []
         copies = {}
@@ -214,14 +216,14 b' class gnuarch_source(common.converter_so'
         cmdline = [self.execmd, cmd]
         cmdline += args
         cmdline = [procutil.shellquote(arg) for arg in cmdline]
-        cmdline += ['>', os.devnull, '2>', os.devnull]
-        cmdline = procutil.quotecommand(' '.join(cmdline))
-        self.ui.debug(cmdline, '\n')
+        cmdline += [b'>', os.devnull, b'2>', os.devnull]
+        cmdline = procutil.quotecommand(b' '.join(cmdline))
+        self.ui.debug(cmdline, b'\n')
         return os.system(pycompat.rapply(procutil.tonativestr, cmdline))
 
     def _update(self, rev):
-        self.ui.debug('applying revision %s...\n' % rev)
-        changeset, status = self.runlines('replay', '-d', self.tmppath, rev)
+        self.ui.debug(b'applying revision %s...\n' % rev)
+        changeset, status = self.runlines(b'replay', b'-d', self.tmppath, rev)
         if status:
             # Something went wrong while merging (baz or tla
             # issue?), get latest revision and try from there
@@ -230,7 +232,7 b' class gnuarch_source(common.converter_so'
         else:
             old_rev = self.parents[rev][0]
             self.ui.debug(
-                'computing changeset between %s and %s...\n' % (old_rev, rev)
+                b'computing changeset between %s and %s...\n' % (old_rev, rev)
             )
             self._parsechangeset(changeset, rev)
 
@@ -239,16 +241,16 b' class gnuarch_source(common.converter_so'
         if stat.S_ISLNK(mode):
             data = util.readlink(os.path.join(self.tmppath, name))
             if mode:
-                mode = 'l'
+                mode = b'l'
             else:
-                mode = ''
+                mode = b''
         else:
             data = util.readfile(os.path.join(self.tmppath, name))
-            mode = (mode & 0o111) and 'x' or ''
+            mode = (mode & 0o111) and b'x' or b''
         return data, mode
 
     def _exclude(self, name):
-        exclude = ['{arch}', '.arch-ids', '.arch-inventory']
+        exclude = [b'{arch}', b'.arch-ids', b'.arch-inventory']
         for exc in exclude:
             if name.find(exc) != -1:
                 return True
@@ -282,15 +284,15 b' class gnuarch_source(common.converter_so'
         return changes, copies
 
     def _obtainrevision(self, rev):
-        self.ui.debug('obtaining revision %s...\n' % rev)
-        output = self._execute('get', rev, self.tmppath)
+        self.ui.debug(b'obtaining revision %s...\n' % rev)
+        output = self._execute(b'get', rev, self.tmppath)
         self.checkexit(output)
-        self.ui.debug('analyzing revision %s...\n' % rev)
+        self.ui.debug(b'analyzing revision %s...\n' % rev)
         files = self._readcontents(self.tmppath)
         self.changes[rev].add_files += files
 
     def _stripbasepath(self, path):
-        if path.startswith('./'):
+        if path.startswith(b'./'):
             return path[2:]
         return path
 
@@ -300,73 +302,73 b' class gnuarch_source(common.converter_so'
 
             # Commit date
             self.changes[rev].date = dateutil.datestr(
-                dateutil.strdate(catlog['Standard-date'], '%Y-%m-%d %H:%M:%S')
+                dateutil.strdate(catlog[b'Standard-date'], b'%Y-%m-%d %H:%M:%S')
             )
 
             # Commit author
-            self.changes[rev].author = self.recode(catlog['Creator'])
+            self.changes[rev].author = self.recode(catlog[b'Creator'])
 
             # Commit description
-            self.changes[rev].summary = '\n\n'.join(
-                (catlog['Summary'], catlog.get_payload())
+            self.changes[rev].summary = b'\n\n'.join(
+                (catlog[b'Summary'], catlog.get_payload())
             )
             self.changes[rev].summary = self.recode(self.changes[rev].summary)
 
             # Commit revision origin when dealing with a branch or tag
-            if 'Continuation-of' in catlog:
+            if b'Continuation-of' in catlog:
                 self.changes[rev].continuationof = self.recode(
-                    catlog['Continuation-of']
+                    catlog[b'Continuation-of']
                 )
         except Exception:
-            raise error.Abort(_('could not parse cat-log of %s') % rev)
+            raise error.Abort(_(b'could not parse cat-log of %s') % rev)
 
     def _parsechangeset(self, data, rev):
         for l in data:
             l = l.strip()
             # Added file (ignore added directory)
-            if l.startswith('A') and not l.startswith('A/'):
+            if l.startswith(b'A') and not l.startswith(b'A/'):
                 file = self._stripbasepath(l[1:].strip())
                 if not self._exclude(file):
                     self.changes[rev].add_files.append(file)
             # Deleted file (ignore deleted directory)
-            elif l.startswith('D') and not l.startswith('D/'):
+            elif l.startswith(b'D') and not l.startswith(b'D/'):
                 file = self._stripbasepath(l[1:].strip())
                 if not self._exclude(file):
                     self.changes[rev].del_files.append(file)
             # Modified binary file
-            elif l.startswith('Mb'):
+            elif l.startswith(b'Mb'):
                 file = self._stripbasepath(l[2:].strip())
                 if not self._exclude(file):
                     self.changes[rev].mod_files.append(file)
             # Modified link
-            elif l.startswith('M->'):
+            elif l.startswith(b'M->'):
                 file = self._stripbasepath(l[3:].strip())
                 if not self._exclude(file):
                     self.changes[rev].mod_files.append(file)
             # Modified file
-            elif l.startswith('M'):
+            elif l.startswith(b'M'):
                 file = self._stripbasepath(l[1:].strip())
                 if not self._exclude(file):
                     self.changes[rev].mod_files.append(file)
             # Renamed file (or link)
-            elif l.startswith('=>'):
-                files = l[2:].strip().split(' ')
+            elif l.startswith(b'=>'):
+                files = l[2:].strip().split(b' ')
                 if len(files) == 1:
-                    files = l[2:].strip().split('\t')
+                    files = l[2:].strip().split(b'\t')
                 src = self._stripbasepath(files[0])
                 dst = self._stripbasepath(files[1])
                 if not self._exclude(src) and not self._exclude(dst):
                     self.changes[rev].ren_files[src] = dst
             # Conversion from file to link or from link to file (modified)
-            elif l.startswith('ch'):
+            elif l.startswith(b'ch'):
                 file = self._stripbasepath(l[2:].strip())
                 if not self._exclude(file):
                     self.changes[rev].mod_files.append(file)
             # Renamed directory
-            elif l.startswith('/>'):
-                dirs = l[2:].strip().split(' ')
+            elif l.startswith(b'/>'):
+                dirs = l[2:].strip().split(b' ')
                 if len(dirs) == 1:
-                    dirs = l[2:].strip().split('\t')
+                    dirs = l[2:].strip().split(b'\t')
                 src = self._stripbasepath(dirs[0])
                 dst = self._stripbasepath(dirs[1])
                 if not self._exclude(src) and not self._exclude(dst):

hgext/convert/hg.py

@@ -51,33 +51,33 b" sha1re = re.compile(br'\\b[0-9a-f]{12,40}"
 class mercurial_sink(common.converter_sink):
     def __init__(self, ui, repotype, path):
         common.converter_sink.__init__(self, ui, repotype, path)
-        self.branchnames = ui.configbool('convert', 'hg.usebranchnames')
-        self.clonebranches = ui.configbool('convert', 'hg.clonebranches')
-        self.tagsbranch = ui.config('convert', 'hg.tagsbranch')
+        self.branchnames = ui.configbool(b'convert', b'hg.usebranchnames')
+        self.clonebranches = ui.configbool(b'convert', b'hg.clonebranches')
+        self.tagsbranch = ui.config(b'convert', b'hg.tagsbranch')
         self.lastbranch = None
         if os.path.isdir(path) and len(os.listdir(path)) > 0:
             try:
                 self.repo = hg.repository(self.ui, path)
                 if not self.repo.local():
                     raise NoRepo(
-                        _('%s is not a local Mercurial repository') % path
+                        _(b'%s is not a local Mercurial repository') % path
                     )
             except error.RepoError as err:
                 ui.traceback()
                 raise NoRepo(err.args[0])
         else:
             try:
-                ui.status(_('initializing destination %s repository\n') % path)
+                ui.status(_(b'initializing destination %s repository\n') % path)
                 self.repo = hg.repository(self.ui, path, create=True)
                 if not self.repo.local():
                     raise NoRepo(
-                        _('%s is not a local Mercurial repository') % path
+                        _(b'%s is not a local Mercurial repository') % path
                     )
                 self.created.append(path)
             except error.RepoError:
                 ui.traceback()
                 raise NoRepo(
-                    _("could not create hg repository %s as sink") % path
+                    _(b"could not create hg repository %s as sink") % path
                 )
         self.lock = None
         self.wlock = None
@@ -85,22 +85,22 b' class mercurial_sink(common.converter_si'
         self.subrevmaps = {}
 
     def before(self):
-        self.ui.debug('run hg sink pre-conversion action\n')
+        self.ui.debug(b'run hg sink pre-conversion action\n')
         self.wlock = self.repo.wlock()
         self.lock = self.repo.lock()
 
     def after(self):
-        self.ui.debug('run hg sink post-conversion action\n')
+        self.ui.debug(b'run hg sink post-conversion action\n')
         if self.lock:
             self.lock.release()
         if self.wlock:
             self.wlock.release()
 
     def revmapfile(self):
-        return self.repo.vfs.join("shamap")
+        return self.repo.vfs.join(b"shamap")
 
     def authorfile(self):
-        return self.repo.vfs.join("authormap")
+        return self.repo.vfs.join(b"authormap")
 
     def setbranch(self, branch, pbranches):
         if not self.clonebranches:
@@ -109,8 +109,8 b' class mercurial_sink(common.converter_si'
         setbranch = branch != self.lastbranch
         self.lastbranch = branch
         if not branch:
-            branch = 'default'
-        pbranches = [(b[0], b[1] and b[1] or 'default') for b in pbranches]
+            branch = b'default'
+        pbranches = [(b[0], b[1] and b[1] or b'default') for b in pbranches]
 
         branchpath = os.path.join(self.path, branch)
         if setbranch:
@@ -135,7 +135,9 b' class mercurial_sink(common.converter_si'
             for pbranch, heads in sorted(missings.iteritems()):
                 pbranchpath = os.path.join(self.path, pbranch)
                 prepo = hg.peer(self.ui, {}, pbranchpath)
-                self.ui.note(_('pulling from %s into %s\n') % (pbranch, branch))
+                self.ui.note(
+                    _(b'pulling from %s into %s\n') % (pbranch, branch)
+                )
                 exchange.pull(
                     self.repo, prepo, [prepo.lookup(h) for h in heads]
                 )
@@ -144,10 +146,10 b' class mercurial_sink(common.converter_si'
     def _rewritetags(self, source, revmap, data):
         fp = stringio()
         for line in data.splitlines():
-            s = line.split(' ', 1)
+            s = line.split(b' ', 1)
             if len(s) != 2:
-                self.ui.warn(_('invalid tag entry: "%s"\n') % line)
-                fp.write('%s\n' % line)  # Bogus, but keep for hash stability
+                self.ui.warn(_(b'invalid tag entry: "%s"\n') % line)
+                fp.write(b'%s\n' % line)  # Bogus, but keep for hash stability
                 continue
             revid = revmap.get(source.lookuprev(s[0]))
             if not revid:
@@ -155,16 +157,16 b' class mercurial_sink(common.converter_si'
                     revid = s[0]
                 else:
                     # missing, but keep for hash stability
-                    self.ui.warn(_('missing tag entry: "%s"\n') % line)
-                    fp.write('%s\n' % line)
+                    self.ui.warn(_(b'missing tag entry: "%s"\n') % line)
+                    fp.write(b'%s\n' % line)
                     continue
-            fp.write('%s %s\n' % (revid, s[1]))
+            fp.write(b'%s %s\n' % (revid, s[1]))
         return fp.getvalue()
 
     def _rewritesubstate(self, source, data):
         fp = stringio()
         for line in data.splitlines():
-            s = line.split(' ', 1)
+            s = line.split(b' ', 1)
             if len(s) != 2:
                 continue
 
@@ -174,7 +176,7 b' class mercurial_sink(common.converter_si'
                 revmap = self.subrevmaps.get(subpath)
                 if revmap is None:
                     revmap = mapfile(
-                        self.ui, self.repo.wjoin(subpath, '.hg/shamap')
+                        self.ui, self.repo.wjoin(subpath, b'.hg/shamap')
                     )
                     self.subrevmaps[subpath] = revmap
 
@@ -182,9 +184,9 b' class mercurial_sink(common.converter_si'
                     # need to be converted, in which case they can be cloned
                     # into place instead of converted.  Therefore, only warn
                     # once.
-                    msg = _('no ".hgsubstate" updates will be made for "%s"\n')
+                    msg = _(b'no ".hgsubstate" updates will be made for "%s"\n')
                     if len(revmap) == 0:
-                        sub = self.repo.wvfs.reljoin(subpath, '.hg')
+                        sub = self.repo.wvfs.reljoin(subpath, b'.hg')
 
                         if self.repo.wvfs.exists(sub):
                             self.ui.warn(msg % subpath)
@@ -193,13 +195,13 b' class mercurial_sink(common.converter_si'
                 if not newid:
                     if len(revmap) > 0:
                         self.ui.warn(
-                            _("%s is missing from %s/.hg/shamap\n")
+                            _(b"%s is missing from %s/.hg/shamap\n")
                             % (revid, subpath)
                         )
                 else:
                     revid = newid
 
-            fp.write('%s %s\n' % (revid, subpath))
+            fp.write(b'%s %s\n' % (revid, subpath))
 
         return fp.getvalue()
 
@@ -232,16 +234,16 b' class mercurial_sink(common.converter_si'
 
             # If the file requires actual merging, abort. We don't have enough
             # context to resolve merges correctly.
-            if action in ['m', 'dm', 'cd', 'dc']:
+            if action in [b'm', b'dm', b'cd', b'dc']:
                 raise error.Abort(
                     _(
-                        "unable to convert merge commit "
-                        "since target parents do not merge cleanly (file "
-                        "%s, parents %s and %s)"
+                        b"unable to convert merge commit "
+                        b"since target parents do not merge cleanly (file "
+                        b"%s, parents %s and %s)"
                     )
                     % (file, p1ctx, p2ctx)
                 )
-            elif action == 'k':
+            elif action == b'k':
                 # 'keep' means nothing changed from p1
                 continue
             else:
@@ -255,7 +257,7 b' class mercurial_sink(common.converter_si'
 
         def getfilectx(repo, memctx, f):
             if p2ctx and f in p2files and f not in copies:
-                self.ui.debug('reusing %s from p2\n' % f)
+                self.ui.debug(b'reusing %s from p2\n' % f)
                 try:
                     return p2ctx[f]
                 except error.ManifestLookupError:
@@ -269,17 +271,17 b' class mercurial_sink(common.converter_si'
             data, mode = source.getfile(f, v)
             if data is None:
                 return None
-            if f == '.hgtags':
+            if f == b'.hgtags':
                 data = self._rewritetags(source, revmap, data)
-            if f == '.hgsubstate':
+            if f == b'.hgsubstate':
                 data = self._rewritesubstate(source, data)
             return context.memfilectx(
                 self.repo,
                 memctx,
                 f,
                 data,
-                'l' in mode,
-                'x' in mode,
+                b'l' in mode,
+                b'x' in mode,
                 copies.get(f),
             )
 
@@ -310,15 +312,15 b' class mercurial_sink(common.converter_si'
 
         extra = commit.extra.copy()
 
-        sourcename = self.repo.ui.config('convert', 'hg.sourcename')
+        sourcename = self.repo.ui.config(b'convert', b'hg.sourcename')
         if sourcename:
-            extra['convert_source'] = sourcename
+            extra[b'convert_source'] = sourcename
 
         for label in (
-            'source',
-            'transplant_source',
-            'rebase_source',
-            'intermediate-source',
+            b'source',
+            b'transplant_source',
+            b'rebase_source',
+            b'intermediate-source',
         ):
             node = extra.get(label)
 
@@ -326,20 +328,20 b' class mercurial_sink(common.converter_si'
                 continue
 
             # Only transplant stores its reference in binary
-            if label == 'transplant_source':
+            if label == b'transplant_source':
                 node = nodemod.hex(node)
 
             newrev = revmap.get(node)
             if newrev is not None:
-                if label == 'transplant_source':
+                if label == b'transplant_source':
                     newrev = nodemod.bin(newrev)
 
                 extra[label] = newrev
 
         if self.branchnames and commit.branch:
-            extra['branch'] = commit.branch
+            extra[b'branch'] = commit.branch
         if commit.rev and commit.saverev:
-            extra['convert_revision'] = commit.rev
+            extra[b'convert_revision'] = commit.rev
 
         while parents:
             p1 = p2
@@ -373,14 +375,14 b' class mercurial_sink(common.converter_si'
             # We won't know if the conversion changes the node until after the
             # commit, so copy the source's phase for now.
             self.repo.ui.setconfig(
-                'phases',
-                'new-commit',
+                b'phases',
+                b'new-commit',
                 phases.phasenames[commit.phase],
-                'convert',
+                b'convert',
             )
 
-            with self.repo.transaction("convert") as tr:
-                if self.repo.ui.config('convert', 'hg.preserve-hash'):
+            with self.repo.transaction(b"convert") as tr:
+                if self.repo.ui.config(b'convert', b'hg.preserve-hash'):
                     origctx = commit.ctx
                 else:
                     origctx = None
@@ -396,15 +398,15 b' class mercurial_sink(common.converter_si'
                             self.repo, tr, phases.draft, [ctx.node()]
                         )
 
-            text = "(octopus merge fixup)\n"
+            text = b"(octopus merge fixup)\n"
             p2 = node
 
         if self.filemapmode and nparents == 1:
             man = self.repo.manifestlog.getstorage(b'')
             mnode = self.repo.changelog.read(nodemod.bin(p2))[0]
-            closed = 'close' in commit.extra
+            closed = b'close' in commit.extra
             if not closed and not man.cmp(m1node, man.revision(mnode)):
-                self.ui.status(_("filtering out empty revision\n"))
+                self.ui.status(_(b"filtering out empty revision\n"))
                 self.repo.rollback(force=True)
                 return parent
         return p2
@@ -416,13 +418,13 b' class mercurial_sink(common.converter_si'
         oldlines = set()
         for branch, heads in self.repo.branchmap().iteritems():
             for h in heads:
-                if '.hgtags' in self.repo[h]:
+                if b'.hgtags' in self.repo[h]:
                     oldlines.update(
-                        set(self.repo[h]['.hgtags'].data().splitlines(True))
+                        set(self.repo[h][b'.hgtags'].data().splitlines(True))
                     )
         oldlines = sorted(list(oldlines))
 
-        newlines = sorted([("%s %s\n" % (tags[tag], tag)) for tag in tags])
+        newlines = sorted([(b"%s %s\n" % (tags[tag], tag)) for tag in tags])
         if newlines == oldlines:
             return None, None
 
@@ -430,12 +432,12 b' class mercurial_sink(common.converter_si'
         oldtags = set()
         newtags = set()
         for line in oldlines:
-            s = line.strip().split(' ', 1)
+            s = line.strip().split(b' ', 1)
             if len(s) != 2:
                 continue
             oldtags.add(s[1])
         for line in newlines:
-            s = line.strip().split(' ', 1)
+            s = line.strip().split(b' ', 1)
             if len(s) != 2:
                 continue
             if s[1] not in oldtags:
@@ -444,21 +446,21 b' class mercurial_sink(common.converter_si'
         if not newtags:
             return None, None
 
-        data = "".join(newlines)
+        data = b"".join(newlines)
 
         def getfilectx(repo, memctx, f):
             return context.memfilectx(repo, memctx, f, data, False, False, None)
 
-        self.ui.status(_("updating tags\n"))
-        date = "%d 0" % int(time.mktime(time.gmtime()))
-        extra = {'branch': self.tagsbranch}
+        self.ui.status(_(b"updating tags\n"))
+        date = b"%d 0" % int(time.mktime(time.gmtime()))
+        extra = {b'branch': self.tagsbranch}
         ctx = context.memctx(
             self.repo,
             (tagparent, None),
-            "update tags",
-            [".hgtags"],
+            b"update tags",
+            [b".hgtags"],
             getfilectx,
-            "convert-repo",
+            b"convert-repo",
             date,
             extra,
         )
@@ -475,8 +477,8 b' class mercurial_sink(common.converter_si'
         try:
             wlock = self.repo.wlock()
             lock = self.repo.lock()
-            tr = self.repo.transaction('bookmark')
-            self.ui.status(_("updating bookmarks\n"))
+            tr = self.repo.transaction(b'bookmark')
+            self.ui.status(_(b"updating bookmarks\n"))
             destmarks = self.repo._bookmarks
             changes = [
                 (bookmark, nodemod.bin(updatedbookmark[bookmark]))
@@ -495,9 +497,9 b' class mercurial_sink(common.converter_si'
         if rev not in self.repo and self.clonebranches:
             raise error.Abort(
                 _(
-                    'revision %s not found in destination '
-                    'repository (lookups with clonebranches=true '
-                    'are not implemented)'
+                    b'revision %s not found in destination '
+                    b'repository (lookups with clonebranches=true '
+                    b'are not implemented)'
                 )
                 % rev
             )
@@ -507,9 +509,9 b' class mercurial_sink(common.converter_si'
 class mercurial_source(common.converter_source):
     def __init__(self, ui, repotype, path, revs=None):
         common.converter_source.__init__(self, ui, repotype, path, revs)
-        self.ignoreerrors = ui.configbool('convert', 'hg.ignoreerrors')
+        self.ignoreerrors = ui.configbool(b'convert', b'hg.ignoreerrors')
         self.ignored = set()
-        self.saverev = ui.configbool('convert', 'hg.saverev')
+        self.saverev = ui.configbool(b'convert', b'hg.saverev')
         try:
             self.repo = hg.repository(self.ui, path)
             # try to provoke an exception if this isn't really a hg
@@ -518,21 +520,21 b' class mercurial_source(common.converter_'
                 raise error.RepoError
         except error.RepoError:
             ui.traceback()
-            raise NoRepo(_("%s is not a local Mercurial repository") % path)
+            raise NoRepo(_(b"%s is not a local Mercurial repository") % path)
         self.lastrev = None
         self.lastctx = None
         self._changescache = None, None
         self.convertfp = None
         # Restrict converted revisions to startrev descendants
-        startnode = ui.config('convert', 'hg.startrev')
-        hgrevs = ui.config('convert', 'hg.revs')
+        startnode = ui.config(b'convert', b'hg.startrev')
+        hgrevs = ui.config(b'convert', b'hg.revs')
         if hgrevs is None:
             if startnode is not None:
                 try:
                     startnode = self.repo.lookup(startnode)
                 except error.RepoError:
                     raise error.Abort(
-                        _('%s is not a valid start revision') % startnode
+                        _(b'%s is not a valid start revision') % startnode
                     )
                 startrev = self.repo.changelog.rev(startnode)
                 children = {startnode: 1}
@@ -548,7 +550,10 b' class mercurial_source(common.converter_'
         else:
             if revs or startnode is not None:
                 raise error.Abort(
-                    _('hg.revs cannot be combined with ' 'hg.startrev or --rev')
+                    _(
+                        b'hg.revs cannot be combined with '
+                        b'hg.startrev or --rev'
+                    )
                 )
             nodes = set()
             parents = set()
@@ -635,7 +640,7 b' class mercurial_source(common.converter_'
                 if not self.ignoreerrors:
                     raise
                 self.ignored.add(name)
-                self.ui.warn(_('ignoring: %s\n') % e)
+                self.ui.warn(_(b'ignoring: %s\n') % e)
         return copies
 
     def getcommit(self, rev):
@@ -647,7 +652,7 b' class mercurial_source(common.converter_'
 
         return common.commit(
             author=ctx.user(),
-            date=dateutil.datestr(ctx.date(), '%Y-%m-%d %H:%M:%S %1%2'),
+            date=dateutil.datestr(ctx.date(), b'%Y-%m-%d %H:%M:%S %1%2'),
             desc=ctx.description(),
             rev=crev,
             parents=parents,
@@ -668,7 +673,7 b' class mercurial_source(common.converter_'
         tags = [
             t
             for t in self.repo.tagslist()
-            if self.repo.tagtype(t[0]) == 'global'
+            if self.repo.tagtype(t[0]) == b'global'
         ]
         return dict(
             [
@@ -696,15 +701,15 b' class mercurial_source(common.converter_'
 
     def converted(self, rev, destrev):
         if self.convertfp is None:
-            self.convertfp = open(self.repo.vfs.join('shamap'), 'ab')
-        self.convertfp.write(util.tonativeeol('%s %s\n' % (destrev, rev)))
+            self.convertfp = open(self.repo.vfs.join(b'shamap'), b'ab')
+        self.convertfp.write(util.tonativeeol(b'%s %s\n' % (destrev, rev)))
         self.convertfp.flush()
 
     def before(self):
-        self.ui.debug('run hg source pre-conversion action\n')
+        self.ui.debug(b'run hg source pre-conversion action\n')
 
     def after(self):
-        self.ui.debug('run hg source post-conversion action\n')
+        self.ui.debug(b'run hg source post-conversion action\n')
 
     def hasnativeorder(self):
         return True
@@ -721,6 +726,6 b' class mercurial_source(common.converter_'
     def getbookmarks(self):
         return bookmarks.listbookmarks(self.repo)
 
-    def checkrevformat(self, revstr, mapname='splicemap'):
+    def checkrevformat(self, revstr, mapname=b'splicemap'):
         """ Mercurial, revision string is a 40 byte hex """
         self.checkhexformat(revstr, mapname)

hgext/convert/monotone.py

@@ -26,11 +26,11 b' class monotone_source(common.converter_s'
         if revs and len(revs) > 1:
             raise error.Abort(
                 _(
-                    'monotone source does not support specifying '
-                    'multiple revs'
+                    b'monotone source does not support specifying '
+                    b'multiple revs'
                 )
             )
-        common.commandline.__init__(self, ui, 'mtn')
+        common.commandline.__init__(self, ui, b'mtn')
 
         self.ui = ui
         self.path = path
@@ -38,17 +38,17 b' class monotone_source(common.converter_s'
         self.revs = revs
 
         norepo = common.NoRepo(
-            _("%s does not look like a monotone repository") % path
+            _(b"%s does not look like a monotone repository") % path
         )
-        if not os.path.exists(os.path.join(path, '_MTN')):
+        if not os.path.exists(os.path.join(path, b'_MTN')):
             # Could be a monotone repository (SQLite db file)
             try:
-                f = open(path, 'rb')
+                f = open(path, b'rb')
                 header = f.read(16)
                 f.close()
             except IOError:
-                header = ''
-            if header != 'SQLite format 3\x00':
+                header = b''
+            if header != b'SQLite format 3\x00':
                 raise norepo
 
         # regular expressions for parsing monotone output
@@ -58,24 +58,26 b' class monotone_source(common.converter_s'
         revision = br'\s+\[(\w+)\]\s*'
         lines = br'(?:.|\n)+'
 
-        self.dir_re = re.compile(space + "dir" + name)
-        self.file_re = re.compile(space + "file" + name + "content" + revision)
+        self.dir_re = re.compile(space + b"dir" + name)
+        self.file_re = re.compile(
+            space + b"file" + name + b"content" + revision
+        )
         self.add_file_re = re.compile(
-            space + "add_file" + name + "content" + revision
+            space + b"add_file" + name + b"content" + revision
         )
         self.patch_re = re.compile(
-            space + "patch" + name + "from" + revision + "to" + revision
+            space + b"patch" + name + b"from" + revision + b"to" + revision
         )
-        self.rename_re = re.compile(space + "rename" + name + "to" + name)
-        self.delete_re = re.compile(space + "delete" + name)
-        self.tag_re = re.compile(space + "tag" + name + "revision" + revision)
+        self.rename_re = re.compile(space + b"rename" + name + b"to" + name)
+        self.delete_re = re.compile(space + b"delete" + name)
+        self.tag_re = re.compile(space + b"tag" + name + b"revision" + revision)
         self.cert_re = re.compile(
-            lines + space + "name" + name + "value" + value
+            lines + space + b"name" + name + b"value" + value
         )
 
-        attr = space + "file" + lines + space + "attr" + space
+        attr = space + b"file" + lines + space + b"attr" + space
         self.attr_execute_re = re.compile(
-            attr + '"mtn:execute"' + space + '"true"'
+            attr + b'"mtn:execute"' + space + b'"true"'
         )
 
         # cached data
@@ -84,7 +86,7 b' class monotone_source(common.converter_s'
         self.files = None
         self.dirs = None
 
-        common.checktool('mtn', abort=False)
+        common.checktool(b'mtn', abort=False)
 
     def mtnrun(self, *args, **kwargs):
         if self.automatestdio:
@@ -94,27 +96,27 b' class monotone_source(common.converter_s'
 
     def mtnrunsingle(self, *args, **kwargs):
         kwargs[r'd'] = self.path
-        return self.run0('automate', *args, **kwargs)
+        return self.run0(b'automate', *args, **kwargs)
 
     def mtnrunstdio(self, *args, **kwargs):
         # Prepare the command in automate stdio format
         kwargs = pycompat.byteskwargs(kwargs)
         command = []
         for k, v in kwargs.iteritems():
-            command.append("%d:%s" % (len(k), k))
+            command.append(b"%d:%s" % (len(k), k))
             if v:
-                command.append("%d:%s" % (len(v), v))
+                command.append(b"%d:%s" % (len(v), v))
         if command:
-            command.insert(0, 'o')
-            command.append('e')
+            command.insert(0, b'o')
+            command.append(b'e')
 
-        command.append('l')
+        command.append(b'l')
         for arg in args:
-            command.append("%d:%s" % (len(arg), arg))
-        command.append('e')
-        command = ''.join(command)
+            command.append(b"%d:%s" % (len(arg), arg))
+        command.append(b'e')
+        command = b''.join(command)
 
-        self.ui.debug("mtn: sending '%s'\n" % command)
+        self.ui.debug(b"mtn: sending '%s'\n" % command)
         self.mtnwritefp.write(command)
         self.mtnwritefp.flush()
 
@@ -122,42 +124,44 b' class monotone_source(common.converter_s'
 
     def mtnstdioreadpacket(self):
         read = None
-        commandnbr = ''
-        while read != ':':
+        commandnbr = b''
+        while read != b':':
             read = self.mtnreadfp.read(1)
             if not read:
-                raise error.Abort(_('bad mtn packet - no end of commandnbr'))
+                raise error.Abort(_(b'bad mtn packet - no end of commandnbr'))
             commandnbr += read
         commandnbr = commandnbr[:-1]
 
         stream = self.mtnreadfp.read(1)
-        if stream not in 'mewptl':
-            raise error.Abort(_('bad mtn packet - bad stream type %s') % stream)
+        if stream not in b'mewptl':
+            raise error.Abort(
+                _(b'bad mtn packet - bad stream type %s') % stream
+            )
 
         read = self.mtnreadfp.read(1)
-        if read != ':':
-            raise error.Abort(_('bad mtn packet - no divider before size'))
+        if read != b':':
+            raise error.Abort(_(b'bad mtn packet - no divider before size'))
 
         read = None
-        lengthstr = ''
-        while read != ':':
+        lengthstr = b''
+        while read != b':':
             read = self.mtnreadfp.read(1)
             if not read:
-                raise error.Abort(_('bad mtn packet - no end of packet size'))
+                raise error.Abort(_(b'bad mtn packet - no end of packet size'))
             lengthstr += read
         try:
             length = pycompat.long(lengthstr[:-1])
         except TypeError:
             raise error.Abort(
-                _('bad mtn packet - bad packet size %s') % lengthstr
+                _(b'bad mtn packet - bad packet size %s') % lengthstr
             )
 
         read = self.mtnreadfp.read(length)
         if len(read) != length:
             raise error.Abort(
                 _(
-                    "bad mtn packet - unable to read full packet "
-                    "read %s of %s"
+                    b"bad mtn packet - unable to read full packet "
+                    b"read %s of %s"
                 )
                 % (len(read), length)
             )
@@ -169,33 +173,33 b' class monotone_source(common.converter_s'
         while True:
             commandnbr, stream, length, output = self.mtnstdioreadpacket()
             self.ui.debug(
-                'mtn: read packet %s:%s:%d\n' % (commandnbr, stream, length)
+                b'mtn: read packet %s:%s:%d\n' % (commandnbr, stream, length)
             )
 
-            if stream == 'l':
+            if stream == b'l':
                 # End of command
-                if output != '0':
+                if output != b'0':
                     raise error.Abort(
-                        _("mtn command '%s' returned %s") % (command, output)
+                        _(b"mtn command '%s' returned %s") % (command, output)
                     )
                 break
-            elif stream in 'ew':
+            elif stream in b'ew':
                 # Error, warning output
-                self.ui.warn(_('%s error:\n') % self.command)
+                self.ui.warn(_(b'%s error:\n') % self.command)
                 self.ui.warn(output)
-            elif stream == 'p':
+            elif stream == b'p':
                 # Progress messages
-                self.ui.debug('mtn: ' + output)
-            elif stream == 'm':
+                self.ui.debug(b'mtn: ' + output)
+            elif stream == b'm':
                 # Main stream - command output
                 retval.append(output)
 
-        return ''.join(retval)
+        return b''.join(retval)
 
     def mtnloadmanifest(self, rev):
         if self.manifest_rev == rev:
             return
-        self.manifest = self.mtnrun("get_manifest_of", rev).split("\n\n")
+        self.manifest = self.mtnrun(b"get_manifest_of", rev).split(b"\n\n")
         self.manifest_rev = rev
         self.files = {}
         self.dirs = {}
@@ -203,11 +207,11 b' class monotone_source(common.converter_s'
         for e in self.manifest:
             m = self.file_re.match(e)
             if m:
-                attr = ""
+                attr = b""
                 name = m.group(1)
                 node = m.group(2)
                 if self.attr_execute_re.match(e):
-                    attr += "x"
+                    attr += b"x"
                 self.files[name] = (node, attr)
             m = self.dir_re.match(e)
             if m:
@@ -224,12 +228,12 b' class monotone_source(common.converter_s'
 
     def mtngetcerts(self, rev):
         certs = {
-            "author": "<missing>",
-            "date": "<missing>",
-            "changelog": "<missing>",
-            "branch": "<missing>",
+            b"author": b"<missing>",
+            b"date": b"<missing>",
+            b"changelog": b"<missing>",
+            b"branch": b"<missing>",
         }
-        certlist = self.mtnrun("certs", rev)
+        certlist = self.mtnrun(b"certs", rev)
         # mtn < 0.45:
         #   key "[e-mail]"
         # mtn >= 0.45:
@@ -239,28 +243,28 b' class monotone_source(common.converter_s'
             m = self.cert_re.match(e)
             if m:
                 name, value = m.groups()
-                value = value.replace(br'\"', '"')
-                value = value.replace(br'\\', '\\')
+                value = value.replace(br'\"', b'"')
+                value = value.replace(br'\\', b'\\')
                 certs[name] = value
         # Monotone may have subsecond dates: 2005-02-05T09:39:12.364306
         # and all times are stored in UTC
-        certs["date"] = certs["date"].split('.')[0] + " UTC"
+        certs[b"date"] = certs[b"date"].split(b'.')[0] + b" UTC"
         return certs
 
     # implement the converter_source interface:
 
     def getheads(self):
         if not self.revs:
-            return self.mtnrun("leaves").splitlines()
+            return self.mtnrun(b"leaves").splitlines()
         else:
             return self.revs
 
     def getchanges(self, rev, full):
         if full:
             raise error.Abort(
-                _("convert from monotone does not support " "--full")
+                _(b"convert from monotone does not support " b"--full")
             )
-        revision = self.mtnrun("get_revision", rev).split("\n\n")
+        revision = self.mtnrun(b"get_revision", rev).split(b"\n\n")
         files = {}
         ignoremove = {}
         renameddirs = []
@@ -298,7 +302,7 b' class monotone_source(common.converter_s'
             for tofile in self.files:
                 if tofile in ignoremove:
                     continue
-                if tofile.startswith(todir + '/'):
+                if tofile.startswith(todir + b'/'):
                     renamed[tofile] = fromdir + tofile[len(todir) :]
                     # Avoid chained moves like:
                     # d1(/a) => d3/d1(/a)
@@ -306,9 +310,9 b' class monotone_source(common.converter_s'
                     ignoremove[tofile] = 1
             for tofile, fromfile in renamed.items():
                 self.ui.debug(
-                    "copying file in renamed directory from '%s' to '%s'"
+                    b"copying file in renamed directory from '%s' to '%s'"
                     % (fromfile, tofile),
-                    '\n',
+                    b'\n',
                 )
                 files[tofile] = rev
                 copies[tofile] = fromfile
@@ -321,32 +325,32 b' class monotone_source(common.converter_s'
         if not self.mtnisfile(name, rev):
             return None, None
         try:
-            data = self.mtnrun("get_file_of", name, r=rev)
+            data = self.mtnrun(b"get_file_of", name, r=rev)
         except Exception:
             return None, None
         self.mtnloadmanifest(rev)
-        node, attr = self.files.get(name, (None, ""))
+        node, attr = self.files.get(name, (None, b""))
         return data, attr
 
     def getcommit(self, rev):
         extra = {}
         certs = self.mtngetcerts(rev)
-        if certs.get('suspend') == certs["branch"]:
-            extra['close'] = 1
-        dateformat = "%Y-%m-%dT%H:%M:%S"
+        if certs.get(b'suspend') == certs[b"branch"]:
+            extra[b'close'] = 1
+        dateformat = b"%Y-%m-%dT%H:%M:%S"
         return common.commit(
-            author=certs["author"],
-            date=dateutil.datestr(dateutil.strdate(certs["date"], dateformat)),
-            desc=certs["changelog"],
+            author=certs[b"author"],
+            date=dateutil.datestr(dateutil.strdate(certs[b"date"], dateformat)),
+            desc=certs[b"changelog"],
             rev=rev,
-            parents=self.mtnrun("parents", rev).splitlines(),
-            branch=certs["branch"],
+            parents=self.mtnrun(b"parents", rev).splitlines(),
+            branch=certs[b"branch"],
             extra=extra,
         )
 
     def gettags(self):
         tags = {}
-        for e in self.mtnrun("tags").split("\n\n"):
+        for e in self.mtnrun(b"tags").split(b"\n\n"):
             m = self.tag_re.match(e)
             if m:
                 tags[m.group(1)] = m.group(2)
@@ -360,42 +364,42 b' class monotone_source(common.converter_s'
     def before(self):
         # Check if we have a new enough version to use automate stdio
         try:
-            versionstr = self.mtnrunsingle("interface_version")
+            versionstr = self.mtnrunsingle(b"interface_version")
             version = float(versionstr)
         except Exception:
             raise error.Abort(
-                _("unable to determine mtn automate interface " "version")
+                _(b"unable to determine mtn automate interface " b"version")
             )
 
         if version >= 12.0:
             self.automatestdio = True
             self.ui.debug(
-                "mtn automate version %f - using automate stdio\n" % version
+                b"mtn automate version %f - using automate stdio\n" % version
             )
 
             # launch the long-running automate stdio process
             self.mtnwritefp, self.mtnreadfp = self._run2(
-                'automate', 'stdio', '-d', self.path
+                b'automate', b'stdio', b'-d', self.path
             )
             # read the headers
             read = self.mtnreadfp.readline()
-            if read != 'format-version: 2\n':
+            if read != b'format-version: 2\n':
                 raise error.Abort(
-                    _('mtn automate stdio header unexpected: %s') % read
+                    _(b'mtn automate stdio header unexpected: %s') % read
                 )
-            while read != '\n':
+            while read != b'\n':
                 read = self.mtnreadfp.readline()
                 if not read:
                     raise error.Abort(
                         _(
-                            "failed to reach end of mtn automate "
-                            "stdio headers"
+                            b"failed to reach end of mtn automate "
+                            b"stdio headers"
                         )
                     )
         else:
             self.ui.debug(
-                "mtn automate version %s - not using automate stdio "
-                "(automate >= 12.0 - mtn >= 0.46 is needed)\n" % version
+                b"mtn automate version %s - not using automate stdio "
+                b"(automate >= 12.0 - mtn >= 0.46 is needed)\n" % version
             )
 
     def after(self):

hgext/convert/p4.py

@@ -24,7 +24,7 b' from . import common'
 
 
 def loaditer(f):
-    "Yield the dictionary objects generated by p4"
+    b"Yield the dictionary objects generated by p4"
     try:
         while True:
             d = marshal.load(f)
@@ -44,7 +44,12 b' def decodefilename(filename):'
     >>> decodefilename(b'//Depot/Directory/%2525/%2523/%23%40.%2A')
     '//Depot/Directory/%25/%23/#@.*'
     """
-    replacements = [('%2A', '*'), ('%23', '#'), ('%40', '@'), ('%25', '%')]
+    replacements = [
+        (b'%2A', b'*'),
+        (b'%23', b'#'),
+        (b'%40', b'@'),
+        (b'%25', b'%'),
+    ]
     for k, v in replacements:
         filename = filename.replace(k, v)
     return filename
@@ -57,16 +62,16 b' class p4_source(common.converter_source)'
 
         super(p4_source, self).__init__(ui, repotype, path, revs=revs)
 
-        if "/" in path and not path.startswith('//'):
+        if b"/" in path and not path.startswith(b'//'):
             raise common.NoRepo(
-                _('%s does not look like a P4 repository') % path
+                _(b'%s does not look like a P4 repository') % path
             )
 
-        common.checktool('p4', abort=False)
+        common.checktool(b'p4', abort=False)
 
         self.revmap = {}
         self.encoding = self.ui.config(
-            'convert', 'p4.encoding', convcmd.orig_encoding
+            b'convert', b'p4.encoding', convcmd.orig_encoding
         )
         self.re_type = re.compile(
             br"([a-z]+)?(text|binary|symlink|apple|resource|unicode|utf\d+)"
@@ -80,7 +85,10 b' class p4_source(common.converter_source)'
 
         if revs and len(revs) > 1:
             raise error.Abort(
-                _("p4 source does not support specifying " "multiple revisions")
+                _(
+                    b"p4 source does not support specifying "
+                    b"multiple revisions"
+                )
             )
 
     def setrevmap(self, revmap):
@@ -97,18 +105,18 b' class p4_source(common.converter_source)'
         self.revmap = revmap
 
     def _parse_view(self, path):
-        "Read changes affecting the path"
-        cmd = 'p4 -G changes -s submitted %s' % procutil.shellquote(path)
-        stdout = procutil.popen(cmd, mode='rb')
+        b"Read changes affecting the path"
+        cmd = b'p4 -G changes -s submitted %s' % procutil.shellquote(path)
+        stdout = procutil.popen(cmd, mode=b'rb')
         p4changes = {}
         for d in loaditer(stdout):
-            c = d.get("change", None)
+            c = d.get(b"change", None)
             if c:
                 p4changes[c] = True
         return p4changes
 
     def _parse(self, ui, path):
-        "Prepare list of P4 filenames and revisions to import"
+        b"Prepare list of P4 filenames and revisions to import"
         p4changes = {}
         changeset = {}
         files_map = {}
@@ -117,29 +125,29 b' class p4_source(common.converter_source)'
         depotname = {}
         heads = []
 
-        ui.status(_('reading p4 views\n'))
+        ui.status(_(b'reading p4 views\n'))
 
         # read client spec or view
-        if "/" in path:
+        if b"/" in path:
             p4changes.update(self._parse_view(path))
-            if path.startswith("//") and path.endswith("/..."):
-                views = {path[:-3]: ""}
+            if path.startswith(b"//") and path.endswith(b"/..."):
+                views = {path[:-3]: b""}
             else:
-                views = {"//": ""}
+                views = {b"//": b""}
         else:
-            cmd = 'p4 -G client -o %s' % procutil.shellquote(path)
-            clientspec = marshal.load(procutil.popen(cmd, mode='rb'))
+            cmd = b'p4 -G client -o %s' % procutil.shellquote(path)
+            clientspec = marshal.load(procutil.popen(cmd, mode=b'rb'))
 
             views = {}
             for client in clientspec:
-                if client.startswith("View"):
+                if client.startswith(b"View"):
                     sview, cview = clientspec[client].split()
                     p4changes.update(self._parse_view(sview))
-                    if sview.endswith("...") and cview.endswith("..."):
+                    if sview.endswith(b"...") and cview.endswith(b"..."):
                         sview = sview[:-3]
                         cview = cview[:-3]
                     cview = cview[2:]
-                    cview = cview[cview.find("/") + 1 :]
+                    cview = cview[cview.find(b"/") + 1 :]
                     views[sview] = cview
 
         # list of changes that affect our source files
@@ -151,10 +159,10 b' class p4_source(common.converter_source)'
         vieworder.sort(key=len, reverse=True)
 
         # handle revision limiting
-        startrev = self.ui.config('convert', 'p4.startrev')
+        startrev = self.ui.config(b'convert', b'p4.startrev')
 
         # now read the full changelists to get the list of file revisions
-        ui.status(_('collecting p4 changelists\n'))
+        ui.status(_(b'collecting p4 changelists\n'))
         lastid = None
         for change in p4changes:
             if startrev and int(change) < int(startrev):
@@ -176,28 +184,28 b' class p4_source(common.converter_source)'
 
             descarr = c.desc.splitlines(True)
             if len(descarr) > 0:
-                shortdesc = descarr[0].rstrip('\r\n')
+                shortdesc = descarr[0].rstrip(b'\r\n')
             else:
-                shortdesc = '**empty changelist description**'
+                shortdesc = b'**empty changelist description**'
 
-            t = '%s %s' % (c.rev, repr(shortdesc)[1:-1])
-            ui.status(stringutil.ellipsis(t, 80) + '\n')
+            t = b'%s %s' % (c.rev, repr(shortdesc)[1:-1])
+            ui.status(stringutil.ellipsis(t, 80) + b'\n')
 
             files = []
             copies = {}
             copiedfiles = []
             i = 0
-            while ("depotFile%d" % i) in d and ("rev%d" % i) in d:
-                oldname = d["depotFile%d" % i]
+            while (b"depotFile%d" % i) in d and (b"rev%d" % i) in d:
+                oldname = d[b"depotFile%d" % i]
                 filename = None
                 for v in vieworder:
                     if oldname.lower().startswith(v.lower()):
                         filename = decodefilename(views[v] + oldname[len(v) :])
                         break
                 if filename:
-                    files.append((filename, d["rev%d" % i]))
+                    files.append((filename, d[b"rev%d" % i]))
                     depotname[filename] = oldname
-                    if d.get("action%d" % i) == "move/add":
+                    if d.get(b"action%d" % i) == b"move/add":
                         copiedfiles.append(filename)
                     localname[oldname] = filename
                 i += 1
@@ -206,23 +214,23 b' class p4_source(common.converter_source)'
             for filename in copiedfiles:
                 oldname = depotname[filename]
 
-                flcmd = 'p4 -G filelog %s' % procutil.shellquote(oldname)
-                flstdout = procutil.popen(flcmd, mode='rb')
+                flcmd = b'p4 -G filelog %s' % procutil.shellquote(oldname)
+                flstdout = procutil.popen(flcmd, mode=b'rb')
 
                 copiedfilename = None
                 for d in loaditer(flstdout):
                     copiedoldname = None
 
                     i = 0
-                    while ("change%d" % i) in d:
+                    while (b"change%d" % i) in d:
                         if (
-                            d["change%d" % i] == change
-                            and d["action%d" % i] == "move/add"
+                            d[b"change%d" % i] == change
+                            and d[b"action%d" % i] == b"move/add"
                         ):
                             j = 0
-                            while ("file%d,%d" % (i, j)) in d:
-                                if d["how%d,%d" % (i, j)] == "moved from":
-                                    copiedoldname = d["file%d,%d" % (i, j)]
+                            while (b"file%d,%d" % (i, j)) in d:
+                                if d[b"how%d,%d" % (i, j)] == b"moved from":
+                                    copiedoldname = d[b"file%d,%d" % (i, j)]
                                     break
                                 j += 1
                         i += 1
@@ -235,7 +243,7 b' class p4_source(common.converter_source)'
                     copies[filename] = copiedfilename
                 else:
                     ui.warn(
-                        _("cannot find source for copied file: %s@%s\n")
+                        _(b"cannot find source for copied file: %s@%s\n")
                         % (filename, change)
                     )
 
@@ -248,11 +256,11 b' class p4_source(common.converter_source)'
             heads = [lastid]
 
         return {
-            'changeset': changeset,
-            'files': files_map,
-            'copies': copies_map,
-            'heads': heads,
-            'depotname': depotname,
+            b'changeset': changeset,
+            b'files': files_map,
+            b'copies': copies_map,
+            b'heads': heads,
+            b'depotname': depotname,
         }
 
     @util.propertycache
@@ -261,74 +269,74 b' class p4_source(common.converter_source)'
 
     @util.propertycache
     def copies(self):
-        return self._parse_once['copies']
+        return self._parse_once[b'copies']
 
     @util.propertycache
     def files(self):
-        return self._parse_once['files']
+        return self._parse_once[b'files']
 
     @util.propertycache
     def changeset(self):
-        return self._parse_once['changeset']
+        return self._parse_once[b'changeset']
 
     @util.propertycache
     def heads(self):
-        return self._parse_once['heads']
+        return self._parse_once[b'heads']
 
     @util.propertycache
     def depotname(self):
-        return self._parse_once['depotname']
+        return self._parse_once[b'depotname']
 
     def getheads(self):
         return self.heads
 
     def getfile(self, name, rev):
-        cmd = 'p4 -G print %s' % procutil.shellquote(
-            "%s#%s" % (self.depotname[name], rev)
+        cmd = b'p4 -G print %s' % procutil.shellquote(
+            b"%s#%s" % (self.depotname[name], rev)
         )
 
         lasterror = None
         while True:
-            stdout = procutil.popen(cmd, mode='rb')
+            stdout = procutil.popen(cmd, mode=b'rb')
 
             mode = None
             contents = []
             keywords = None
 
             for d in loaditer(stdout):
-                code = d["code"]
-                data = d.get("data")
+                code = d[b"code"]
+                data = d.get(b"data")
 
-                if code == "error":
+                if code == b"error":
                     # if this is the first time error happened
                     # re-attempt getting the file
                     if not lasterror:
-                        lasterror = IOError(d["generic"], data)
+                        lasterror = IOError(d[b"generic"], data)
                         # this will exit inner-most for-loop
                         break
                     else:
                         raise lasterror
 
-                elif code == "stat":
-                    action = d.get("action")
-                    if action in ["purge", "delete", "move/delete"]:
+                elif code == b"stat":
+                    action = d.get(b"action")
+                    if action in [b"purge", b"delete", b"move/delete"]:
                         return None, None
-                    p4type = self.re_type.match(d["type"])
+                    p4type = self.re_type.match(d[b"type"])
                     if p4type:
-                        mode = ""
-                        flags = (p4type.group(1) or "") + (
-                            p4type.group(3) or ""
+                        mode = b""
+                        flags = (p4type.group(1) or b"") + (
+                            p4type.group(3) or b""
                         )
-                        if "x" in flags:
-                            mode = "x"
-                        if p4type.group(2) == "symlink":
-                            mode = "l"
-                        if "ko" in flags:
+                        if b"x" in flags:
+                            mode = b"x"
+                        if p4type.group(2) == b"symlink":
+                            mode = b"l"
+                        if b"ko" in flags:
                             keywords = self.re_keywords_old
-                        elif "k" in flags:
+                        elif b"k" in flags:
                             keywords = self.re_keywords
 
-                elif code == "text" or code == "binary":
+                elif code == b"text" or code == b"binary":
                     contents.append(data)
 
                 lasterror = None
@@ -339,18 +347,18 b' class p4_source(common.converter_source)'
         if mode is None:
             return None, None
 
-        contents = ''.join(contents)
+        contents = b''.join(contents)
 
         if keywords:
-            contents = keywords.sub("$\\1$", contents)
-        if mode == "l" and contents.endswith("\n"):
+            contents = keywords.sub(b"$\\1$", contents)
+        if mode == b"l" and contents.endswith(b"\n"):
             contents = contents[:-1]
 
         return contents, mode
 
     def getchanges(self, rev, full):
         if full:
-            raise error.Abort(_("convert from p4 does not support --full"))
+            raise error.Abort(_(b"convert from p4 does not support --full"))
         return self.files[rev], self.copies[rev], set()
 
     def _construct_commit(self, obj, parents=None):
@@ -358,26 +366,26 b' class p4_source(common.converter_source)'
         Constructs a common.commit object from an unmarshalled
         `p4 describe` output
         """
-        desc = self.recode(obj.get("desc", ""))
-        date = (int(obj["time"]), 0)  # timezone not set
+        desc = self.recode(obj.get(b"desc", b""))
+        date = (int(obj[b"time"]), 0)  # timezone not set
         if parents is None:
             parents = []
 
         return common.commit(
-            author=self.recode(obj["user"]),
-            date=dateutil.datestr(date, '%Y-%m-%d %H:%M:%S %1%2'),
+            author=self.recode(obj[b"user"]),
+            date=dateutil.datestr(date, b'%Y-%m-%d %H:%M:%S %1%2'),
             parents=parents,
             desc=desc,
             branch=None,
-            rev=obj['change'],
-            extra={"p4": obj['change'], "convert_revision": obj['change']},
+            rev=obj[b'change'],
+            extra={b"p4": obj[b'change'], b"convert_revision": obj[b'change']},
         )
 
     def _fetch_revision(self, rev):
         """Return an output of `p4 describe` including author, commit date as
         a dictionary."""
-        cmd = "p4 -G describe -s %s" % rev
-        stdout = procutil.popen(cmd, mode='rb')
+        cmd = b"p4 -G describe -s %s" % rev
+        stdout = procutil.popen(cmd, mode=b'rb')
         return marshal.load(stdout)
 
     def getcommit(self, rev):
@@ -387,7 +395,7 b' class p4_source(common.converter_source)'
             d = self._fetch_revision(rev)
             return self._construct_commit(d, parents=None)
         raise error.Abort(
-            _("cannot find %s in the revmap or parsed changesets") % rev
+            _(b"cannot find %s in the revmap or parsed changesets") % rev
         )
 
     def gettags(self):

hgext/convert/subversion.py

@@ -54,7 +54,7 b' try:'
     import warnings
 
     warnings.filterwarnings(
-        'ignore', module='svn.core', category=DeprecationWarning
+        b'ignore', module=b'svn.core', category=DeprecationWarning
     )
     svn.core.SubversionException  # trigger import to catch error
 
@@ -80,16 +80,16 b' def revsplit(rev):'
     >>> revsplit(b'bad')
     ('', '', 0)
     """
-    parts = rev.rsplit('@', 1)
+    parts = rev.rsplit(b'@', 1)
     revnum = 0
     if len(parts) > 1:
         revnum = int(parts[1])
-    parts = parts[0].split('/', 1)
-    uuid = ''
-    mod = ''
-    if len(parts) > 1 and parts[0].startswith('svn:'):
+    parts = parts[0].split(b'/', 1)
+    uuid = b''
+    mod = b''
+    if len(parts) > 1 and parts[0].startswith(b'svn:'):
         uuid = parts[0][4:]
-        mod = '/' + parts[1]
+        mod = b'/' + parts[1]
     return uuid, mod, revnum
 
 
@@ -101,7 +101,7 b' def quote(s):'
     # so we can extend it safely with new components. The "safe"
     # characters were taken from the "svn_uri__char_validity" table in
     # libsvn_subr/path.c.
-    return urlreq.quote(s, "!$&'()*+,-./:=@_~")
+    return urlreq.quote(s, b"!$&'()*+,-./:=@_~")
 
 
 def geturl(path):
@@ -113,11 +113,11 b' def geturl(path):'
     if os.path.isdir(path):
         path = os.path.normpath(os.path.abspath(path))
         if pycompat.iswindows:
-            path = '/' + util.normpath(path)
+            path = b'/' + util.normpath(path)
         # Module URL is later compared with the repository URL returned
         # by svn API, which is UTF-8.
         path = encoding.tolocal(path)
-        path = 'file://%s' % quote(path)
+        path = b'file://%s' % quote(path)
     return svn.core.svn_path_canonicalize(path)
 
 
@@ -188,7 +188,7 b' def debugsvnlog(ui, **opts):'
     """
     if svn is None:
         raise error.Abort(
-            _('debugsvnlog could not load Subversion python ' 'bindings')
+            _(b'debugsvnlog could not load Subversion python ' b'bindings')
         )
 
     args = decodeargs(ui.fin.read())
@@ -208,8 +208,8 b' class logstream(object):'
             except EOFError:
                 raise error.Abort(
                     _(
-                        'Mercurial failed to run itself, check'
-                        ' hg executable is in PATH'
+                        b'Mercurial failed to run itself, check'
+                        b' hg executable is in PATH'
                     )
                 )
             try:
@@ -217,7 +217,7 b' class logstream(object):'
             except (TypeError, ValueError):
                 if entry is None:
                     break
-                raise error.Abort(_("log stream exception '%s'") % entry)
+                raise error.Abort(_(b"log stream exception '%s'") % entry)
             yield entry
 
     def close(self):
@@ -270,7 +270,7 b' class directlogstream(list):'
 # looking for several svn-specific files and directories in the given
 # directory.
 def filecheck(ui, path, proto):
-    for x in ('locks', 'hooks', 'format', 'db'):
+    for x in (b'locks', b'hooks', b'format', b'db'):
         if not os.path.exists(os.path.join(path, x)):
             return False
     return True
@@ -282,16 +282,16 b' def filecheck(ui, path, proto):'
 def httpcheck(ui, path, proto):
     try:
         opener = urlreq.buildopener()
-        rsp = opener.open('%s://%s/!svn/ver/0/.svn' % (proto, path), 'rb')
+        rsp = opener.open(b'%s://%s/!svn/ver/0/.svn' % (proto, path), b'rb')
         data = rsp.read()
     except urlerr.httperror as inst:
         if inst.code != 404:
             # Except for 404 we cannot know for sure this is not an svn repo
             ui.warn(
                 _(
-                    'svn: cannot probe remote repository, assume it could '
-                    'be a subversion repository. Use --source-type if you '
-                    'know better.\n'
+                    b'svn: cannot probe remote repository, assume it could '
+                    b'be a subversion repository. Use --source-type if you '
+                    b'know better.\n'
                 )
             )
             return True
@@ -299,38 +299,38 b' def httpcheck(ui, path, proto):'
     except Exception:
         # Could be urlerr.urlerror if the URL is invalid or anything else.
         return False
-    return '<m:human-readable errcode="160013">' in data
+    return b'<m:human-readable errcode="160013">' in data
 
 
 protomap = {
-    'http': httpcheck,
-    'https': httpcheck,
-    'file': filecheck,
+    b'http': httpcheck,
+    b'https': httpcheck,
+    b'file': filecheck,
 }
 
 
 def issvnurl(ui, url):
     try:
-        proto, path = url.split('://', 1)
-        if proto == 'file':
+        proto, path = url.split(b'://', 1)
+        if proto == b'file':
             if (
                 pycompat.iswindows
-                and path[:1] == '/'
+                and path[:1] == b'/'
                 and path[1:2].isalpha()
-                and path[2:6].lower() == '%3a/'
+                and path[2:6].lower() == b'%3a/'
             ):
-                path = path[:2] + ':/' + path[6:]
+                path = path[:2] + b':/' + path[6:]
             path = urlreq.url2pathname(path)
     except ValueError:
-        proto = 'file'
+        proto = b'file'
         path = os.path.abspath(url)
-    if proto == 'file':
+    if proto == b'file':
         path = util.pconvert(path)
     check = protomap.get(proto, lambda *args: False)
-    while '/' in path:
+    while b'/' in path:
         if check(ui, path, proto):
             return True
-        path = path.rsplit('/', 1)[0]
+        path = path.rsplit(b'/', 1)[0]
     return False
 
 
@@ -353,35 +353,35 b' class svn_source(converter_source):'
         super(svn_source, self).__init__(ui, repotype, url, revs=revs)
 
         if not (
-            url.startswith('svn://')
-            or url.startswith('svn+ssh://')
+            url.startswith(b'svn://')
+            or url.startswith(b'svn+ssh://')
             or (
                 os.path.exists(url)
-                and os.path.exists(os.path.join(url, '.svn'))
+                and os.path.exists(os.path.join(url, b'.svn'))
             )
             or issvnurl(ui, url)
         ):
             raise NoRepo(
-                _("%s does not look like a Subversion repository") % url
+                _(b"%s does not look like a Subversion repository") % url
             )
         if svn is None:
-            raise MissingTool(_('could not load Subversion python bindings'))
+            raise MissingTool(_(b'could not load Subversion python bindings'))
 
         try:
             version = svn.core.SVN_VER_MAJOR, svn.core.SVN_VER_MINOR
             if version < (1, 4):
                 raise MissingTool(
                     _(
-                        'Subversion python bindings %d.%d found, '
-                        '1.4 or later required'
+                        b'Subversion python bindings %d.%d found, '
+                        b'1.4 or later required'
                     )
                     % version
                 )
         except AttributeError:
             raise MissingTool(
                 _(
-                    'Subversion python bindings are too old, 1.4 '
-                    'or later required'
+                    b'Subversion python bindings are too old, 1.4 '
+                    b'or later required'
                 )
             )
 
@@ -391,14 +391,14 b' class svn_source(converter_source):'
         try:
             # Support file://path@rev syntax. Useful e.g. to convert
             # deleted branches.
-            at = url.rfind('@')
+            at = url.rfind(b'@')
             if at >= 0:
                 latest = int(url[at + 1 :])
                 url = url[:at]
         except ValueError:
             pass
         self.url = geturl(url)
-        self.encoding = 'UTF-8'  # Subversion is always nominal UTF-8
+        self.encoding = b'UTF-8'  # Subversion is always nominal UTF-8
         try:
             self.transport = transport.SvnRaTransport(url=self.url)
             self.ra = self.transport.ra
@@ -414,15 +414,15 b' class svn_source(converter_source):'
             self.uuid = svn.ra.get_uuid(self.ra)
         except svn.core.SubversionException:
             ui.traceback()
-            svnversion = '%d.%d.%d' % (
+            svnversion = b'%d.%d.%d' % (
                 svn.core.SVN_VER_MAJOR,
                 svn.core.SVN_VER_MINOR,
                 svn.core.SVN_VER_MICRO,
             )
             raise NoRepo(
                 _(
-                    "%s does not look like a Subversion repository "
-                    "to libsvn version %s"
+                    b"%s does not look like a Subversion repository "
+                    b"to libsvn version %s"
                 )
                 % (self.url, svnversion)
             )
@@ -431,29 +431,29 b' class svn_source(converter_source):'
             if len(revs) > 1:
                 raise error.Abort(
                     _(
-                        'subversion source does not support '
-                        'specifying multiple revisions'
+                        b'subversion source does not support '
+                        b'specifying multiple revisions'
                     )
                 )
             try:
                 latest = int(revs[0])
             except ValueError:
                 raise error.Abort(
-                    _('svn: revision %s is not an integer') % revs[0]
+                    _(b'svn: revision %s is not an integer') % revs[0]
                 )
 
-        trunkcfg = self.ui.config('convert', 'svn.trunk')
+        trunkcfg = self.ui.config(b'convert', b'svn.trunk')
         if trunkcfg is None:
-            trunkcfg = 'trunk'
-        self.trunkname = trunkcfg.strip('/')
-        self.startrev = self.ui.config('convert', 'svn.startrev')
+            trunkcfg = b'trunk'
+        self.trunkname = trunkcfg.strip(b'/')
+        self.startrev = self.ui.config(b'convert', b'svn.startrev')
         try:
             self.startrev = int(self.startrev)
             if self.startrev < 0:
                 self.startrev = 0
         except ValueError:
             raise error.Abort(
-                _('svn: start revision %s is not an integer') % self.startrev
+                _(b'svn: start revision %s is not an integer') % self.startrev
             )
 
         try:
@@ -461,12 +461,14 b' class svn_source(converter_source):'
         except SvnPathNotFound:
             self.head = None
         if not self.head:
-            raise error.Abort(_('no revision found in module %s') % self.module)
+            raise error.Abort(
+                _(b'no revision found in module %s') % self.module
+            )
         self.last_changed = self.revnum(self.head)
 
         self._changescache = (None, None)
 
-        if os.path.exists(os.path.join(url, '.svn/entries')):
+        if os.path.exists(os.path.join(url, b'.svn/entries')):
             self.wc = url
         else:
             self.wc = None
@@ -484,7 +486,7 b' class svn_source(converter_source):'
     def exists(self, path, optrev):
         try:
             svn.client.ls(
-                self.url.rstrip('/') + '/' + quote(path),
+                self.url.rstrip(b'/') + b'/' + quote(path),
                 optrev,
                 False,
                 self.ctx,
@@ -499,61 +501,62 b' class svn_source(converter_source):'
             return kind == svn.core.svn_node_dir
 
         def getcfgpath(name, rev):
-            cfgpath = self.ui.config('convert', 'svn.' + name)
-            if cfgpath is not None and cfgpath.strip() == '':
+            cfgpath = self.ui.config(b'convert', b'svn.' + name)
+            if cfgpath is not None and cfgpath.strip() == b'':
                 return None
-            path = (cfgpath or name).strip('/')
+            path = (cfgpath or name).strip(b'/')
             if not self.exists(path, rev):
-                if self.module.endswith(path) and name == 'trunk':
+                if self.module.endswith(path) and name == b'trunk':
                     # we are converting from inside this directory
                     return None
                 if cfgpath:
                     raise error.Abort(
-                        _('expected %s to be at %r, but not found')
+                        _(b'expected %s to be at %r, but not found')
                         % (name, path)
                     )
                 return None
-            self.ui.note(_('found %s at %r\n') % (name, path))
+            self.ui.note(_(b'found %s at %r\n') % (name, path))
             return path
 
         rev = optrev(self.last_changed)
-        oldmodule = ''
-        trunk = getcfgpath('trunk', rev)
-        self.tags = getcfgpath('tags', rev)
-        branches = getcfgpath('branches', rev)
+        oldmodule = b''
+        trunk = getcfgpath(b'trunk', rev)
+        self.tags = getcfgpath(b'tags', rev)
+        branches = getcfgpath(b'branches', rev)
 
         # If the project has a trunk or branches, we will extract heads
         # from them. We keep the project root otherwise.
         if trunk:
-            oldmodule = self.module or ''
-            self.module += '/' + trunk
+            oldmodule = self.module or b''
+            self.module += b'/' + trunk
             self.head = self.latest(self.module, self.last_changed)
             if not self.head:
                 raise error.Abort(
-                    _('no revision found in module %s') % self.module
+                    _(b'no revision found in module %s') % self.module
                 )
 
         # First head in the list is the module's head
         self.heads = [self.head]
         if self.tags is not None:
-            self.tags = '%s/%s' % (oldmodule, (self.tags or 'tags'))
+            self.tags = b'%s/%s' % (oldmodule, (self.tags or b'tags'))
 
         # Check if branches bring a few more heads to the list
         if branches:
-            rpath = self.url.strip('/')
+            rpath = self.url.strip(b'/')
             branchnames = svn.client.ls(
-                rpath + '/' + quote(branches), rev, False, self.ctx
+                rpath + b'/' + quote(branches), rev, False, self.ctx
             )
             for branch in sorted(branchnames):
-                module = '%s/%s/%s' % (oldmodule, branches, branch)
+                module = b'%s/%s/%s' % (oldmodule, branches, branch)
                 if not isdir(module, self.last_changed):
                     continue
                 brevid = self.latest(module, self.last_changed)
                 if not brevid:
-                    self.ui.note(_('ignoring empty branch %s\n') % branch)
+                    self.ui.note(_(b'ignoring empty branch %s\n') % branch)
                     continue
                 self.ui.note(
-                    _('found branch %s at %d\n') % (branch, self.revnum(brevid))
+                    _(b'found branch %s at %d\n')
+                    % (branch, self.revnum(brevid))
                 )
                 self.heads.append(brevid)
 
@@ -561,14 +564,14 b' class svn_source(converter_source):'
             if len(self.heads) > 1:
                 raise error.Abort(
                     _(
-                        'svn: start revision is not supported '
-                        'with more than one branch'
+                        b'svn: start revision is not supported '
+                        b'with more than one branch'
                     )
                 )
             revnum = self.revnum(self.heads[0])
             if revnum < self.startrev:
                 raise error.Abort(
-                    _('svn: no revision found after start revision %d')
+                    _(b'svn: no revision found after start revision %d')
                     % self.startrev
                 )
 
@@ -628,13 +631,13 b' class svn_source(converter_source):'
                 stop = revnum + 1
             self._fetch_revisions(revnum, stop)
             if rev not in self.commits:
-                raise error.Abort(_('svn: revision %s not found') % revnum)
+                raise error.Abort(_(b'svn: revision %s not found') % revnum)
         revcommit = self.commits[rev]
         # caller caches the result, so free it here to release memory
         del self.commits[rev]
         return revcommit
 
-    def checkrevformat(self, revstr, mapname='splicemap'):
+    def checkrevformat(self, revstr, mapname=b'splicemap'):
         """ fails if revision format does not match the correct format"""
         if not re.match(
             r'svn:[0-9a-f]{8,8}-[0-9a-f]{4,4}-'
@@ -643,12 +646,12 b' class svn_source(converter_source):'
             revstr,
         ):
             raise error.Abort(
-                _('%s entry %s is not a valid revision' ' identifier')
+                _(b'%s entry %s is not a valid revision' b' identifier')
                 % (mapname, revstr)
             )
 
     def numcommits(self):
-        return int(self.head.rsplit('@', 1)[1]) - self.startrev
+        return int(self.head.rsplit(b'@', 1)[1]) - self.startrev
 
     def gettags(self):
         tags = {}
@@ -689,7 +692,7 b' class svn_source(converter_source):'
                     srctagspath = copies.pop()[0]
 
                 for source, sourcerev, dest in copies:
-                    if not dest.startswith(tagspath + '/'):
+                    if not dest.startswith(tagspath + b'/'):
                         continue
                     for tag in pendings:
                         if tag[0].startswith(dest):
@@ -709,14 +712,14 b' class svn_source(converter_source):'
                 addeds = dict(
                     (p, e.copyfrom_path)
                     for p, e in origpaths.iteritems()
-                    if e.action == 'A' and e.copyfrom_path
+                    if e.action == b'A' and e.copyfrom_path
                 )
                 badroots = set()
                 for destroot in addeds:
                     for source, sourcerev, dest in pendings:
                         if not dest.startswith(
-                            destroot + '/'
-                        ) or source.startswith(addeds[destroot] + '/'):
+                            destroot + b'/'
+                        ) or source.startswith(addeds[destroot] + b'/'):
                             continue
                         badroots.add(destroot)
                         break
@@ -726,13 +729,13 b' class svn_source(converter_source):'
                         p
                         for p in pendings
                         if p[2] != badroot
-                        and not p[2].startswith(badroot + '/')
+                        and not p[2].startswith(badroot + b'/')
                     ]
 
                 # Tell tag renamings from tag creations
                 renamings = []
                 for source, sourcerev, dest in pendings:
-                    tagname = dest.split('/')[-1]
+                    tagname = dest.split(b'/')[-1]
                     if source.startswith(srctagspath):
                         renamings.append([source, sourcerev, tagname])
                         continue
@@ -761,18 +764,18 b' class svn_source(converter_source):'
             return
         if self.convertfp is None:
             self.convertfp = open(
-                os.path.join(self.wc, '.svn', 'hg-shamap'), 'ab'
+                os.path.join(self.wc, b'.svn', b'hg-shamap'), b'ab'
             )
         self.convertfp.write(
-            util.tonativeeol('%s %d\n' % (destrev, self.revnum(rev)))
+            util.tonativeeol(b'%s %d\n' % (destrev, self.revnum(rev)))
         )
         self.convertfp.flush()
 
     def revid(self, revnum, module=None):
-        return 'svn:%s%s@%s' % (self.uuid, module or self.module, revnum)
+        return b'svn:%s%s@%s' % (self.uuid, module or self.module, revnum)
 
     def revnum(self, rev):
-        return int(rev.split('@')[-1])
+        return int(rev.split(b'@')[-1])
 
     def latest(self, path, stop=None):
         """Find the latest revid affecting path, up to stop revision
@@ -800,7 +803,7 b' class svn_source(converter_source):'
                             continue
                         newpath = paths[p].copyfrom_path + path[len(p) :]
                         self.ui.debug(
-                            "branch renamed from %s to %s at %d\n"
+                            b"branch renamed from %s to %s at %d\n"
                             % (path, newpath, revnum)
                         )
                         path = newpath
@@ -813,20 +816,20 b' class svn_source(converter_source):'
 
         if not path.startswith(self.rootmodule):
             # Requests on foreign branches may be forbidden at server level
-            self.ui.debug('ignoring foreign branch %r\n' % path)
+            self.ui.debug(b'ignoring foreign branch %r\n' % path)
             return None
 
         if stop is None:
             stop = svn.ra.get_latest_revnum(self.ra)
         try:
-            prevmodule = self.reparent('')
-            dirent = svn.ra.stat(self.ra, path.strip('/'), stop)
+            prevmodule = self.reparent(b'')
+            dirent = svn.ra.stat(self.ra, path.strip(b'/'), stop)
             self.reparent(prevmodule)
         except svn.core.SubversionException:
             dirent = None
         if not dirent:
             raise SvnPathNotFound(
-                _('%s not found up to revision %d') % (path, stop)
+                _(b'%s not found up to revision %d') % (path, stop)
             )
 
         # stat() gives us the previous revision on this line of
@@ -843,11 +846,11 b' class svn_source(converter_source):'
             # the whole history.
             revnum, realpath = findchanges(path, stop)
             if revnum is None:
-                self.ui.debug('ignoring empty branch %r\n' % realpath)
+                self.ui.debug(b'ignoring empty branch %r\n' % realpath)
                 return None
 
         if not realpath.startswith(self.rootmodule):
-            self.ui.debug('ignoring foreign branch %r\n' % realpath)
+            self.ui.debug(b'ignoring foreign branch %r\n' % realpath)
             return None
         return self.revid(revnum, realpath)
 
@@ -858,8 +861,8 b' class svn_source(converter_source):'
         svnurl = self.baseurl + quote(module)
         prevmodule = self.prevmodule
         if prevmodule is None:
-            prevmodule = ''
-        self.ui.debug("reparent to %s\n" % svnurl)
+            prevmodule = b''
+        self.ui.debug(b"reparent to %s\n" % svnurl)
         svn.ra.reparent(self.ra, svnurl)
         self.prevmodule = module
         return prevmodule
@@ -874,7 +877,7 b' class svn_source(converter_source):'
             self.reparent(self.module)
 
         progress = self.ui.makeprogress(
-            _('scanning paths'), unit=_('paths'), total=len(paths)
+            _(b'scanning paths'), unit=_(b'paths'), total=len(paths)
         )
         for i, (path, ent) in enumerate(paths):
             progress.update(i, item=path)
@@ -894,37 +897,37 b' class svn_source(converter_source):'
                 if not copyfrom_path:
                     continue
                 self.ui.debug(
-                    "copied to %s from %s@%s\n"
+                    b"copied to %s from %s@%s\n"
                     % (entrypath, copyfrom_path, ent.copyfrom_rev)
                 )
                 copies[self.recode(entrypath)] = self.recode(copyfrom_path)
             elif kind == 0:  # gone, but had better be a deleted *file*
-                self.ui.debug("gone from %s\n" % ent.copyfrom_rev)
+                self.ui.debug(b"gone from %s\n" % ent.copyfrom_rev)
                 pmodule, prevnum = revsplit(parents[0])[1:]
-                parentpath = pmodule + "/" + entrypath
+                parentpath = pmodule + b"/" + entrypath
                 fromkind = self._checkpath(entrypath, prevnum, pmodule)
 
                 if fromkind == svn.core.svn_node_file:
                     removed.add(self.recode(entrypath))
                 elif fromkind == svn.core.svn_node_dir:
-                    oroot = parentpath.strip('/')
-                    nroot = path.strip('/')
+                    oroot = parentpath.strip(b'/')
+                    nroot = path.strip(b'/')
                     children = self._iterfiles(oroot, prevnum)
                     for childpath in children:
                         childpath = childpath.replace(oroot, nroot)
-                        childpath = self.getrelpath("/" + childpath, pmodule)
+                        childpath = self.getrelpath(b"/" + childpath, pmodule)
                         if childpath:
                             removed.add(self.recode(childpath))
                 else:
                     self.ui.debug(
-                        'unknown path in revision %d: %s\n' % (revnum, path)
+                        b'unknown path in revision %d: %s\n' % (revnum, path)
                     )
             elif kind == svn.core.svn_node_dir:
-                if ent.action == 'M':
+                if ent.action == b'M':
                     # If the directory just had a prop change,
                     # then we shouldn't need to look for its children.
                     continue
-                if ent.action == 'R' and parents:
+                if ent.action == b'R' and parents:
                     # If a directory is replacing a file, mark the previous
                     # file as deleted
                     pmodule, prevnum = revsplit(parents[0])[1:]
@@ -935,12 +938,12 b' class svn_source(converter_source):'
                         # We do not know what files were kept or removed,
                         # mark them all as changed.
                         for childpath in self._iterfiles(pmodule, prevnum):
-                            childpath = self.getrelpath("/" + childpath)
+                            childpath = self.getrelpath(b"/" + childpath)
                             if childpath:
                                 changed.add(self.recode(childpath))
 
                 for childpath in self._iterfiles(path, revnum):
-                    childpath = self.getrelpath("/" + childpath)
+                    childpath = self.getrelpath(b"/" + childpath)
                     if childpath:
                         changed.add(self.recode(childpath))
 
@@ -956,12 +959,12 b' class svn_source(converter_source):'
                 if not copyfrompath:
                     continue
                 self.ui.debug(
-                    "mark %s came from %s:%d\n"
+                    b"mark %s came from %s:%d\n"
                     % (path, copyfrompath, ent.copyfrom_rev)
                 )
                 children = self._iterfiles(ent.copyfrom_path, ent.copyfrom_rev)
                 for childpath in children:
-                    childpath = self.getrelpath("/" + childpath, pmodule)
+                    childpath = self.getrelpath(b"/" + childpath, pmodule)
                     if not childpath:
                         continue
                     copytopath = path + childpath[len(copyfrompath) :]
@@ -983,7 +986,8 b' class svn_source(converter_source):'
             the revision is a branch root.
             """
             self.ui.debug(
-                "parsing revision %d (%d changes)\n" % (revnum, len(orig_paths))
+                b"parsing revision %d (%d changes)\n"
+                % (revnum, len(orig_paths))
             )
 
             branched = False
@@ -1012,11 +1016,11 b' class svn_source(converter_source):'
                         if prevnum >= self.startrev:
                             parents = [previd]
                             self.ui.note(
-                                _('found parent of branch %s at %d: %s\n')
+                                _(b'found parent of branch %s at %d: %s\n')
                                 % (self.module, prevnum, prevmodule)
                             )
                 else:
-                    self.ui.debug("no copyfrom path, don't know what to do.\n")
+                    self.ui.debug(b"no copyfrom path, don't know what to do.\n")
 
             paths = []
             # filter out unrelated paths
@@ -1028,22 +1032,24 b' class svn_source(converter_source):'
             # Example SVN datetime. Includes microseconds.
             # ISO-8601 conformant
             # '2007-01-04T17:35:00.902377Z'
-            date = dateutil.parsedate(date[:19] + " UTC", ["%Y-%m-%dT%H:%M:%S"])
-            if self.ui.configbool('convert', 'localtimezone'):
+            date = dateutil.parsedate(
+                date[:19] + b" UTC", [b"%Y-%m-%dT%H:%M:%S"]
+            )
+            if self.ui.configbool(b'convert', b'localtimezone'):
                 date = makedatetimestamp(date[0])
 
             if message:
                 log = self.recode(message)
             else:
-                log = ''
+                log = b''
 
             if author:
                 author = self.recode(author)
             else:
-                author = ''
+                author = b''
 
             try:
-                branch = self.module.split("/")[-1]
+                branch = self.module.split(b"/")[-1]
                 if branch == self.trunkname:
                     branch = None
             except IndexError:
@@ -1051,7 +1057,7 b' class svn_source(converter_source):'
 
             cset = commit(
                 author=author,
-                date=dateutil.datestr(date, '%Y-%m-%d %H:%M:%S %1%2'),
+                date=dateutil.datestr(date, b'%Y-%m-%d %H:%M:%S %1%2'),
                 desc=log,
                 parents=parents,
                 branch=branch,
@@ -1068,7 +1074,7 b' class svn_source(converter_source):'
             return cset, branched
 
         self.ui.note(
-            _('fetching revision log for "%s" from %d to %d\n')
+            _(b'fetching revision log for "%s" from %d to %d\n')
             % (self.module, from_revnum, to_revnum)
         )
 
@@ -1083,7 +1089,7 b' class svn_source(converter_source):'
                         lastonbranch = True
                         break
                     if not paths:
-                        self.ui.debug('revision %d has no entries\n' % revnum)
+                        self.ui.debug(b'revision %d has no entries\n' % revnum)
                         # If we ever leave the loop on an empty
                         # revision, do not try to get a parent branch
                         lastonbranch = lastonbranch or revnum == 0
@@ -1114,7 +1120,7 b' class svn_source(converter_source):'
             (inst, num) = xxx_todo_changeme.args
             if num == svn.core.SVN_ERR_FS_NO_SUCH_REVISION:
                 raise error.Abort(
-                    _('svn: branch has no revision %s') % to_revnum
+                    _(b'svn: branch has no revision %s') % to_revnum
                 )
             raise
 
@@ -1135,8 +1141,8 b' class svn_source(converter_source):'
             io.close()
             if isinstance(info, list):
                 info = info[-1]
-            mode = ("svn:executable" in info) and 'x' or ''
-            mode = ("svn:special" in info) and 'l' or mode
+            mode = (b"svn:executable" in info) and b'x' or b''
+            mode = (b"svn:special" in info) and b'l' or mode
         except svn.core.SubversionException as e:
             notfound = (
                 svn.core.SVN_ERR_FS_NOT_FOUND,
@@ -1145,20 +1151,20 b' class svn_source(converter_source):'
             if e.apr_err in notfound:  # File not found
                 return None, None
             raise
-        if mode == 'l':
-            link_prefix = "link "
+        if mode == b'l':
+            link_prefix = b"link "
             if data.startswith(link_prefix):
                 data = data[len(link_prefix) :]
         return data, mode
 
     def _iterfiles(self, path, revnum):
         """Enumerate all files in path at revnum, recursively."""
-        path = path.strip('/')
+        path = path.strip(b'/')
         pool = svn.core.Pool()
-        rpath = '/'.join([self.baseurl, quote(path)]).strip('/')
+        rpath = b'/'.join([self.baseurl, quote(path)]).strip(b'/')
         entries = svn.client.ls(rpath, optrev(revnum), True, self.ctx, pool)
         if path:
-            path += '/'
+            path += b'/'
         return (
             (path + p)
             for p, e in entries.iteritems()
@@ -1175,24 +1181,24 b' class svn_source(converter_source):'
         #   "/CMFPlone/branches/Plone-2_0-branch/tests/PloneTestCase.py"
         # that is to say "tests/PloneTestCase.py"
         if path.startswith(module):
-            relative = path.rstrip('/')[len(module) :]
-            if relative.startswith('/'):
+            relative = path.rstrip(b'/')[len(module) :]
+            if relative.startswith(b'/'):
                 return relative[1:]
-            elif relative == '':
+            elif relative == b'':
                 return relative
 
         # The path is outside our tracked tree...
-        self.ui.debug('%r is not under %r, ignoring\n' % (path, module))
+        self.ui.debug(b'%r is not under %r, ignoring\n' % (path, module))
         return None
 
     def _checkpath(self, path, revnum, module=None):
         if module is not None:
-            prevmodule = self.reparent('')
-            path = module + '/' + path
+            prevmodule = self.reparent(b'')
+            path = module + b'/' + path
         try:
             # ra.check_path does not like leading slashes very much, it leads
             # to PROPFIND subversion errors
-            return svn.ra.check_path(self.ra, path.strip('/'), revnum)
+            return svn.ra.check_path(self.ra, path.strip(b'/'), revnum)
         finally:
             if module is not None:
                 self.reparent(prevmodule)
@@ -1210,9 +1216,9 b' class svn_source(converter_source):'
         # supplied URL
         relpaths = []
         for p in paths:
-            if not p.startswith('/'):
-                p = self.module + '/' + p
-            relpaths.append(p.strip('/'))
+            if not p.startswith(b'/'):
+                p = self.module + b'/' + p
+            relpaths.append(p.strip(b'/'))
         args = [
             self.baseurl,
             relpaths,
@@ -1223,11 +1229,11 b' class svn_source(converter_source):'
             strict_node_history,
         ]
         # developer config: convert.svn.debugsvnlog
-        if not self.ui.configbool('convert', 'svn.debugsvnlog'):
+        if not self.ui.configbool(b'convert', b'svn.debugsvnlog'):
             return directlogstream(*args)
         arg = encodeargs(args)
         hgexe = procutil.hgexecutable()
-        cmd = '%s debugsvnlog' % procutil.shellquote(hgexe)
+        cmd = b'%s debugsvnlog' % procutil.shellquote(hgexe)
         stdin, stdout = procutil.popen2(procutil.quotecommand(cmd))
         stdin.write(arg)
         try:
@@ -1235,8 +1241,8 b' class svn_source(converter_source):'
         except IOError:
             raise error.Abort(
                 _(
-                    'Mercurial failed to run itself, check'
-                    ' hg executable is in PATH'
+                    b'Mercurial failed to run itself, check'
+                    b' hg executable is in PATH'
                 )
             )
         return logstream(stdout)
@@ -1272,18 +1278,18 b' class svn_sink(converter_sink, commandli'
             os.chdir(self.cwd)
 
     def join(self, name):
-        return os.path.join(self.wc, '.svn', name)
+        return os.path.join(self.wc, b'.svn', name)
 
     def revmapfile(self):
-        return self.join('hg-shamap')
+        return self.join(b'hg-shamap')
 
     def authorfile(self):
-        return self.join('hg-authormap')
+        return self.join(b'hg-authormap')
 
     def __init__(self, ui, repotype, path):
 
         converter_sink.__init__(self, ui, repotype, path)
-        commandline.__init__(self, ui, 'svn')
+        commandline.__init__(self, ui, b'svn')
         self.delete = []
         self.setexec = []
         self.delexec = []
@@ -1292,51 +1298,53 b' class svn_sink(converter_sink, commandli'
         self.cwd = encoding.getcwd()
 
         created = False
-        if os.path.isfile(os.path.join(path, '.svn', 'entries')):
+        if os.path.isfile(os.path.join(path, b'.svn', b'entries')):
             self.wc = os.path.realpath(path)
-            self.run0('update')
+            self.run0(b'update')
         else:
             if not re.search(br'^(file|http|https|svn|svn\+ssh)\://', path):
                 path = os.path.realpath(path)
                 if os.path.isdir(os.path.dirname(path)):
-                    if not os.path.exists(os.path.join(path, 'db', 'fs-type')):
+                    if not os.path.exists(
+                        os.path.join(path, b'db', b'fs-type')
+                    ):
                         ui.status(
-                            _("initializing svn repository '%s'\n")
+                            _(b"initializing svn repository '%s'\n")
                             % os.path.basename(path)
                         )
-                        commandline(ui, 'svnadmin').run0('create', path)
+                        commandline(ui, b'svnadmin').run0(b'create', path)
                         created = path
                     path = util.normpath(path)
-                    if not path.startswith('/'):
-                        path = '/' + path
-                    path = 'file://' + path
+                    if not path.startswith(b'/'):
+                        path = b'/' + path
+                    path = b'file://' + path
 
             wcpath = os.path.join(
-                encoding.getcwd(), os.path.basename(path) + '-wc'
+                encoding.getcwd(), os.path.basename(path) + b'-wc'
             )
             ui.status(
-                _("initializing svn working copy '%s'\n")
+                _(b"initializing svn working copy '%s'\n")
                 % os.path.basename(wcpath)
             )
-            self.run0('checkout', path, wcpath)
+            self.run0(b'checkout', path, wcpath)
 
             self.wc = wcpath
         self.opener = vfsmod.vfs(self.wc)
         self.wopener = vfsmod.vfs(self.wc)
-        self.childmap = mapfile(ui, self.join('hg-childmap'))
+        self.childmap = mapfile(ui, self.join(b'hg-childmap'))
         if util.checkexec(self.wc):
             self.is_exec = util.isexec
         else:
             self.is_exec = None
 
         if created:
-            hook = os.path.join(created, 'hooks', 'pre-revprop-change')
-            fp = open(hook, 'wb')
+            hook = os.path.join(created, b'hooks', b'pre-revprop-change')
+            fp = open(hook, b'wb')
             fp.write(pre_revprop_change)
             fp.close()
             util.setflags(hook, False, True)
 
-        output = self.run0('info')
+        output = self.run0(b'info')
         self.uuid = self.uuid_re.search(output).group(1).strip()
 
     def wjoin(self, *names):
@@ -1348,7 +1356,7 b' class svn_sink(converter_sink, commandli'
         # already tracked entries, so we have to track and filter them
         # ourselves.
         m = set()
-        output = self.run0('ls', recursive=True, xml=True)
+        output = self.run0(b'ls', recursive=True, xml=True)
         doc = xml.dom.minidom.parseString(output)
         for e in doc.getElementsByTagName(r'entry'):
             for n in e.childNodes:
@@ -1367,7 +1375,7 b' class svn_sink(converter_sink, commandli'
         return m
 
     def putfile(self, filename, flags, data):
-        if 'l' in flags:
+        if b'l' in flags:
             self.wopener.symlink(data, filename)
         else:
             try:
@@ -1387,12 +1395,12 b' class svn_sink(converter_sink, commandli'
 
             if self.is_exec:
                 if wasexec:
-                    if 'x' not in flags:
+                    if b'x' not in flags:
                         self.delexec.append(filename)
                 else:
-                    if 'x' in flags:
+                    if b'x' in flags:
                         self.setexec.append(filename)
-                util.setflags(self.wjoin(filename), False, 'x' in flags)
+                util.setflags(self.wjoin(filename), False, b'x' in flags)
 
     def _copyfile(self, source, dest):
         # SVN's copy command pukes if the destination file exists, but
@@ -1402,13 +1410,13 b' class svn_sink(converter_sink, commandli'
         exists = os.path.lexists(wdest)
         if exists:
             fd, tempname = pycompat.mkstemp(
-                prefix='hg-copy-', dir=os.path.dirname(wdest)
+                prefix=b'hg-copy-', dir=os.path.dirname(wdest)
             )
             os.close(fd)
             os.unlink(tempname)
             os.rename(wdest, tempname)
         try:
-            self.run0('copy', source, dest)
+            self.run0(b'copy', source, dest)
         finally:
             self.manifest.add(dest)
             if exists:
@@ -1424,7 +1432,7 b' class svn_sink(converter_sink, commandli'
             if os.path.isdir(self.wjoin(f)):
                 dirs.add(f)
             i = len(f)
-            for i in iter(lambda: f.rfind('/', 0, i), -1):
+            for i in iter(lambda: f.rfind(b'/', 0, i), -1):
                 dirs.add(f[:i])
         return dirs
 
@@ -1434,21 +1442,21 b' class svn_sink(converter_sink, commandli'
         ]
         if add_dirs:
             self.manifest.update(add_dirs)
-            self.xargs(add_dirs, 'add', non_recursive=True, quiet=True)
+            self.xargs(add_dirs, b'add', non_recursive=True, quiet=True)
         return add_dirs
 
     def add_files(self, files):
         files = [f for f in files if f not in self.manifest]
         if files:
             self.manifest.update(files)
-            self.xargs(files, 'add', quiet=True)
+            self.xargs(files, b'add', quiet=True)
         return files
 
     def addchild(self, parent, child):
         self.childmap[parent] = child
 
     def revid(self, rev):
-        return "svn:%s@%s" % (self.uuid, rev)
+        return b"svn:%s@%s" % (self.uuid, rev)
 
     def putcommit(
         self, files, copies, parents, commit, source, revmap, full, cleanp2
@@ -1480,49 +1488,49 b' class svn_sink(converter_sink, commandli'
                 self._copyfile(s, d)
             self.copies = []
         if self.delete:
-            self.xargs(self.delete, 'delete')
+            self.xargs(self.delete, b'delete')
             for f in self.delete:
                 self.manifest.remove(f)
             self.delete = []
         entries.update(self.add_files(files.difference(entries)))
         if self.delexec:
-            self.xargs(self.delexec, 'propdel', 'svn:executable')
+            self.xargs(self.delexec, b'propdel', b'svn:executable')
             self.delexec = []
         if self.setexec:
-            self.xargs(self.setexec, 'propset', 'svn:executable', '*')
+            self.xargs(self.setexec, b'propset', b'svn:executable', b'*')
             self.setexec = []
 
-        fd, messagefile = pycompat.mkstemp(prefix='hg-convert-')
+        fd, messagefile = pycompat.mkstemp(prefix=b'hg-convert-')
         fp = os.fdopen(fd, r'wb')
         fp.write(util.tonativeeol(commit.desc))
         fp.close()
         try:
             output = self.run0(
-                'commit',
+                b'commit',
                 username=stringutil.shortuser(commit.author),
                 file=messagefile,
-                encoding='utf-8',
+                encoding=b'utf-8',
             )
             try:
                 rev = self.commit_re.search(output).group(1)
             except AttributeError:
                 if not files:
-                    return parents[0] if parents else 'None'
-                self.ui.warn(_('unexpected svn output:\n'))
+                    return parents[0] if parents else b'None'
+                self.ui.warn(_(b'unexpected svn output:\n'))
                 self.ui.warn(output)
-                raise error.Abort(_('unable to cope with svn output'))
+                raise error.Abort(_(b'unable to cope with svn output'))
             if commit.rev:
                 self.run(
-                    'propset',
-                    'hg:convert-rev',
+                    b'propset',
+                    b'hg:convert-rev',
                     commit.rev,
                     revprop=True,
                     revision=rev,
                 )
-            if commit.branch and commit.branch != 'default':
+            if commit.branch and commit.branch != b'default':
                 self.run(
-                    'propset',
-                    'hg:convert-branch',
+                    b'propset',
+                    b'hg:convert-branch',
                     commit.branch,
                     revprop=True,
                     revision=rev,
@@ -1534,7 +1542,7 b' class svn_sink(converter_sink, commandli'
             os.unlink(messagefile)
 
     def puttags(self, tags):
-        self.ui.warn(_('writing Subversion tags is not yet implemented\n'))
+        self.ui.warn(_(b'writing Subversion tags is not yet implemented\n'))
         return None, None
 
     def hascommitfrommap(self, rev):
@@ -1549,8 +1557,8 b' class svn_sink(converter_sink, commandli'
             return True
         raise error.Abort(
             _(
-                'splice map revision %s not found in subversion '
-                'child map (revision lookups are not implemented)'
+                b'splice map revision %s not found in subversion '
+                b'child map (revision lookups are not implemented)'
             )
             % rev
         )

hgext/convert/transport.py

@@ -54,13 +54,13 b' def _create_auth_baton(pool):'
     )
     if getprovider:
         # Available in svn >= 1.6
-        for name in ('gnome_keyring', 'keychain', 'kwallet', 'windows'):
-            for type in ('simple', 'ssl_client_cert_pw', 'ssl_server_trust'):
+        for name in (b'gnome_keyring', b'keychain', b'kwallet', b'windows'):
+            for type in (b'simple', b'ssl_client_cert_pw', b'ssl_server_trust'):
                 p = getprovider(name, type, pool)
                 if p:
                     providers.append(p)
     else:
-        if util.safehasattr(svn.client, 'get_windows_simple_provider'):
+        if util.safehasattr(svn.client, b'get_windows_simple_provider'):
             providers.append(svn.client.get_windows_simple_provider(pool))
 
     return svn.core.svn_auth_open(providers, pool)
@@ -75,14 +75,14 b' class SvnRaTransport(object):'
     Open an ra connection to a Subversion repository.
     """
 
-    def __init__(self, url="", ra=None):
+    def __init__(self, url=b"", ra=None):
         self.pool = Pool()
         self.svn_url = url
-        self.username = ''
-        self.password = ''
+        self.username = b''
+        self.password = b''
 
         # Only Subversion 1.4 has reparent()
-        if ra is None or not util.safehasattr(svn.ra, 'reparent'):
+        if ra is None or not util.safehasattr(svn.ra, b'reparent'):
             self.client = svn.client.create_context(self.pool)
             ab = _create_auth_baton(self.pool)
             self.client.auth_baton = ab

hgext/eol.py

@@ -112,41 +112,41 b' from mercurial.utils import stringutil'
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
-testedwith = 'ships-with-hg-core'
+testedwith = b'ships-with-hg-core'
 
 configtable = {}
 configitem = registrar.configitem(configtable)
 
 configitem(
-    'eol', 'fix-trailing-newline', default=False,
+    b'eol', b'fix-trailing-newline', default=False,
 )
 configitem(
-    'eol', 'native', default=pycompat.oslinesep,
+    b'eol', b'native', default=pycompat.oslinesep,
 )
 configitem(
-    'eol', 'only-consistent', default=True,
+    b'eol', b'only-consistent', default=True,
 )
 
 # Matches a lone LF, i.e., one that is not part of CRLF.
-singlelf = re.compile('(^|[^\r])\n')
+singlelf = re.compile(b'(^|[^\r])\n')
 
 
 def inconsistenteol(data):
-    return '\r\n' in data and singlelf.search(data)
+    return b'\r\n' in data and singlelf.search(data)
 
 
 def tolf(s, params, ui, **kwargs):
     """Filter to convert to LF EOLs."""
     if stringutil.binary(s):
         return s
-    if ui.configbool('eol', 'only-consistent') and inconsistenteol(s):
+    if ui.configbool(b'eol', b'only-consistent') and inconsistenteol(s):
         return s
     if (
-        ui.configbool('eol', 'fix-trailing-newline')
+        ui.configbool(b'eol', b'fix-trailing-newline')
         and s
-        and not s.endswith('\n')
+        and not s.endswith(b'\n')
     ):
-        s = s + '\n'
+        s = s + b'\n'
     return util.tolf(s)
 
 
@@ -154,14 +154,14 b' def tocrlf(s, params, ui, **kwargs):'
     """Filter to convert to CRLF EOLs."""
     if stringutil.binary(s):
         return s
-    if ui.configbool('eol', 'only-consistent') and inconsistenteol(s):
+    if ui.configbool(b'eol', b'only-consistent') and inconsistenteol(s):
         return s
     if (
-        ui.configbool('eol', 'fix-trailing-newline')
+        ui.configbool(b'eol', b'fix-trailing-newline')
         and s
-        and not s.endswith('\n')
+        and not s.endswith(b'\n')
     ):
-        s = s + '\n'
+        s = s + b'\n'
     return util.tocrlf(s)
 
 
@@ -171,60 +171,68 b' def isbinary(s, params):'
 
 
 filters = {
-    'to-lf': tolf,
-    'to-crlf': tocrlf,
-    'is-binary': isbinary,
+    b'to-lf': tolf,
+    b'to-crlf': tocrlf,
+    b'is-binary': isbinary,
     # The following provide backwards compatibility with win32text
-    'cleverencode:': tolf,
-    'cleverdecode:': tocrlf,
+    b'cleverencode:': tolf,
+    b'cleverdecode:': tocrlf,
 }
 
 
 class eolfile(object):
     def __init__(self, ui, root, data):
-        self._decode = {'LF': 'to-lf', 'CRLF': 'to-crlf', 'BIN': 'is-binary'}
-        self._encode = {'LF': 'to-lf', 'CRLF': 'to-crlf', 'BIN': 'is-binary'}
+        self._decode = {
+            b'LF': b'to-lf',
+            b'CRLF': b'to-crlf',
+            b'BIN': b'is-binary',
+        }
+        self._encode = {
+            b'LF': b'to-lf',
+            b'CRLF': b'to-crlf',
+            b'BIN': b'is-binary',
+        }
 
         self.cfg = config.config()
         # Our files should not be touched. The pattern must be
         # inserted first override a '** = native' pattern.
-        self.cfg.set('patterns', '.hg*', 'BIN', 'eol')
+        self.cfg.set(b'patterns', b'.hg*', b'BIN', b'eol')
         # We can then parse the user's patterns.
-        self.cfg.parse('.hgeol', data)
+        self.cfg.parse(b'.hgeol', data)
 
-        isrepolf = self.cfg.get('repository', 'native') != 'CRLF'
-        self._encode['NATIVE'] = isrepolf and 'to-lf' or 'to-crlf'
-        iswdlf = ui.config('eol', 'native') in ('LF', '\n')
-        self._decode['NATIVE'] = iswdlf and 'to-lf' or 'to-crlf'
+        isrepolf = self.cfg.get(b'repository', b'native') != b'CRLF'
+        self._encode[b'NATIVE'] = isrepolf and b'to-lf' or b'to-crlf'
+        iswdlf = ui.config(b'eol', b'native') in (b'LF', b'\n')
+        self._decode[b'NATIVE'] = iswdlf and b'to-lf' or b'to-crlf'
 
         include = []
         exclude = []
         self.patterns = []
-        for pattern, style in self.cfg.items('patterns'):
+        for pattern, style in self.cfg.items(b'patterns'):
             key = style.upper()
-            if key == 'BIN':
+            if key == b'BIN':
                 exclude.append(pattern)
             else:
                 include.append(pattern)
-            m = match.match(root, '', [pattern])
+            m = match.match(root, b'', [pattern])
             self.patterns.append((pattern, key, m))
         # This will match the files for which we need to care
         # about inconsistent newlines.
-        self.match = match.match(root, '', [], include, exclude)
+        self.match = match.match(root, b'', [], include, exclude)
 
     def copytoui(self, ui):
         for pattern, key, m in self.patterns:
             try:
-                ui.setconfig('decode', pattern, self._decode[key], 'eol')
-                ui.setconfig('encode', pattern, self._encode[key], 'eol')
+                ui.setconfig(b'decode', pattern, self._decode[key], b'eol')
+                ui.setconfig(b'encode', pattern, self._encode[key], b'eol')
             except KeyError:
                 ui.warn(
-                    _("ignoring unknown EOL style '%s' from %s\n")
-                    % (key, self.cfg.source('patterns', pattern))
+                    _(b"ignoring unknown EOL style '%s' from %s\n")
+                    % (key, self.cfg.source(b'patterns', pattern))
                 )
         # eol.only-consistent can be specified in ~/.hgrc or .hgeol
-        for k, v in self.cfg.items('eol'):
-            ui.setconfig('eol', k, v, 'eol')
+        for k, v in self.cfg.items(b'eol'):
+            ui.setconfig(b'eol', k, v, b'eol')
 
     def checkrev(self, repo, ctx, files):
         failed = []
@@ -237,9 +245,9 b' class eolfile(object):'
                 target = self._encode[key]
                 data = ctx[f].data()
                 if (
-                    target == "to-lf"
-                    and "\r\n" in data
-                    or target == "to-crlf"
+                    target == b"to-lf"
+                    and b"\r\n" in data
+                    or target == b"to-crlf"
                     and singlelf.search(data)
                 ):
                     failed.append((f, target, bytes(ctx)))
@@ -254,15 +262,18 b' def parseeol(ui, repo, nodes):'
                 if node is None:
                     # Cannot use workingctx.data() since it would load
                     # and cache the filters before we configure them.
-                    data = repo.wvfs('.hgeol').read()
+                    data = repo.wvfs(b'.hgeol').read()
                 else:
-                    data = repo[node]['.hgeol'].data()
+                    data = repo[node][b'.hgeol'].data()
                 return eolfile(ui, repo.root, data)
             except (IOError, LookupError):
                 pass
     except errormod.ParseError as inst:
         ui.warn(
-            _("warning: ignoring .hgeol file due to parse error " "at %s: %s\n")
+            _(
+                b"warning: ignoring .hgeol file due to parse error "
+                b"at %s: %s\n"
+            )
             % (inst.args[1], inst.args[0])
         )
     return None
@@ -276,10 +287,10 b' def ensureenabled(ui):'
     never loaded. This function ensure the extension is enabled when running
     hooks.
     """
-    if 'eol' in ui._knownconfig:
+    if b'eol' in ui._knownconfig:
         return
-    ui.setconfig('extensions', 'eol', '', source='internal')
-    extensions.loadall(ui, ['eol'])
+    ui.setconfig(b'extensions', b'eol', b'', source=b'internal')
+    extensions.loadall(ui, [b'eol'])
 
 
 def _checkhook(ui, repo, node, headsonly):
@@ -302,14 +313,16 b' def _checkhook(ui, repo, node, headsonly'
             failed.extend(eol.checkrev(repo, ctx, files))
 
     if failed:
-        eols = {'to-lf': 'CRLF', 'to-crlf': 'LF'}
+        eols = {b'to-lf': b'CRLF', b'to-crlf': b'LF'}
         msgs = []
         for f, target, node in sorted(failed):
             msgs.append(
-                _("  %s in %s should not have %s line endings")
+                _(b"  %s in %s should not have %s line endings")
                 % (f, node, eols[target])
             )
-        raise errormod.Abort(_("end-of-line check failed:\n") + "\n".join(msgs))
+        raise errormod.Abort(
+            _(b"end-of-line check failed:\n") + b"\n".join(msgs)
+        )
 
 
 def checkallhook(ui, repo, node, hooktype, **kwargs):
@@ -333,16 +346,16 b' def preupdate(ui, repo, hooktype, parent'
 
 
 def uisetup(ui):
-    ui.setconfig('hooks', 'preupdate.eol', preupdate, 'eol')
+    ui.setconfig(b'hooks', b'preupdate.eol', preupdate, b'eol')
 
 
 def extsetup(ui):
     try:
-        extensions.find('win32text')
+        extensions.find(b'win32text')
         ui.warn(
             _(
-                "the eol extension is incompatible with the "
-                "win32text extension\n"
+                b"the eol extension is incompatible with the "
+                b"win32text extension\n"
             )
         )
     except KeyError:
@@ -357,7 +370,7 b' def reposetup(ui, repo):'
     for name, fn in filters.iteritems():
         repo.adddatafilter(name, fn)
 
-    ui.setconfig('patch', 'eol', 'auto', 'eol')
+    ui.setconfig(b'patch', b'eol', b'auto', b'eol')
 
     class eolrepo(repo.__class__):
         def loadeol(self, nodes):
@@ -368,37 +381,37 b' def reposetup(ui, repo):'
             return eol.match
 
         def _hgcleardirstate(self):
-            self._eolmatch = self.loadeol([None, 'tip'])
+            self._eolmatch = self.loadeol([None, b'tip'])
             if not self._eolmatch:
                 self._eolmatch = util.never
                 return
 
             oldeol = None
             try:
-                cachemtime = os.path.getmtime(self.vfs.join("eol.cache"))
+                cachemtime = os.path.getmtime(self.vfs.join(b"eol.cache"))
             except OSError:
                 cachemtime = 0
             else:
-                olddata = self.vfs.read("eol.cache")
+                olddata = self.vfs.read(b"eol.cache")
                 if olddata:
                     oldeol = eolfile(self.ui, self.root, olddata)
 
             try:
-                eolmtime = os.path.getmtime(self.wjoin(".hgeol"))
+                eolmtime = os.path.getmtime(self.wjoin(b".hgeol"))
             except OSError:
                 eolmtime = 0
 
             if eolmtime > cachemtime:
-                self.ui.debug("eol: detected change in .hgeol\n")
+                self.ui.debug(b"eol: detected change in .hgeol\n")
 
-                hgeoldata = self.wvfs.read('.hgeol')
+                hgeoldata = self.wvfs.read(b'.hgeol')
                 neweol = eolfile(self.ui, self.root, hgeoldata)
 
                 wlock = None
                 try:
                     wlock = self.wlock()
                     for f in self.dirstate:
-                        if self.dirstate[f] != 'n':
+                        if self.dirstate[f] != b'n':
                             continue
                         if oldeol is not None:
                             if not oldeol.match(f) and not neweol.match(f):
@@ -419,7 +432,7 b' def reposetup(ui, repo):'
                         # the new .hgeol file specify a different filter
                         self.dirstate.normallookup(f)
                     # Write the cache to update mtime and cache .hgeol
-                    with self.vfs("eol.cache", "w") as f:
+                    with self.vfs(b"eol.cache", b"w") as f:
                         f.write(hgeoldata)
                 except errormod.LockUnavailable:
                     # If we cannot lock the repository and clear the
@@ -447,7 +460,7 b' def reposetup(ui, repo):'
                     continue
                 if inconsistenteol(data):
                     raise errormod.Abort(
-                        _("inconsistent newline style " "in %s\n") % f
+                        _(b"inconsistent newline style " b"in %s\n") % f
                     )
             return super(eolrepo, self).commitctx(ctx, error, origctx)
 

hgext/extdiff.py

@@ -118,26 +118,26 b' configtable = {}'
 configitem = registrar.configitem(configtable)
 
 configitem(
-    'extdiff', br'opts\..*', default='', generic=True,
+    b'extdiff', br'opts\..*', default=b'', generic=True,
 )
 
 configitem(
-    'extdiff', br'gui\..*', generic=True,
+    b'extdiff', br'gui\..*', generic=True,
 )
 
 configitem(
-    'diff-tools', br'.*\.diffargs$', default=None, generic=True,
+    b'diff-tools', br'.*\.diffargs$', default=None, generic=True,
 )
 
 configitem(
-    'diff-tools', br'.*\.gui$', generic=True,
+    b'diff-tools', br'.*\.gui$', generic=True,
 )
 
 # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
-testedwith = 'ships-with-hg-core'
+testedwith = b'ships-with-hg-core'
 
 
 def snapshot(ui, repo, files, node, tmproot, listsubrepos):
@@ -145,40 +145,40 b' def snapshot(ui, repo, files, node, tmpr'
     if not using snapshot, -I/-X does not work and recursive diff
     in tools like kdiff3 and meld displays too many files.'''
     dirname = os.path.basename(repo.root)
-    if dirname == "":
-        dirname = "root"
+    if dirname == b"":
+        dirname = b"root"
     if node is not None:
-        dirname = '%s.%s' % (dirname, short(node))
+        dirname = b'%s.%s' % (dirname, short(node))
     base = os.path.join(tmproot, dirname)
     os.mkdir(base)
     fnsandstat = []
 
     if node is not None:
         ui.note(
-            _('making snapshot of %d files from rev %s\n')
+            _(b'making snapshot of %d files from rev %s\n')
             % (len(files), short(node))
         )
     else:
         ui.note(
-            _('making snapshot of %d files from working directory\n')
+            _(b'making snapshot of %d files from working directory\n')
             % (len(files))
         )
 
     if files:
-        repo.ui.setconfig("ui", "archivemeta", False)
+        repo.ui.setconfig(b"ui", b"archivemeta", False)
 
         archival.archive(
             repo,
             base,
             node,
-            'files',
+            b'files',
             match=scmutil.matchfiles(repo, files),
             subrepos=listsubrepos,
         )
 
         for fn in sorted(files):
             wfn = util.pconvert(fn)
-            ui.note('  %s\n' % wfn)
+            ui.note(b'  %s\n' % wfn)
 
             if node is None:
                 dest = os.path.join(base, wfn)
@@ -202,20 +202,20 b' def formatcmdline('
     # When not operating in 3-way mode, an empty string is
     # returned for parent2
     replace = {
-        'parent': parent1,
-        'parent1': parent1,
-        'parent2': parent2,
-        'plabel1': plabel1,
-        'plabel2': plabel2,
-        'child': child,
-        'clabel': clabel,
-        'root': repo_root,
+        b'parent': parent1,
+        b'parent1': parent1,
+        b'parent2': parent2,
+        b'plabel1': plabel1,
+        b'plabel2': plabel2,
+        b'child': child,
+        b'clabel': clabel,
+        b'root': repo_root,
     }
 
     def quote(match):
         pre = match.group(2)
         key = match.group(3)
-        if not do3way and key == 'parent2':
+        if not do3way and key == b'parent2':
             return pre
         return pre + procutil.shellquote(replace[key])
 
@@ -225,7 +225,7 b' def formatcmdline('
         br'\$(parent2|parent1?|child|plabel1|plabel2|clabel|root)\1'
     )
     if not do3way and not re.search(regex, cmdline):
-        cmdline += ' $parent1 $child'
+        cmdline += b' $parent1 $child'
     return re.sub(regex, quote, cmdline)
 
 
@@ -273,8 +273,8 b' def _runperfilediff('
         if not os.path.isfile(path1a):
             path1a = os.devnull
 
-        path1b = ''
-        label1b = ''
+        path1b = b''
+        label1b = b''
         if do3way:
             path1b = os.path.join(tmproot, dir1b, commonfile)
             label1b = commonfile + rev1b
@@ -286,24 +286,24 b' def _runperfilediff('
 
         if confirm:
             # Prompt before showing this diff
-            difffiles = _('diff %s (%d of %d)') % (
+            difffiles = _(b'diff %s (%d of %d)') % (
                 commonfile,
                 idx + 1,
                 totalfiles,
             )
             responses = _(
-                '[Yns?]'
-                '$$ &Yes, show diff'
-                '$$ &No, skip this diff'
-                '$$ &Skip remaining diffs'
-                '$$ &? (display help)'
+                b'[Yns?]'
+                b'$$ &Yes, show diff'
+                b'$$ &No, skip this diff'
+                b'$$ &Skip remaining diffs'
+                b'$$ &? (display help)'
             )
-            r = ui.promptchoice('%s %s' % (difffiles, responses))
+            r = ui.promptchoice(b'%s %s' % (difffiles, responses))
             if r == 3:  # ?
                 while r == 3:
                     for c, t in ui.extractchoices(responses)[1]:
-                        ui.write('%s - %s\n' % (c, encoding.lower(t)))
-                    r = ui.promptchoice('%s %s' % (difffiles, responses))
+                        ui.write(b'%s - %s\n' % (c, encoding.lower(t)))
+                    r = ui.promptchoice(b'%s %s' % (difffiles, responses))
             if r == 0:  # yes
                 pass
             elif r == 1:  # no
@@ -331,22 +331,22 b' def _runperfilediff('
             # as we know, the tool doesn't have a GUI, in which case
             # we can't run multiple CLI programs at the same time.
             ui.debug(
-                'running %r in %s\n' % (pycompat.bytestr(curcmdline), tmproot)
+                b'running %r in %s\n' % (pycompat.bytestr(curcmdline), tmproot)
             )
-            ui.system(curcmdline, cwd=tmproot, blockedtag='extdiff')
+            ui.system(curcmdline, cwd=tmproot, blockedtag=b'extdiff')
         else:
             # Run the comparison program but don't wait, as we're
             # going to rapid-fire each file diff and then wait on
             # the whole group.
             ui.debug(
-                'running %r in %s (backgrounded)\n'
+                b'running %r in %s (backgrounded)\n'
                 % (pycompat.bytestr(curcmdline), tmproot)
             )
             proc = _systembackground(curcmdline, cwd=tmproot)
             waitprocs.append(proc)
 
     if waitprocs:
-        with ui.timeblockedsection('extdiff'):
+        with ui.timeblockedsection(b'extdiff'):
             for proc in waitprocs:
                 proc.wait()
 
@@ -360,12 +360,12 b' def dodiff(ui, repo, cmdline, pats, opts'
     - just invoke the diff for a single file in the working dir
     '''
 
-    revs = opts.get('rev')
-    change = opts.get('change')
-    do3way = '$parent2' in cmdline
+    revs = opts.get(b'rev')
+    change = opts.get(b'change')
+    do3way = b'$parent2' in cmdline
 
     if revs and change:
-        msg = _('cannot specify --rev and --change at the same time')
+        msg = _(b'cannot specify --rev and --change at the same time')
         raise error.Abort(msg)
     elif change:
         ctx2 = scmutil.revsingle(repo, change, None)
@@ -377,8 +377,8 b' def dodiff(ui, repo, cmdline, pats, opts'
         else:
             ctx1b = repo[nullid]
 
-    perfile = opts.get('per_file')
-    confirm = opts.get('confirm')
+    perfile = opts.get(b'per_file')
+    confirm = opts.get(b'confirm')
 
     node1a = ctx1a.node()
     node1b = ctx1b.node()
@@ -389,17 +389,17 b' def dodiff(ui, repo, cmdline, pats, opts'
         if node1b == nullid:
             do3way = False
 
-    subrepos = opts.get('subrepos')
+    subrepos = opts.get(b'subrepos')
 
     matcher = scmutil.match(repo[node2], pats, opts)
 
-    if opts.get('patch'):
+    if opts.get(b'patch'):
         if subrepos:
-            raise error.Abort(_('--patch cannot be used with --subrepos'))
+            raise error.Abort(_(b'--patch cannot be used with --subrepos'))
         if perfile:
-            raise error.Abort(_('--patch cannot be used with --per-file'))
+            raise error.Abort(_(b'--patch cannot be used with --per-file'))
         if node2 is None:
-            raise error.Abort(_('--patch requires two revisions'))
+            raise error.Abort(_(b'--patch requires two revisions'))
     else:
         mod_a, add_a, rem_a = map(
             set, repo.status(node1a, node2, matcher, listsubrepos=subrepos)[:3]
@@ -416,33 +416,33 b' def dodiff(ui, repo, cmdline, pats, opts'
         if not common:
             return 0
 
-    tmproot = pycompat.mkdtemp(prefix='extdiff.')
+    tmproot = pycompat.mkdtemp(prefix=b'extdiff.')
     try:
-        if not opts.get('patch'):
+        if not opts.get(b'patch'):
             # Always make a copy of node1a (and node1b, if applicable)
             dir1a_files = mod_a | rem_a | ((mod_b | add_b) - add_a)
             dir1a = snapshot(ui, repo, dir1a_files, node1a, tmproot, subrepos)[
                 0
             ]
-            rev1a = '@%d' % repo[node1a].rev()
+            rev1a = b'@%d' % repo[node1a].rev()
             if do3way:
                 dir1b_files = mod_b | rem_b | ((mod_a | add_a) - add_b)
                 dir1b = snapshot(
                     ui, repo, dir1b_files, node1b, tmproot, subrepos
                 )[0]
-                rev1b = '@%d' % repo[node1b].rev()
+                rev1b = b'@%d' % repo[node1b].rev()
             else:
                 dir1b = None
-                rev1b = ''
+                rev1b = b''
 
             fnsandstat = []
 
             # If node2 in not the wc or there is >1 change, copy it
-            dir2root = ''
-            rev2 = ''
+            dir2root = b''
+            rev2 = b''
             if node2:
                 dir2 = snapshot(ui, repo, modadd, node2, tmproot, subrepos)[0]
-                rev2 = '@%d' % repo[node2].rev()
+                rev2 = b'@%d' % repo[node2].rev()
             elif len(common) > 1:
                 # we only actually need to get the files to copy back to
                 # the working dir in this case (because the other cases
@@ -453,7 +453,7 b' def dodiff(ui, repo, cmdline, pats, opts'
                 )
             else:
                 # This lets the diff tool open the changed file directly
-                dir2 = ''
+                dir2 = b''
                 dir2root = repo.root
 
             label1a = rev1a
@@ -476,8 +476,8 b' def dodiff(ui, repo, cmdline, pats, opts'
                 dir2 = os.path.join(dir2root, dir2, common_file)
                 label2 = common_file + rev2
         else:
-            template = 'hg-%h.patch'
-            with formatter.nullformatter(ui, 'extdiff', {}) as fm:
+            template = b'hg-%h.patch'
+            with formatter.nullformatter(ui, b'extdiff', {}) as fm:
                 cmdutil.export(
                     repo,
                     [repo[node1a].rev(), repo[node2].rev()],
@@ -507,9 +507,9 b' def dodiff(ui, repo, cmdline, pats, opts'
                 clabel=label2,
             )
             ui.debug(
-                'running %r in %s\n' % (pycompat.bytestr(cmdline), tmproot)
+                b'running %r in %s\n' % (pycompat.bytestr(cmdline), tmproot)
             )
-            ui.system(cmdline, cwd=tmproot, blockedtag='extdiff')
+            ui.system(cmdline, cwd=tmproot, blockedtag=b'extdiff')
         else:
             # Run the external tool once for each pair of files
             _runperfilediff(
@@ -545,35 +545,41 b' def dodiff(ui, repo, cmdline, pats, opts'
                 or (cpstat.st_mode & 0o100) != (st.st_mode & 0o100)
             ):
                 ui.debug(
-                    'file changed while diffing. '
-                    'Overwriting: %s (src: %s)\n' % (working_fn, copy_fn)
+                    b'file changed while diffing. '
+                    b'Overwriting: %s (src: %s)\n' % (working_fn, copy_fn)
                 )
                 util.copyfile(copy_fn, working_fn)
 
         return 1
     finally:
-        ui.note(_('cleaning up temp directory\n'))
+        ui.note(_(b'cleaning up temp directory\n'))
         shutil.rmtree(tmproot)
 
 
 extdiffopts = (
     [
-        ('o', 'option', [], _('pass option to comparison program'), _('OPT')),
-        ('r', 'rev', [], _('revision'), _('REV')),
-        ('c', 'change', '', _('change made by revision'), _('REV')),
         (
-            '',
-            'per-file',
+            b'o',
+            b'option',
+            [],
+            _(b'pass option to comparison program'),
+            _(b'OPT'),
+        ),
+        (b'r', b'rev', [], _(b'revision'), _(b'REV')),
+        (b'c', b'change', b'', _(b'change made by revision'), _(b'REV')),
+        (
+            b'',
+            b'per-file',
             False,
-            _('compare each file instead of revision snapshots'),
+            _(b'compare each file instead of revision snapshots'),
         ),
         (
-            '',
-            'confirm',
+            b'',
+            b'confirm',
             False,
-            _('prompt user before each external program invocation'),
+            _(b'prompt user before each external program invocation'),
         ),
-        ('', 'patch', None, _('compare patches for two revisions')),
+        (b'', b'patch', None, _(b'compare patches for two revisions')),
     ]
     + cmdutil.walkopts
     + cmdutil.subrepoopts
@@ -581,10 +587,10 b' extdiffopts = ('
 
 
 @command(
-    'extdiff',
-    [('p', 'program', '', _('comparison program to run'), _('CMD')),]
+    b'extdiff',
+    [(b'p', b'program', b'', _(b'comparison program to run'), _(b'CMD')),]
     + extdiffopts,
-    _('hg extdiff [OPT]... [FILE]...'),
+    _(b'hg extdiff [OPT]... [FILE]...'),
     helpcategory=command.CATEGORY_FILE_CONTENTS,
     inferrepo=True,
 )
@@ -620,12 +626,12 b' def extdiff(ui, repo, *pats, **opts):'
     the external program. It is ignored if --per-file isn't specified.
     '''
     opts = pycompat.byteskwargs(opts)
-    program = opts.get('program')
-    option = opts.get('option')
+    program = opts.get(b'program')
+    option = opts.get(b'option')
     if not program:
-        program = 'diff'
-        option = option or ['-Npru']
-    cmdline = ' '.join(map(procutil.shellquote, [program] + option))
+        program = b'diff'
+        option = option or [b'-Npru']
+    cmdline = b' '.join(map(procutil.shellquote, [program] + option))
     return dodiff(ui, repo, cmdline, pats, opts)
 
 
@@ -655,29 +661,29 b' class savedcmd(object):'
 
     def __call__(self, ui, repo, *pats, **opts):
         opts = pycompat.byteskwargs(opts)
-        options = ' '.join(map(procutil.shellquote, opts['option']))
+        options = b' '.join(map(procutil.shellquote, opts[b'option']))
         if options:
-            options = ' ' + options
+            options = b' ' + options
         return dodiff(
             ui, repo, self._cmdline + options, pats, opts, guitool=self._isgui
         )
 
 
 def uisetup(ui):
-    for cmd, path in ui.configitems('extdiff'):
+    for cmd, path in ui.configitems(b'extdiff'):
         path = util.expandpath(path)
-        if cmd.startswith('cmd.'):
+        if cmd.startswith(b'cmd.'):
             cmd = cmd[4:]
             if not path:
                 path = procutil.findexe(cmd)
                 if path is None:
                     path = filemerge.findexternaltool(ui, cmd) or cmd
-            diffopts = ui.config('extdiff', 'opts.' + cmd)
+            diffopts = ui.config(b'extdiff', b'opts.' + cmd)
             cmdline = procutil.shellquote(path)
             if diffopts:
-                cmdline += ' ' + diffopts
-            isgui = ui.configbool('extdiff', 'gui.' + cmd)
-        elif cmd.startswith('opts.') or cmd.startswith('gui.'):
+                cmdline += b' ' + diffopts
+            isgui = ui.configbool(b'extdiff', b'gui.' + cmd)
+        elif cmd.startswith(b'opts.') or cmd.startswith(b'gui.'):
             continue
         else:
             if path:
@@ -691,21 +697,21 b' def uisetup(ui):'
                     path = filemerge.findexternaltool(ui, cmd) or cmd
                 cmdline = procutil.shellquote(path)
                 diffopts = False
-            isgui = ui.configbool('extdiff', 'gui.' + cmd)
+            isgui = ui.configbool(b'extdiff', b'gui.' + cmd)
         # look for diff arguments in [diff-tools] then [merge-tools]
         if not diffopts:
-            key = cmd + '.diffargs'
-            for section in ('diff-tools', 'merge-tools'):
+            key = cmd + b'.diffargs'
+            for section in (b'diff-tools', b'merge-tools'):
                 args = ui.config(section, key)
                 if args:
-                    cmdline += ' ' + args
+                    cmdline += b' ' + args
                     if isgui is None:
-                        isgui = ui.configbool(section, cmd + '.gui') or False
+                        isgui = ui.configbool(section, cmd + b'.gui') or False
                     break
         command(
             cmd,
             extdiffopts[:],
-            _('hg %s [OPTION]... [FILE]...') % cmd,
+            _(b'hg %s [OPTION]... [FILE]...') % cmd,
             helpcategory=command.CATEGORY_FILE_CONTENTS,
             inferrepo=True,
         )(savedcmd(path, cmdline, isgui))

hgext/factotum.py

@@ -69,44 +69,44 b' configtable = {}'
 configitem = registrar.configitem(configtable)
 
 configitem(
-    'factotum', 'executable', default='/bin/auth/factotum',
+    b'factotum', b'executable', default=b'/bin/auth/factotum',
 )
 configitem(
-    'factotum', 'mountpoint', default='/mnt/factotum',
+    b'factotum', b'mountpoint', default=b'/mnt/factotum',
 )
 configitem(
-    'factotum', 'service', default='hg',
+    b'factotum', b'service', default=b'hg',
 )
 
 
 def auth_getkey(self, params):
     if not self.ui.interactive():
-        raise error.Abort(_('factotum not interactive'))
-    if 'user=' not in params:
-        params = '%s user?' % params
-    params = '%s !password?' % params
-    os.system(procutil.tonativestr("%s -g '%s'" % (_executable, params)))
+        raise error.Abort(_(b'factotum not interactive'))
+    if b'user=' not in params:
+        params = b'%s user?' % params
+    params = b'%s !password?' % params
+    os.system(procutil.tonativestr(b"%s -g '%s'" % (_executable, params)))
 
 
 def auth_getuserpasswd(self, getkey, params):
-    params = 'proto=pass %s' % params
+    params = b'proto=pass %s' % params
     while True:
-        fd = os.open('%s/rpc' % _mountpoint, os.O_RDWR)
+        fd = os.open(b'%s/rpc' % _mountpoint, os.O_RDWR)
         try:
-            os.write(fd, 'start %s' % params)
+            os.write(fd, b'start %s' % params)
             l = os.read(fd, ERRMAX).split()
-            if l[0] == 'ok':
-                os.write(fd, 'read')
+            if l[0] == b'ok':
+                os.write(fd, b'read')
                 status, user, passwd = os.read(fd, ERRMAX).split(None, 2)
-                if status == 'ok':
-                    if passwd.startswith("'"):
-                        if passwd.endswith("'"):
-                            passwd = passwd[1:-1].replace("''", "'")
+                if status == b'ok':
+                    if passwd.startswith(b"'"):
+                        if passwd.endswith(b"'"):
+                            passwd = passwd[1:-1].replace(b"''", b"'")
                         else:
-                            raise error.Abort(_('malformed password string'))
+                            raise error.Abort(_(b'malformed password string'))
                     return (user, passwd)
         except (OSError, IOError):
-            raise error.Abort(_('factotum not responding'))
+            raise error.Abort(_(b'factotum not responding'))
         finally:
             os.close(fd)
         getkey(self, params)
@@ -127,18 +127,18 b' def find_user_password(self, realm, auth'
         self._writedebug(user, passwd)
         return (user, passwd)
 
-    prefix = ''
+    prefix = b''
     res = httpconnection.readauthforuri(self.ui, authuri, user)
     if res:
         _, auth = res
-        prefix = auth.get('prefix')
-        user, passwd = auth.get('username'), auth.get('password')
+        prefix = auth.get(b'prefix')
+        user, passwd = auth.get(b'username'), auth.get(b'password')
     if not user or not passwd:
         if not prefix:
-            prefix = realm.split(' ')[0].lower()
-        params = 'service=%s prefix=%s' % (_service, prefix)
+            prefix = realm.split(b' ')[0].lower()
+        params = b'service=%s prefix=%s' % (_service, prefix)
         if user:
-            params = '%s user=%s' % (params, user)
+            params = b'%s user=%s' % (params, user)
         user, passwd = auth_getuserpasswd(self, auth_getkey, params)
 
     self.add_password(realm, authuri, user, passwd)
@@ -148,8 +148,8 b' def find_user_password(self, realm, auth'
 
 def uisetup(ui):
     global _executable
-    _executable = ui.config('factotum', 'executable')
+    _executable = ui.config(b'factotum', b'executable')
     global _mountpoint
-    _mountpoint = ui.config('factotum', 'mountpoint')
+    _mountpoint = ui.config(b'factotum', b'mountpoint')
     global _service
-    _service = ui.config('factotum', 'service')
+    _service = ui.config(b'factotum', b'service')

hgext/fastannotate/__init__.py

@@ -119,56 +119,56 b' from . import ('
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
-testedwith = 'ships-with-hg-core'
+testedwith = b'ships-with-hg-core'
 
 cmdtable = commands.cmdtable
 
 configtable = {}
 configitem = registrar.configitem(configtable)
 
-configitem('fastannotate', 'modes', default=['fastannotate'])
-configitem('fastannotate', 'server', default=False)
-configitem('fastannotate', 'client', default=False)
-configitem('fastannotate', 'unfilteredrepo', default=True)
-configitem('fastannotate', 'defaultformat', default=['number'])
-configitem('fastannotate', 'perfhack', default=False)
-configitem('fastannotate', 'mainbranch')
-configitem('fastannotate', 'forcetext', default=True)
-configitem('fastannotate', 'forcefollow', default=True)
-configitem('fastannotate', 'clientfetchthreshold', default=10)
-configitem('fastannotate', 'serverbuildondemand', default=True)
-configitem('fastannotate', 'remotepath', default='default')
+configitem(b'fastannotate', b'modes', default=[b'fastannotate'])
+configitem(b'fastannotate', b'server', default=False)
+configitem(b'fastannotate', b'client', default=False)
+configitem(b'fastannotate', b'unfilteredrepo', default=True)
+configitem(b'fastannotate', b'defaultformat', default=[b'number'])
+configitem(b'fastannotate', b'perfhack', default=False)
+configitem(b'fastannotate', b'mainbranch')
+configitem(b'fastannotate', b'forcetext', default=True)
+configitem(b'fastannotate', b'forcefollow', default=True)
+configitem(b'fastannotate', b'clientfetchthreshold', default=10)
+configitem(b'fastannotate', b'serverbuildondemand', default=True)
+configitem(b'fastannotate', b'remotepath', default=b'default')
 
 
 def uisetup(ui):
-    modes = set(ui.configlist('fastannotate', 'modes'))
-    if 'fctx' in modes:
-        modes.discard('hgweb')
+    modes = set(ui.configlist(b'fastannotate', b'modes'))
+    if b'fctx' in modes:
+        modes.discard(b'hgweb')
     for name in modes:
-        if name == 'fastannotate':
+        if name == b'fastannotate':
             commands.registercommand()
-        elif name == 'hgweb':
+        elif name == b'hgweb':
             from . import support
 
             support.replacehgwebannotate()
-        elif name == 'fctx':
+        elif name == b'fctx':
             from . import support
 
             support.replacefctxannotate()
             commands.wrapdefault()
         else:
-            raise hgerror.Abort(_('fastannotate: invalid mode: %s') % name)
+            raise hgerror.Abort(_(b'fastannotate: invalid mode: %s') % name)
 
-    if ui.configbool('fastannotate', 'server'):
+    if ui.configbool(b'fastannotate', b'server'):
         protocol.serveruisetup(ui)
 
 
 def extsetup(ui):
     # fastannotate has its own locking, without depending on repo lock
     # TODO: avoid mutating this unless the specific repo has it enabled
-    localrepo.localrepository._wlockfreeprefix.add('fastannotate/')
+    localrepo.localrepository._wlockfreeprefix.add(b'fastannotate/')
 
 
 def reposetup(ui, repo):
-    if ui.configbool('fastannotate', 'client'):
+    if ui.configbool(b'fastannotate', b'client'):
         protocol.clientreposetup(ui, repo)

hgext/fastannotate/commands.py

@@ -34,7 +34,7 b' command = registrar.command(cmdtable)'
 
 def _matchpaths(repo, rev, pats, opts, aopts=facontext.defaultopts):
     """generate paths matching given patterns"""
-    perfhack = repo.ui.configbool('fastannotate', 'perfhack')
+    perfhack = repo.ui.configbool(b'fastannotate', b'perfhack')
 
     # disable perfhack if:
     # a) any walkopt is used
@@ -44,8 +44,8 b' def _matchpaths(repo, rev, pats, opts, a'
         # cwd related to reporoot
         reporoot = os.path.dirname(repo.path)
         reldir = os.path.relpath(encoding.getcwd(), reporoot)
-        if reldir == '.':
-            reldir = ''
+        if reldir == b'.':
+            reldir = b''
         if any(opts.get(o[1]) for o in commands.walkopts):  # a)
             perfhack = False
         else:  # b)
@@ -56,7 +56,7 b' def _matchpaths(repo, rev, pats, opts, a'
             # disable perfhack on '..' since it allows escaping from the repo
             if any(
                 (
-                    '..' in f
+                    b'..' in f
                     or not os.path.isfile(
                         facontext.pathhelper(repo, f, aopts).linelogpath
                     )
@@ -73,7 +73,7 b' def _matchpaths(repo, rev, pats, opts, a'
     else:
 
         def bad(x, y):
-            raise error.Abort("%s: %s" % (x, y))
+            raise error.Abort(b"%s: %s" % (x, y))
 
         ctx = scmutil.revsingle(repo, rev)
         m = scmutil.match(ctx, pats, opts, badfn=bad)
@@ -83,42 +83,57 b' def _matchpaths(repo, rev, pats, opts, a'
 
 fastannotatecommandargs = {
     r'options': [
-        ('r', 'rev', '.', _('annotate the specified revision'), _('REV')),
-        ('u', 'user', None, _('list the author (long with -v)')),
-        ('f', 'file', None, _('list the filename')),
-        ('d', 'date', None, _('list the date (short with -q)')),
-        ('n', 'number', None, _('list the revision number (default)')),
-        ('c', 'changeset', None, _('list the changeset')),
+        (b'r', b'rev', b'.', _(b'annotate the specified revision'), _(b'REV')),
+        (b'u', b'user', None, _(b'list the author (long with -v)')),
+        (b'f', b'file', None, _(b'list the filename')),
+        (b'd', b'date', None, _(b'list the date (short with -q)')),
+        (b'n', b'number', None, _(b'list the revision number (default)')),
+        (b'c', b'changeset', None, _(b'list the changeset')),
+        (
+            b'l',
+            b'line-number',
+            None,
+            _(b'show line number at the first ' b'appearance'),
+        ),
         (
-            'l',
-            'line-number',
+            b'e',
+            b'deleted',
             None,
-            _('show line number at the first ' 'appearance'),
+            _(b'show deleted lines (slow) (EXPERIMENTAL)'),
         ),
-        ('e', 'deleted', None, _('show deleted lines (slow) (EXPERIMENTAL)')),
-        ('', 'no-content', None, _('do not show file content (EXPERIMENTAL)')),
-        ('', 'no-follow', None, _("don't follow copies and renames")),
         (
-            '',
-            'linear',
+            b'',
+            b'no-content',
+            None,
+            _(b'do not show file content (EXPERIMENTAL)'),
+        ),
+        (b'', b'no-follow', None, _(b"don't follow copies and renames")),
+        (
+            b'',
+            b'linear',
             None,
             _(
-                'enforce linear history, ignore second parent '
-                'of merges (EXPERIMENTAL)'
+                b'enforce linear history, ignore second parent '
+                b'of merges (EXPERIMENTAL)'
             ),
         ),
-        ('', 'long-hash', None, _('show long changeset hash (EXPERIMENTAL)')),
         (
-            '',
-            'rebuild',
+            b'',
+            b'long-hash',
             None,
-            _('rebuild cache even if it exists ' '(EXPERIMENTAL)'),
+            _(b'show long changeset hash (EXPERIMENTAL)'),
+        ),
+        (
+            b'',
+            b'rebuild',
+            None,
+            _(b'rebuild cache even if it exists ' b'(EXPERIMENTAL)'),
         ),
     ]
     + commands.diffwsopts
     + commands.walkopts
     + commands.formatteropts,
-    r'synopsis': _('[-r REV] [-f] [-a] [-u] [-d] [-n] [-c] [-l] FILE...'),
+    r'synopsis': _(b'[-r REV] [-f] [-a] [-u] [-d] [-n] [-c] [-l] FILE...'),
     r'inferrepo': True,
 }
 
@@ -155,52 +170,55 b' def fastannotate(ui, repo, *pats, **opts'
         affecting results are used.
     """
     if not pats:
-        raise error.Abort(_('at least one filename or pattern is required'))
+        raise error.Abort(_(b'at least one filename or pattern is required'))
 
     # performance hack: filtered repo can be slow. unfilter by default.
-    if ui.configbool('fastannotate', 'unfilteredrepo'):
+    if ui.configbool(b'fastannotate', b'unfilteredrepo'):
         repo = repo.unfiltered()
 
     opts = pycompat.byteskwargs(opts)
 
-    rev = opts.get('rev', '.')
-    rebuild = opts.get('rebuild', False)
+    rev = opts.get(b'rev', b'.')
+    rebuild = opts.get(b'rebuild', False)
 
     diffopts = patch.difffeatureopts(
-        ui, opts, section='annotate', whitespace=True
+        ui, opts, section=b'annotate', whitespace=True
     )
     aopts = facontext.annotateopts(
         diffopts=diffopts,
-        followmerge=not opts.get('linear', False),
-        followrename=not opts.get('no_follow', False),
+        followmerge=not opts.get(b'linear', False),
+        followrename=not opts.get(b'no_follow', False),
     )
 
     if not any(
-        opts.get(s) for s in ['user', 'date', 'file', 'number', 'changeset']
+        opts.get(s)
+        for s in [b'user', b'date', b'file', b'number', b'changeset']
     ):
         # default 'number' for compatibility. but fastannotate is more
         # efficient with "changeset", "line-number" and "no-content".
-        for name in ui.configlist('fastannotate', 'defaultformat', ['number']):
+        for name in ui.configlist(
+            b'fastannotate', b'defaultformat', [b'number']
+        ):
             opts[name] = True
 
-    ui.pager('fastannotate')
-    template = opts.get('template')
-    if template == 'json':
+    ui.pager(b'fastannotate')
+    template = opts.get(b'template')
+    if template == b'json':
         formatter = faformatter.jsonformatter(ui, repo, opts)
     else:
         formatter = faformatter.defaultformatter(ui, repo, opts)
-    showdeleted = opts.get('deleted', False)
-    showlines = not bool(opts.get('no_content'))
-    showpath = opts.get('file', False)
+    showdeleted = opts.get(b'deleted', False)
+    showlines = not bool(opts.get(b'no_content'))
+    showpath = opts.get(b'file', False)
 
     # find the head of the main (master) branch
-    master = ui.config('fastannotate', 'mainbranch') or rev
+    master = ui.config(b'fastannotate', b'mainbranch') or rev
 
     # paths will be used for prefetching and the real annotating
     paths = list(_matchpaths(repo, rev, pats, opts, aopts))
 
     # for client, prefetch from the server
-    if util.safehasattr(repo, 'prefetchfastannotate'):
+    if util.safehasattr(repo, b'prefetchfastannotate'):
         repo.prefetchfastannotate(paths)
 
     for path in paths:
@@ -238,7 +256,7 b' def fastannotate(ui, repo, *pats, **opts'
 
 _newopts = set()
 _knownopts = {
-    opt[1].replace('-', '_')
+    opt[1].replace(b'-', b'_')
     for opt in (fastannotatecommandargs[r'options'] + commands.globalopts)
 }
 
@@ -246,16 +264,16 b' def fastannotate(ui, repo, *pats, **opts'
 def _annotatewrapper(orig, ui, repo, *pats, **opts):
     """used by wrapdefault"""
     # we need this hack until the obsstore has 0.0 seconds perf impact
-    if ui.configbool('fastannotate', 'unfilteredrepo'):
+    if ui.configbool(b'fastannotate', b'unfilteredrepo'):
         repo = repo.unfiltered()
 
     # treat the file as text (skip the isbinary check)
-    if ui.configbool('fastannotate', 'forcetext'):
+    if ui.configbool(b'fastannotate', b'forcetext'):
         opts[r'text'] = True
 
     # check if we need to do prefetch (client-side)
     rev = opts.get(r'rev')
-    if util.safehasattr(repo, 'prefetchfastannotate') and rev is not None:
+    if util.safehasattr(repo, b'prefetchfastannotate') and rev is not None:
         paths = list(_matchpaths(repo, rev, pats, pycompat.byteskwargs(opts)))
         repo.prefetchfastannotate(paths)
 
@@ -264,20 +282,20 b' def _annotatewrapper(orig, ui, repo, *pa'
 
 def registercommand():
     """register the fastannotate command"""
-    name = 'fastannotate|fastblame|fa'
+    name = b'fastannotate|fastblame|fa'
     command(name, helpbasic=True, **fastannotatecommandargs)(fastannotate)
 
 
 def wrapdefault():
     """wrap the default annotate command, to be aware of the protocol"""
-    extensions.wrapcommand(commands.table, 'annotate', _annotatewrapper)
+    extensions.wrapcommand(commands.table, b'annotate', _annotatewrapper)
 
 
 @command(
-    'debugbuildannotatecache',
-    [('r', 'rev', '', _('build up to the specific revision'), _('REV'))]
+    b'debugbuildannotatecache',
+    [(b'r', b'rev', b'', _(b'build up to the specific revision'), _(b'REV'))]
     + commands.walkopts,
-    _('[-r REV] FILE...'),
+    _(b'[-r REV] FILE...'),
 )
 def debugbuildannotatecache(ui, repo, *pats, **opts):
     """incrementally build fastannotate cache up to REV for specified files
@@ -291,25 +309,25 b' def debugbuildannotatecache(ui, repo, *p'
     options and lives in '.hg/fastannotate/default'.
     """
     opts = pycompat.byteskwargs(opts)
-    rev = opts.get('REV') or ui.config('fastannotate', 'mainbranch')
+    rev = opts.get(b'REV') or ui.config(b'fastannotate', b'mainbranch')
     if not rev:
         raise error.Abort(
-            _('you need to provide a revision'),
-            hint=_('set fastannotate.mainbranch or use --rev'),
+            _(b'you need to provide a revision'),
+            hint=_(b'set fastannotate.mainbranch or use --rev'),
         )
-    if ui.configbool('fastannotate', 'unfilteredrepo'):
+    if ui.configbool(b'fastannotate', b'unfilteredrepo'):
         repo = repo.unfiltered()
     ctx = scmutil.revsingle(repo, rev)
     m = scmutil.match(ctx, pats, opts)
     paths = list(ctx.walk(m))
-    if util.safehasattr(repo, 'prefetchfastannotate'):
+    if util.safehasattr(repo, b'prefetchfastannotate'):
         # client
-        if opts.get('REV'):
-            raise error.Abort(_('--rev cannot be used for client'))
+        if opts.get(b'REV'):
+            raise error.Abort(_(b'--rev cannot be used for client'))
         repo.prefetchfastannotate(paths)
     else:
         # server, or full repo
-        progress = ui.makeprogress(_('building'), total=len(paths))
+        progress = ui.makeprogress(_(b'building'), total=len(paths))
         for i, path in enumerate(paths):
             progress.update(i)
             with facontext.annotatecontext(repo, path) as actx:
@@ -321,7 +339,7 b' def debugbuildannotatecache(ui, repo, *p'
                     # the cache is broken (could happen with renaming so the
                     # file history gets invalidated). rebuild and try again.
                     ui.debug(
-                        'fastannotate: %s: rebuilding broken cache\n' % path
+                        b'fastannotate: %s: rebuilding broken cache\n' % path
                     )
                     actx.rebuild()
                     try:
@@ -331,8 +349,8 b' def debugbuildannotatecache(ui, repo, *p'
                         # cache for other files.
                         ui.warn(
                             _(
-                                'fastannotate: %s: failed to '
-                                'build cache: %r\n'
+                                b'fastannotate: %s: failed to '
+                                b'build cache: %r\n'
                             )
                             % (path, ex)
                         )

hgext/fastannotate/context.py

@@ -52,7 +52,7 b' def _parents(f, follow=True):'
     # renamed filectx won't have a filelog yet, so set it
     # from the cache to save time
     for p in pl:
-        if not '_filelog' in p.__dict__:
+        if not b'_filelog' in p.__dict__:
             p._filelog = _getflog(f._repo, p.path())
 
     return pl
@@ -62,8 +62,8 b' def _parents(f, follow=True):'
 # so it takes a fctx instead of a pair of text and fctx.
 def _decorate(fctx):
     text = fctx.data()
-    linecount = text.count('\n')
-    if text and not text.endswith('\n'):
+    linecount = text.count(b'\n')
+    if text and not text.endswith(b'\n'):
         linecount += 1
     return ([(fctx, i) for i in pycompat.xrange(linecount)], text)
 
@@ -75,7 +75,7 b' def _pair(parent, child, blocks):'
     for (a1, a2, b1, b2), t in blocks:
         # Changed blocks ('!') or blocks made only of blank lines ('~')
         # belong to the child.
-        if t == '=':
+        if t == b'=':
             child[0][b1:b2] = parent[0][a1:a2]
     return child
 
@@ -119,7 +119,7 b' def resolvefctx(repo, rev, path, resolve'
             fctx = repo.filectx(path, changeid=ctx.rev())
     else:
         fctx = ctx[path]
-        if adjustctx == 'linkrev':
+        if adjustctx == b'linkrev':
             introrev = fctx.linkrev()
         else:
             introrev = fctx.introrev()
@@ -132,10 +132,10 b' def resolvefctx(repo, rev, path, resolve'
 # like mercurial.store.encodedir, but use linelog suffixes: .m, .l, .lock
 def encodedir(path):
     return (
-        path.replace('.hg/', '.hg.hg/')
-        .replace('.l/', '.l.hg/')
-        .replace('.m/', '.m.hg/')
-        .replace('.lock/', '.lock.hg/')
+        path.replace(b'.hg/', b'.hg.hg/')
+        .replace(b'.l/', b'.l.hg/')
+        .replace(b'.m/', b'.m.hg/')
+        .replace(b'.lock/', b'.lock.hg/')
     )
 
 
@@ -157,9 +157,9 b' class annotateopts(object):'
     """
 
     defaults = {
-        'diffopts': None,
-        'followrename': True,
-        'followmerge': True,
+        b'diffopts': None,
+        b'followrename': True,
+        b'followmerge': True,
     }
 
     def __init__(self, **opts):
@@ -170,17 +170,17 b' class annotateopts(object):'
     @util.propertycache
     def shortstr(self):
         """represent opts in a short string, suitable for a directory name"""
-        result = ''
+        result = b''
         if not self.followrename:
-            result += 'r0'
+            result += b'r0'
         if not self.followmerge:
-            result += 'm0'
+            result += b'm0'
         if self.diffopts is not None:
             assert isinstance(self.diffopts, mdiff.diffopts)
             diffopthash = hashdiffopts(self.diffopts)
             if diffopthash != _defaultdiffopthash:
-                result += 'i' + diffopthash
-        return result or 'default'
+                result += b'i' + diffopthash
+        return result or b'default'
 
 
 defaultopts = annotateopts()
@@ -206,7 +206,7 b' class _annotatecontext(object):'
     def linelog(self):
         if self._linelog is None:
             if os.path.exists(self.linelogpath):
-                with open(self.linelogpath, 'rb') as f:
+                with open(self.linelogpath, b'rb') as f:
                     try:
                         self._linelog = linelogmod.linelog.fromdata(f.read())
                     except linelogmod.LineLogError:
@@ -226,7 +226,7 b' class _annotatecontext(object):'
             self._revmap.flush()
             self._revmap = None
         if self._linelog is not None:
-            with open(self.linelogpath, 'wb') as f:
+            with open(self.linelogpath, b'wb') as f:
                 f.write(self._linelog.encode())
             self._linelog = None
 
@@ -308,11 +308,11 b' class _annotatecontext(object):'
         if directly:
             if self.ui.debugflag:
                 self.ui.debug(
-                    'fastannotate: %s: using fast path '
-                    '(resolved fctx: %s)\n'
+                    b'fastannotate: %s: using fast path '
+                    b'(resolved fctx: %s)\n'
                     % (
                         self.path,
-                        stringutil.pprint(util.safehasattr(revfctx, 'node')),
+                        stringutil.pprint(util.safehasattr(revfctx, b'node')),
                     )
                 )
             return self.annotatedirectly(revfctx, showpath, showlines)
@@ -356,8 +356,8 b' class _annotatecontext(object):'
         if masterfctx:
             if masterfctx.rev() is None:
                 raise error.Abort(
-                    _('cannot update linelog to wdir()'),
-                    hint=_('set fastannotate.mainbranch'),
+                    _(b'cannot update linelog to wdir()'),
+                    hint=_(b'set fastannotate.mainbranch'),
                 )
             initvisit.append(masterfctx)
         visit = initvisit[:]
@@ -403,13 +403,13 b' class _annotatecontext(object):'
         if self.ui.debugflag:
             if newmainbranch:
                 self.ui.debug(
-                    'fastannotate: %s: %d new changesets in the main'
-                    ' branch\n' % (self.path, len(newmainbranch))
+                    b'fastannotate: %s: %d new changesets in the main'
+                    b' branch\n' % (self.path, len(newmainbranch))
                 )
             elif not hist:  # no joints, no updates
                 self.ui.debug(
-                    'fastannotate: %s: linelog cannot help in '
-                    'annotating this revision\n' % self.path
+                    b'fastannotate: %s: linelog cannot help in '
+                    b'annotating this revision\n' % self.path
                 )
 
         # prepare annotateresult so we can update linelog incrementally
@@ -418,7 +418,7 b' class _annotatecontext(object):'
         # 3rd DFS does the actual annotate
         visit = initvisit[:]
         progress = self.ui.makeprogress(
-            'building cache', total=len(newmainbranch)
+            b'building cache', total=len(newmainbranch)
         )
         while visit:
             f = visit[-1]
@@ -463,7 +463,7 b' class _annotatecontext(object):'
                 if len(pl) == 2 and self.opts.followmerge:  # merge
                     bannotated = curr[0]
                 if blocks is None:  # no parents, add an empty one
-                    blocks = list(self._diffblocks('', curr[1]))
+                    blocks = list(self._diffblocks(b'', curr[1]))
                 self._appendrev(f, blocks, bannotated)
             elif showpath:  # not append linelog, but we need to record path
                 self._node2path[f.node()] = f.path()
@@ -490,7 +490,7 b' class _annotatecontext(object):'
             if hsh is not None and (hsh, self.path) in self.revmap:
                 f = hsh
         if f is None:
-            adjustctx = 'linkrev' if self._perfhack else True
+            adjustctx = b'linkrev' if self._perfhack else True
             f = self._resolvefctx(rev, adjustctx=adjustctx, resolverev=True)
             result = f in self.revmap
             if not result and self._perfhack:
@@ -511,7 +511,7 b' class _annotatecontext(object):'
         # find a chain from rev to anything in the mainbranch
         if revfctx not in self.revmap:
             chain = [revfctx]
-            a = ''
+            a = b''
             while True:
                 f = chain[-1]
                 pl = self._parentfunc(f)
@@ -589,8 +589,8 b' class _annotatecontext(object):'
                         hsh = annotateresult[idxs[0]][0]
                         if self.ui.debugflag:
                             self.ui.debug(
-                                'fastannotate: reading %s line #%d '
-                                'to resolve lines %r\n'
+                                b'fastannotate: reading %s line #%d '
+                                b'to resolve lines %r\n'
                                 % (node.short(hsh), linenum, idxs)
                             )
                         fctx = self._resolvefctx(hsh, revmap.rev2path(rev))
@@ -603,14 +603,15 b' class _annotatecontext(object):'
 
             # run the annotate and the lines should match to the file content
             self.ui.debug(
-                'fastannotate: annotate %s to resolve lines\n' % node.short(hsh)
+                b'fastannotate: annotate %s to resolve lines\n'
+                % node.short(hsh)
             )
             linelog.annotate(rev)
             fctx = self._resolvefctx(hsh, revmap.rev2path(rev))
             annotated = linelog.annotateresult
             lines = mdiff.splitnewlines(fctx.data())
             if len(lines) != len(annotated):
-                raise faerror.CorruptedFileError('unexpected annotated lines')
+                raise faerror.CorruptedFileError(b'unexpected annotated lines')
             # resolve lines from the annotate result
             for i, line in enumerate(lines):
                 k = annotated[i]
@@ -633,11 +634,11 b' class _annotatecontext(object):'
         llrev = self.revmap.hsh2rev(hsh)
         if not llrev:
             raise faerror.CorruptedFileError(
-                '%s is not in revmap' % node.hex(hsh)
+                b'%s is not in revmap' % node.hex(hsh)
             )
         if (self.revmap.rev2flag(llrev) & revmapmod.sidebranchflag) != 0:
             raise faerror.CorruptedFileError(
-                '%s is not in revmap mainbranch' % node.hex(hsh)
+                b'%s is not in revmap mainbranch' % node.hex(hsh)
             )
         self.linelog.annotate(llrev)
         result = [
@@ -677,7 +678,7 b' class _annotatecontext(object):'
             """(fctx) -> int"""
             # f should not be a linelog revision
             if isinstance(f, int):
-                raise error.ProgrammingError('f should not be an int')
+                raise error.ProgrammingError(b'f should not be an int')
             # f is a fctx, allocate linelog rev on demand
             hsh = f.node()
             rev = revmap.hsh2rev(hsh)
@@ -690,7 +691,7 b' class _annotatecontext(object):'
         siderevmap = {}  # node: int
         if bannotated is not None:
             for (a1, a2, b1, b2), op in blocks:
-                if op != '=':
+                if op != b'=':
                     # f could be either linelong rev, or fctx.
                     siderevs += [
                         f
@@ -708,7 +709,7 b' class _annotatecontext(object):'
         siderevmap[fctx] = llrev
 
         for (a1, a2, b1, b2), op in reversed(blocks):
-            if op == '=':
+            if op == b'=':
                 continue
             if bannotated is None:
                 linelog.replacelines(llrev, a1, a2, b1, b2)
@@ -760,7 +761,7 b' class _annotatecontext(object):'
 
     @util.propertycache
     def _perfhack(self):
-        return self.ui.configbool('fastannotate', 'perfhack')
+        return self.ui.configbool(b'fastannotate', b'perfhack')
 
     def _resolvefctx(self, rev, path=None, **kwds):
         return resolvefctx(self.repo, rev, (path or self.path), **kwds)
@@ -781,7 +782,7 b' class pathhelper(object):'
     def __init__(self, repo, path, opts=defaultopts):
         # different options use different directories
         self._vfspath = os.path.join(
-            'fastannotate', opts.shortstr, encodedir(path)
+            b'fastannotate', opts.shortstr, encodedir(path)
         )
         self._repo = repo
 
@@ -791,14 +792,14 b' class pathhelper(object):'
 
     @property
     def linelogpath(self):
-        return self._repo.vfs.join(self._vfspath + '.l')
+        return self._repo.vfs.join(self._vfspath + b'.l')
 
     def lock(self):
-        return lockmod.lock(self._repo.vfs, self._vfspath + '.lock')
+        return lockmod.lock(self._repo.vfs, self._vfspath + b'.lock')
 
     @property
     def revmappath(self):
-        return self._repo.vfs.join(self._vfspath + '.m')
+        return self._repo.vfs.join(self._vfspath + b'.m')
 
 
 @contextlib.contextmanager
@@ -831,7 +832,7 b' def annotatecontext(repo, path, opts=def'
     except Exception:
         if actx is not None:
             actx.rebuild()
-        repo.ui.debug('fastannotate: %s: cache broken and deleted\n' % path)
+        repo.ui.debug(b'fastannotate: %s: cache broken and deleted\n' % path)
         raise
     finally:
         if actx is not None:
@@ -844,7 +845,7 b' def fctxannotatecontext(fctx, follow=Tru'
     """
     repo = fctx._repo
     path = fctx._path
-    if repo.ui.configbool('fastannotate', 'forcefollow', True):
+    if repo.ui.configbool(b'fastannotate', b'forcefollow', True):
         follow = True
     aopts = annotateopts(diffopts=diffopts, followrename=follow)
     return annotatecontext(repo, path, aopts, rebuild)

hgext/fastannotate/formatter.py

@@ -33,35 +33,35 b' class defaultformatter(object):'
         hexfunc = self._hexfunc
 
         # special handling working copy "changeset" and "rev" functions
-        if self.opts.get('rev') == 'wdir()':
+        if self.opts.get(b'rev') == b'wdir()':
             orig = hexfunc
             hexfunc = lambda x: None if x is None else orig(x)
-            wnode = hexfunc(repo['.'].node()) + '+'
-            wrev = '%d' % repo['.'].rev()
-            wrevpad = ''
-            if not opts.get('changeset'):  # only show + if changeset is hidden
-                wrev += '+'
-                wrevpad = ' '
-            revenc = lambda x: wrev if x is None else ('%d' % x) + wrevpad
+            wnode = hexfunc(repo[b'.'].node()) + b'+'
+            wrev = b'%d' % repo[b'.'].rev()
+            wrevpad = b''
+            if not opts.get(b'changeset'):  # only show + if changeset is hidden
+                wrev += b'+'
+                wrevpad = b' '
+            revenc = lambda x: wrev if x is None else (b'%d' % x) + wrevpad
 
             def csetenc(x):
                 if x is None:
                     return wnode
-                return pycompat.bytestr(x) + ' '
+                return pycompat.bytestr(x) + b' '
 
         else:
             revenc = csetenc = pycompat.bytestr
 
         # opt name, separator, raw value (for json/plain), encoder (for plain)
         opmap = [
-            ('user', ' ', lambda x: getctx(x).user(), ui.shortuser),
-            ('number', ' ', lambda x: getctx(x).rev(), revenc),
-            ('changeset', ' ', lambda x: hexfunc(x[0]), csetenc),
-            ('date', ' ', lambda x: getctx(x).date(), datefunc),
-            ('file', ' ', lambda x: x[2], pycompat.bytestr),
-            ('line_number', ':', lambda x: x[1] + 1, pycompat.bytestr),
+            (b'user', b' ', lambda x: getctx(x).user(), ui.shortuser),
+            (b'number', b' ', lambda x: getctx(x).rev(), revenc),
+            (b'changeset', b' ', lambda x: hexfunc(x[0]), csetenc),
+            (b'date', b' ', lambda x: getctx(x).date(), datefunc),
+            (b'file', b' ', lambda x: x[2], pycompat.bytestr),
+            (b'line_number', b':', lambda x: x[1] + 1, pycompat.bytestr),
         ]
-        fieldnamemap = {'number': 'rev', 'changeset': 'node'}
+        fieldnamemap = {b'number': b'rev', b'changeset': b'node'}
         funcmap = [
             (get, sep, fieldnamemap.get(op, op), enc)
             for op, sep, get, enc in opmap
@@ -69,7 +69,7 b' class defaultformatter(object):'
         ]
         # no separator for first column
         funcmap[0] = list(funcmap[0])
-        funcmap[0][1] = ''
+        funcmap[0][1] = b''
         self.funcmap = funcmap
 
     def write(self, annotatedresult, lines=None, existinglines=None):
@@ -83,39 +83,39 b' class defaultformatter(object):'
         for f, sep, name, enc in self.funcmap:
             l = [enc(f(x)) for x in annotatedresult]
             pieces.append(l)
-            if name in ['node', 'date']:  # node and date has fixed size
+            if name in [b'node', b'date']:  # node and date has fixed size
                 l = l[:1]
             widths = pycompat.maplist(encoding.colwidth, set(l))
             maxwidth = max(widths) if widths else 0
             maxwidths.append(maxwidth)
 
         # buffered output
-        result = ''
+        result = b''
         for i in pycompat.xrange(len(annotatedresult)):
             for j, p in enumerate(pieces):
                 sep = self.funcmap[j][1]
-                padding = ' ' * (maxwidths[j] - len(p[i]))
+                padding = b' ' * (maxwidths[j] - len(p[i]))
                 result += sep + padding + p[i]
             if lines:
                 if existinglines is None:
-                    result += ': ' + lines[i]
+                    result += b': ' + lines[i]
                 else:  # extra formatting showing whether a line exists
                     key = (annotatedresult[i][0], annotatedresult[i][1])
                     if key in existinglines:
-                        result += ':  ' + lines[i]
+                        result += b':  ' + lines[i]
                     else:
-                        result += ': ' + self.ui.label(
-                            '-' + lines[i], 'diff.deleted'
+                        result += b': ' + self.ui.label(
+                            b'-' + lines[i], b'diff.deleted'
                         )
 
-            if result[-1:] != '\n':
-                result += '\n'
+            if result[-1:] != b'\n':
+                result += b'\n'
 
         self.ui.write(result)
 
     @util.propertycache
     def _hexfunc(self):
-        if self.ui.debugflag or self.opts.get('long_hash'):
+        if self.ui.debugflag or self.opts.get(b'long_hash'):
             return node.hex
         else:
             return node.short
@@ -127,7 +127,7 b' class defaultformatter(object):'
 class jsonformatter(defaultformatter):
     def __init__(self, ui, repo, opts):
         super(jsonformatter, self).__init__(ui, repo, opts)
-        self.ui.write('[')
+        self.ui.write(b'[')
         self.needcomma = False
 
     def write(self, annotatedresult, lines=None, existinglines=None):
@@ -139,23 +139,23 b' class jsonformatter(defaultformatter):'
             for f, sep, name, enc in self.funcmap
         ]
         if lines is not None:
-            pieces.append(('line', lines))
+            pieces.append((b'line', lines))
         pieces.sort()
 
-        seps = [','] * len(pieces[:-1]) + ['']
+        seps = [b','] * len(pieces[:-1]) + [b'']
 
-        result = ''
+        result = b''
         lasti = len(annotatedresult) - 1
         for i in pycompat.xrange(len(annotatedresult)):
-            result += '\n {\n'
+            result += b'\n {\n'
             for j, p in enumerate(pieces):
                 k, vs = p
-                result += '  "%s": %s%s\n' % (
+                result += b'  "%s": %s%s\n' % (
                     k,
                     templatefilters.json(vs[i], paranoid=False),
                     seps[j],
                 )
-            result += ' }%s' % ('' if i == lasti else ',')
+            result += b' }%s' % (b'' if i == lasti else b',')
         if lasti >= 0:
             self.needcomma = True
 
@@ -163,7 +163,7 b' class jsonformatter(defaultformatter):'
 
     def _writecomma(self):
         if self.needcomma:
-            self.ui.write(',')
+            self.ui.write(b',')
             self.needcomma = False
 
     @util.propertycache
@@ -171,4 +171,4 b' class jsonformatter(defaultformatter):'
         return node.hex
 
     def end(self):
-        self.ui.write('\n]\n')
+        self.ui.write(b'\n]\n')

hgext/fastannotate/protocol.py

@@ -25,12 +25,12 b' from . import context'
 
 def _getmaster(ui):
     """get the mainbranch, and enforce it is set"""
-    master = ui.config('fastannotate', 'mainbranch')
+    master = ui.config(b'fastannotate', b'mainbranch')
     if not master:
         raise error.Abort(
             _(
-                'fastannotate.mainbranch is required '
-                'for both the client and the server'
+                b'fastannotate.mainbranch is required '
+                b'for both the client and the server'
             )
         )
     return master
@@ -41,7 +41,7 b' def _getmaster(ui):'
 
 def _capabilities(orig, repo, proto):
     result = orig(repo, proto)
-    result.append('getannotate')
+    result.append(b'getannotate')
     return result
 
 
@@ -49,9 +49,9 b' def _getannotate(repo, proto, path, last'
     # output:
     #   FILE := vfspath + '\0' + str(size) + '\0' + content
     #   OUTPUT := '' | FILE + OUTPUT
-    result = ''
+    result = b''
     buildondemand = repo.ui.configbool(
-        'fastannotate', 'serverbuildondemand', True
+        b'fastannotate', b'serverbuildondemand', True
     )
     with context.annotatecontext(repo, path) as actx:
         if buildondemand:
@@ -80,25 +80,25 b' def _getannotate(repo, proto, path, last'
             for p in [actx.revmappath, actx.linelogpath]:
                 if not os.path.exists(p):
                     continue
-                with open(p, 'rb') as f:
+                with open(p, b'rb') as f:
                     content = f.read()
-                vfsbaselen = len(repo.vfs.base + '/')
+                vfsbaselen = len(repo.vfs.base + b'/')
                 relpath = p[vfsbaselen:]
-                result += '%s\0%d\0%s' % (relpath, len(content), content)
+                result += b'%s\0%d\0%s' % (relpath, len(content), content)
     return result
 
 
 def _registerwireprotocommand():
-    if 'getannotate' in wireprotov1server.commands:
+    if b'getannotate' in wireprotov1server.commands:
         return
-    wireprotov1server.wireprotocommand('getannotate', 'path lastnode')(
+    wireprotov1server.wireprotocommand(b'getannotate', b'path lastnode')(
         _getannotate
     )
 
 
 def serveruisetup(ui):
     _registerwireprotocommand()
-    extensions.wrapfunction(wireprotov1server, '_capabilities', _capabilities)
+    extensions.wrapfunction(wireprotov1server, b'_capabilities', _capabilities)
 
 
 # client-side
@@ -109,15 +109,15 b' def _parseresponse(payload):'
     i = 0
     l = len(payload) - 1
     state = 0  # 0: vfspath, 1: size
-    vfspath = size = ''
+    vfspath = size = b''
     while i < l:
         ch = payload[i : i + 1]
-        if ch == '\0':
+        if ch == b'\0':
             if state == 1:
                 result[vfspath] = payload[i + 1 : i + 1 + int(size)]
                 i += int(size)
                 state = 0
-                vfspath = size = ''
+                vfspath = size = b''
             elif state == 0:
                 state = 1
         else:
@@ -133,11 +133,11 b' def peersetup(ui, peer):'
     class fastannotatepeer(peer.__class__):
         @wireprotov1peer.batchable
         def getannotate(self, path, lastnode=None):
-            if not self.capable('getannotate'):
-                ui.warn(_('remote peer cannot provide annotate cache\n'))
+            if not self.capable(b'getannotate'):
+                ui.warn(_(b'remote peer cannot provide annotate cache\n'))
                 yield None, None
             else:
-                args = {'path': path, 'lastnode': lastnode or ''}
+                args = {b'path': path, b'lastnode': lastnode or b''}
                 f = wireprotov1peer.future()
                 yield args, f
                 yield _parseresponse(f.value)
@@ -150,7 +150,7 b' def annotatepeer(repo):'
     ui = repo.ui
 
     remotepath = ui.expandpath(
-        ui.config('fastannotate', 'remotepath', 'default')
+        ui.config(b'fastannotate', b'remotepath', b'default')
     )
     peer = hg.peer(ui, {}, remotepath)
 
@@ -175,11 +175,12 b' def clientfetch(repo, paths, lastnodemap'
     ui = repo.ui
     results = []
     with peer.commandexecutor() as batcher:
-        ui.debug('fastannotate: requesting %d files\n' % len(paths))
+        ui.debug(b'fastannotate: requesting %d files\n' % len(paths))
         for p in paths:
             results.append(
                 batcher.callcommand(
-                    'getannotate', {'path': p, 'lastnode': lastnodemap.get(p)}
+                    b'getannotate',
+                    {b'path': p, b'lastnode': lastnodemap.get(p)},
                 )
             )
 
@@ -189,19 +190,21 b' def clientfetch(repo, paths, lastnodemap'
             r = {util.pconvert(p): v for p, v in r.iteritems()}
             for path in sorted(r):
                 # ignore malicious paths
-                if not path.startswith('fastannotate/') or '/../' in (
-                    path + '/'
+                if not path.startswith(b'fastannotate/') or b'/../' in (
+                    path + b'/'
                 ):
-                    ui.debug('fastannotate: ignored malicious path %s\n' % path)
+                    ui.debug(
+                        b'fastannotate: ignored malicious path %s\n' % path
+                    )
                     continue
                 content = r[path]
                 if ui.debugflag:
                     ui.debug(
-                        'fastannotate: writing %d bytes to %s\n'
+                        b'fastannotate: writing %d bytes to %s\n'
                         % (len(content), path)
                     )
                 repo.vfs.makedirs(os.path.dirname(path))
-                with repo.vfs(path, 'wb') as f:
+                with repo.vfs(path, b'wb') as f:
                     f.write(content)
 
 
@@ -209,7 +212,7 b' def _filterfetchpaths(repo, paths):'
     """return a subset of paths whose history is long and need to fetch linelog
     from the server. works with remotefilelog and non-remotefilelog repos.
     """
-    threshold = repo.ui.configint('fastannotate', 'clientfetchthreshold', 10)
+    threshold = repo.ui.configint(b'fastannotate', b'clientfetchthreshold', 10)
     if threshold <= 0:
         return paths
 
@@ -240,7 +243,7 b' def localreposetup(ui, repo):'
                     clientfetch(self, needupdatepaths, lastnodemap, peer)
             except Exception as ex:
                 # could be directory not writable or so, not fatal
-                self.ui.debug('fastannotate: prefetch failed: %r\n' % ex)
+                self.ui.debug(b'fastannotate: prefetch failed: %r\n' % ex)
 
     repo.__class__ = fastannotaterepo
 

hgext/fastannotate/revmap.py

@@ -70,7 +70,7 b' class revmap(object):'
         # since rename does not happen frequently, do not store path for every
         # revision. self._renamerevs can be used for bisecting.
         self._renamerevs = [0]
-        self._renamepaths = ['']
+        self._renamepaths = [b'']
         self._lastmaxrev = -1
         if path:
             if os.path.exists(path):
@@ -98,9 +98,13 b' class revmap(object):'
         if flush is True, incrementally update the file.
         """
         if hsh in self._hsh2rev:
-            raise error.CorruptedFileError('%r is in revmap already' % hex(hsh))
+            raise error.CorruptedFileError(
+                b'%r is in revmap already' % hex(hsh)
+            )
         if len(hsh) != _hshlen:
-            raise hgerror.ProgrammingError('hsh must be %d-char long' % _hshlen)
+            raise hgerror.ProgrammingError(
+                b'hsh must be %d-char long' % _hshlen
+            )
         idx = len(self._rev2hsh)
         flag = 0
         if sidebranch:
@@ -149,7 +153,7 b' class revmap(object):'
         self._rev2hsh = [None]
         self._rev2flag = [None]
         self._hsh2rev = {}
-        self._rev2path = ['']
+        self._rev2path = [b'']
         self._lastmaxrev = -1
         if flush:
             self.flush()
@@ -159,12 +163,12 b' class revmap(object):'
         if not self.path:
             return
         if self._lastmaxrev == -1:  # write the entire file
-            with open(self.path, 'wb') as f:
+            with open(self.path, b'wb') as f:
                 f.write(self.HEADER)
                 for i in pycompat.xrange(1, len(self._rev2hsh)):
                     self._writerev(i, f)
         else:  # append incrementally
-            with open(self.path, 'ab') as f:
+            with open(self.path, b'ab') as f:
                 for i in pycompat.xrange(
                     self._lastmaxrev + 1, len(self._rev2hsh)
                 ):
@@ -179,7 +183,7 b' class revmap(object):'
         # which is faster than both LOAD_CONST and LOAD_GLOBAL.
         flaglen = 1
         hshlen = _hshlen
-        with open(self.path, 'rb') as f:
+        with open(self.path, b'rb') as f:
             if f.read(len(self.HEADER)) != self.HEADER:
                 raise error.CorruptedFileError()
             self.clear(flush=False)
@@ -205,23 +209,23 b' class revmap(object):'
         """append a revision data to file"""
         flag = self._rev2flag[rev]
         hsh = self._rev2hsh[rev]
-        f.write(struct.pack('B', flag))
+        f.write(struct.pack(b'B', flag))
         if flag & renameflag:
             path = self.rev2path(rev)
             if path is None:
-                raise error.CorruptedFileError('cannot find path for %s' % rev)
+                raise error.CorruptedFileError(b'cannot find path for %s' % rev)
             f.write(path + b'\0')
         f.write(hsh)
 
     @staticmethod
     def _readcstr(f):
         """read a C-language-like '\0'-terminated string"""
-        buf = ''
+        buf = b''
         while True:
             ch = f.read(1)
             if not ch:  # unexpected eof
                 raise error.CorruptedFileError()
-            if ch == '\0':
+            if ch == b'\0':
                 break
             buf += ch
         return buf
@@ -249,7 +253,7 b' def getlastnode(path):'
     """
     hsh = None
     try:
-        with open(path, 'rb') as f:
+        with open(path, b'rb') as f:
             f.seek(-_hshlen, io.SEEK_END)
             if f.tell() > len(revmap.HEADER):
                 hsh = f.read(_hshlen)

hgext/fastannotate/support.py

@@ -64,7 +64,7 b' def _convertoutputs(repo, annotated, con'
 
 def _getmaster(fctx):
     """(fctx) -> str"""
-    return fctx._repo.ui.config('fastannotate', 'mainbranch') or 'default'
+    return fctx._repo.ui.config(b'fastannotate', b'mainbranch') or b'default'
 
 
 def _doannotate(fctx, follow=True, diffopts=None):
@@ -83,7 +83,7 b' def _doannotate(fctx, follow=True, diffo'
         except Exception:
             ac.rebuild()  # try rebuild once
             fctx._repo.ui.debug(
-                'fastannotate: %s: rebuilding broken cache\n' % fctx._path
+                b'fastannotate: %s: rebuilding broken cache\n' % fctx._path
             )
             try:
                 annotated, contents = ac.annotate(
@@ -98,7 +98,7 b' def _doannotate(fctx, follow=True, diffo'
 
 def _hgwebannotate(orig, fctx, ui):
     diffopts = patch.difffeatureopts(
-        ui, untrusted=True, section='annotate', whitespace=True
+        ui, untrusted=True, section=b'annotate', whitespace=True
     )
     return _doannotate(fctx, diffopts=diffopts)
 
@@ -115,7 +115,7 b' def _fctxannotate('
         return _doannotate(self, follow, diffopts)
     except Exception as ex:
         self._repo.ui.debug(
-            'fastannotate: falling back to the vanilla ' 'annotate: %r\n' % ex
+            b'fastannotate: falling back to the vanilla ' b'annotate: %r\n' % ex
         )
         return orig(self, follow=follow, skiprevs=skiprevs, diffopts=diffopts)
 
@@ -130,8 +130,8 b' def _remotefctxannotate(orig, self, foll'
 
 
 def replacehgwebannotate():
-    extensions.wrapfunction(hgweb.webutil, 'annotate', _hgwebannotate)
+    extensions.wrapfunction(hgweb.webutil, b'annotate', _hgwebannotate)
 
 
 def replacefctxannotate():
-    extensions.wrapfunction(hgcontext.basefilectx, 'annotate', _fctxannotate)
+    extensions.wrapfunction(hgcontext.basefilectx, b'annotate', _fctxannotate)

hgext/fetch.py

@@ -30,30 +30,30 b' command = registrar.command(cmdtable)'
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
-testedwith = 'ships-with-hg-core'
+testedwith = b'ships-with-hg-core'
 
 
 @command(
-    'fetch',
+    b'fetch',
     [
         (
-            'r',
-            'rev',
+            b'r',
+            b'rev',
             [],
-            _('a specific revision you would like to pull'),
-            _('REV'),
+            _(b'a specific revision you would like to pull'),
+            _(b'REV'),
         ),
-        ('', 'edit', None, _('invoke editor on commit messages')),
-        ('', 'force-editor', None, _('edit commit message (DEPRECATED)')),
-        ('', 'switch-parent', None, _('switch parents when merging')),
+        (b'', b'edit', None, _(b'invoke editor on commit messages')),
+        (b'', b'force-editor', None, _(b'edit commit message (DEPRECATED)')),
+        (b'', b'switch-parent', None, _(b'switch parents when merging')),
     ]
     + cmdutil.commitopts
     + cmdutil.commitopts2
     + cmdutil.remoteopts,
-    _('hg fetch [SOURCE]'),
+    _(b'hg fetch [SOURCE]'),
     helpcategory=command.CATEGORY_REMOTE_REPO_MANAGEMENT,
 )
-def fetch(ui, repo, source='default', **opts):
+def fetch(ui, repo, source=b'default', **opts):
     '''pull changes from a remote repository, merge new changes if needed.
 
     This finds all changes from the repository at the specified path
@@ -74,9 +74,9 b" def fetch(ui, repo, source='default', **"
     '''
 
     opts = pycompat.byteskwargs(opts)
-    date = opts.get('date')
+    date = opts.get(b'date')
     if date:
-        opts['date'] = dateutil.parsedate(date)
+        opts[b'date'] = dateutil.parsedate(date)
 
     parent = repo.dirstate.p1()
     branch = repo.dirstate.branch()
@@ -86,8 +86,8 b" def fetch(ui, repo, source='default', **"
         branchnode = None
     if parent != branchnode:
         raise error.Abort(
-            _('working directory not at branch tip'),
-            hint=_("use 'hg update' to check out branch tip"),
+            _(b'working directory not at branch tip'),
+            hint=_(b"use 'hg update' to check out branch tip"),
         )
 
     wlock = lock = None
@@ -102,23 +102,23 b" def fetch(ui, repo, source='default', **"
         if len(bheads) > 1:
             raise error.Abort(
                 _(
-                    'multiple heads in this branch '
-                    '(use "hg heads ." and "hg merge" to merge)'
+                    b'multiple heads in this branch '
+                    b'(use "hg heads ." and "hg merge" to merge)'
                 )
             )
 
         other = hg.peer(repo, opts, ui.expandpath(source))
         ui.status(
-            _('pulling from %s\n') % util.hidepassword(ui.expandpath(source))
+            _(b'pulling from %s\n') % util.hidepassword(ui.expandpath(source))
         )
         revs = None
-        if opts['rev']:
+        if opts[b'rev']:
             try:
-                revs = [other.lookup(rev) for rev in opts['rev']]
+                revs = [other.lookup(rev) for rev in opts[b'rev']]
             except error.CapabilityError:
                 err = _(
-                    "other repository doesn't support revision lookup, "
-                    "so a rev cannot be specified."
+                    b"other repository doesn't support revision lookup, "
+                    b"so a rev cannot be specified."
                 )
                 raise error.Abort(err)
 
@@ -146,8 +146,8 b" def fetch(ui, repo, source='default', **"
         if len(newheads) > 1:
             ui.status(
                 _(
-                    'not merging with %d other new branch heads '
-                    '(use "hg heads ." and "hg merge" to merge them)\n'
+                    b'not merging with %d other new branch heads '
+                    b'(use "hg heads ." and "hg merge" to merge them)\n'
                 )
                 % (len(newheads) - 1)
             )
@@ -162,17 +162,17 b" def fetch(ui, repo, source='default', **"
             # By default, we consider the repository we're pulling
             # *from* as authoritative, so we merge our changes into
             # theirs.
-            if opts['switch_parent']:
+            if opts[b'switch_parent']:
                 firstparent, secondparent = newparent, newheads[0]
             else:
                 firstparent, secondparent = newheads[0], newparent
                 ui.status(
-                    _('updating to %d:%s\n')
+                    _(b'updating to %d:%s\n')
                     % (repo.changelog.rev(firstparent), short(firstparent))
                 )
             hg.clean(repo, firstparent)
             ui.status(
-                _('merging with %d:%s\n')
+                _(b'merging with %d:%s\n')
                 % (repo.changelog.rev(secondparent), short(secondparent))
             )
             err = hg.merge(repo, secondparent, remind=False)
@@ -180,13 +180,15 b" def fetch(ui, repo, source='default', **"
         if not err:
             # we don't translate commit messages
             message = cmdutil.logmessage(ui, opts) or (
-                'Automated merge with %s' % util.removeauth(other.url())
+                b'Automated merge with %s' % util.removeauth(other.url())
             )
-            editopt = opts.get('edit') or opts.get('force_editor')
-            editor = cmdutil.getcommiteditor(edit=editopt, editform='fetch')
-            n = repo.commit(message, opts['user'], opts['date'], editor=editor)
+            editopt = opts.get(b'edit') or opts.get(b'force_editor')
+            editor = cmdutil.getcommiteditor(edit=editopt, editform=b'fetch')
+            n = repo.commit(
+                message, opts[b'user'], opts[b'date'], editor=editor
+            )
             ui.status(
-                _('new changeset %d:%s merges remote changes ' 'with local\n')
+                _(b'new changeset %d:%s merges remote changes ' b'with local\n')
                 % (repo.changelog.rev(n), short(n))
             )
 

hgext/fix.py

@@ -157,7 +157,7 b' from mercurial import ('
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
-testedwith = 'ships-with-hg-core'
+testedwith = b'ships-with-hg-core'
 
 cmdtable = {}
 command = registrar.command(cmdtable)
@@ -167,61 +167,61 b' configitem = registrar.configitem(config'
 
 # Register the suboptions allowed for each configured fixer, and default values.
 FIXER_ATTRS = {
-    'command': None,
-    'linerange': None,
-    'pattern': None,
-    'priority': 0,
-    'metadata': 'false',
-    'skipclean': 'true',
-    'enabled': 'true',
+    b'command': None,
+    b'linerange': None,
+    b'pattern': None,
+    b'priority': 0,
+    b'metadata': b'false',
+    b'skipclean': b'true',
+    b'enabled': b'true',
 }
 
 for key, default in FIXER_ATTRS.items():
-    configitem('fix', '.*(:%s)?' % key, default=default, generic=True)
+    configitem(b'fix', b'.*(:%s)?' % key, default=default, generic=True)
 
 # A good default size allows most source code files to be fixed, but avoids
 # letting fixer tools choke on huge inputs, which could be surprising to the
 # user.
-configitem('fix', 'maxfilesize', default='2MB')
+configitem(b'fix', b'maxfilesize', default=b'2MB')
 
 # Allow fix commands to exit non-zero if an executed fixer tool exits non-zero.
 # This helps users do shell scripts that stop when a fixer tool signals a
 # problem.
-configitem('fix', 'failure', default='continue')
+configitem(b'fix', b'failure', default=b'continue')
 
 
 def checktoolfailureaction(ui, message, hint=None):
     """Abort with 'message' if fix.failure=abort"""
-    action = ui.config('fix', 'failure')
-    if action not in ('continue', 'abort'):
+    action = ui.config(b'fix', b'failure')
+    if action not in (b'continue', b'abort'):
         raise error.Abort(
-            _('unknown fix.failure action: %s') % (action,),
-            hint=_('use "continue" or "abort"'),
+            _(b'unknown fix.failure action: %s') % (action,),
+            hint=_(b'use "continue" or "abort"'),
         )
-    if action == 'abort':
+    if action == b'abort':
         raise error.Abort(message, hint=hint)
 
 
-allopt = ('', 'all', False, _('fix all non-public non-obsolete revisions'))
+allopt = (b'', b'all', False, _(b'fix all non-public non-obsolete revisions'))
 baseopt = (
-    '',
-    'base',
+    b'',
+    b'base',
     [],
     _(
-        'revisions to diff against (overrides automatic '
-        'selection, and applies to every revision being '
-        'fixed)'
+        b'revisions to diff against (overrides automatic '
+        b'selection, and applies to every revision being '
+        b'fixed)'
     ),
-    _('REV'),
+    _(b'REV'),
 )
-revopt = ('r', 'rev', [], _('revisions to fix'), _('REV'))
-wdiropt = ('w', 'working-dir', False, _('fix the working directory'))
-wholeopt = ('', 'whole', False, _('always fix every line of a file'))
-usage = _('[OPTION]... [FILE]...')
+revopt = (b'r', b'rev', [], _(b'revisions to fix'), _(b'REV'))
+wdiropt = (b'w', b'working-dir', False, _(b'fix the working directory'))
+wholeopt = (b'', b'whole', False, _(b'always fix every line of a file'))
+usage = _(b'[OPTION]... [FILE]...')
 
 
 @command(
-    'fix',
+    b'fix',
     [allopt, baseopt, revopt, wdiropt, wholeopt],
     usage,
     helpcategory=command.CATEGORY_FILE_CONTENTS,
@@ -250,12 +250,12 b' def fix(ui, repo, *pats, **opts):'
     override this default behavior, though it is not usually desirable to do so.
     """
     opts = pycompat.byteskwargs(opts)
-    if opts['all']:
-        if opts['rev']:
-            raise error.Abort(_('cannot specify both "--rev" and "--all"'))
-        opts['rev'] = ['not public() and not obsolete()']
-        opts['working_dir'] = True
-    with repo.wlock(), repo.lock(), repo.transaction('fix'):
+    if opts[b'all']:
+        if opts[b'rev']:
+            raise error.Abort(_(b'cannot specify both "--rev" and "--all"'))
+        opts[b'rev'] = [b'not public() and not obsolete()']
+        opts[b'working_dir'] = True
+    with repo.wlock(), repo.lock(), repo.transaction(b'fix'):
         revstofix = getrevstofix(ui, repo, opts)
         basectxs = getbasectxs(repo, opts, revstofix)
         workqueue, numitems = getworkqueue(
@@ -297,7 +297,7 b' def fix(ui, repo, *pats, **opts):'
         wdirwritten = False
         commitorder = sorted(revstofix, reverse=True)
         with ui.makeprogress(
-            topic=_('fixing'), unit=_('files'), total=sum(numitems.values())
+            topic=_(b'fixing'), unit=_(b'files'), total=sum(numitems.values())
         ) as progress:
             for rev, path, filerevmetadata, newdata in results:
                 progress.increment(item=path)
@@ -306,12 +306,12 b' def fix(ui, repo, *pats, **opts):'
                 if newdata is not None:
                     filedata[rev][path] = newdata
                     hookargs = {
-                        'rev': rev,
-                        'path': path,
-                        'metadata': filerevmetadata,
+                        b'rev': rev,
+                        b'path': path,
+                        b'metadata': filerevmetadata,
                     }
                     repo.hook(
-                        'postfixfile',
+                        b'postfixfile',
                         throw=False,
                         **pycompat.strkwargs(hookargs)
                     )
@@ -332,11 +332,11 b' def fix(ui, repo, *pats, **opts):'
 
         cleanup(repo, replacements, wdirwritten)
         hookargs = {
-            'replacements': replacements,
-            'wdirwritten': wdirwritten,
-            'metadata': aggregatemetadata,
+            b'replacements': replacements,
+            b'wdirwritten': wdirwritten,
+            b'metadata': aggregatemetadata,
         }
-        repo.hook('postfix', throw=True, **pycompat.strkwargs(hookargs))
+        repo.hook(b'postfix', throw=True, **pycompat.strkwargs(hookargs))
 
 
 def cleanup(repo, replacements, wdirwritten):
@@ -353,7 +353,7 b' def cleanup(repo, replacements, wdirwrit'
     effects of the command, though we choose not to output anything here.
     """
     replacements = {prec: [succ] for prec, succ in replacements.iteritems()}
-    scmutil.cleanupnodes(repo, replacements, 'fix', fixphase=True)
+    scmutil.cleanupnodes(repo, replacements, b'fix', fixphase=True)
 
 
 def getworkqueue(ui, repo, pats, opts, revstofix, basectxs):
@@ -375,7 +375,7 b' def getworkqueue(ui, repo, pats, opts, r'
     """
     workqueue = []
     numitems = collections.defaultdict(int)
-    maxfilesize = ui.configbytes('fix', 'maxfilesize')
+    maxfilesize = ui.configbytes(b'fix', b'maxfilesize')
     for rev in sorted(revstofix):
         fixctx = repo[rev]
         match = scmutil.match(fixctx, pats, opts)
@@ -387,7 +387,7 b' def getworkqueue(ui, repo, pats, opts, r'
                 continue
             if fctx.size() > maxfilesize:
                 ui.warn(
-                    _('ignoring file larger than %s: %s\n')
+                    _(b'ignoring file larger than %s: %s\n')
                     % (util.bytecount(maxfilesize), path)
                 )
                 continue
@@ -398,29 +398,29 b' def getworkqueue(ui, repo, pats, opts, r'
 
 def getrevstofix(ui, repo, opts):
     """Returns the set of revision numbers that should be fixed"""
-    revs = set(scmutil.revrange(repo, opts['rev']))
+    revs = set(scmutil.revrange(repo, opts[b'rev']))
     for rev in revs:
         checkfixablectx(ui, repo, repo[rev])
     if revs:
         cmdutil.checkunfinished(repo)
         checknodescendants(repo, revs)
-    if opts.get('working_dir'):
+    if opts.get(b'working_dir'):
         revs.add(wdirrev)
         if list(merge.mergestate.read(repo).unresolved()):
-            raise error.Abort('unresolved conflicts', hint="use 'hg resolve'")
+            raise error.Abort(b'unresolved conflicts', hint=b"use 'hg resolve'")
     if not revs:
         raise error.Abort(
-            'no changesets specified', hint='use --rev or --working-dir'
+            b'no changesets specified', hint=b'use --rev or --working-dir'
         )
     return revs
 
 
 def checknodescendants(repo, revs):
     if not obsolete.isenabled(repo, obsolete.allowunstableopt) and repo.revs(
-        '(%ld::) - (%ld)', revs, revs
+        b'(%ld::) - (%ld)', revs, revs
     ):
         raise error.Abort(
-            _('can only fix a changeset together ' 'with all its descendants')
+            _(b'can only fix a changeset together ' b'with all its descendants')
         )
 
 
@@ -428,15 +428,18 b' def checkfixablectx(ui, repo, ctx):'
     """Aborts if the revision shouldn't be replaced with a fixed one."""
     if not ctx.mutable():
         raise error.Abort(
-            'can\'t fix immutable changeset %s' % (scmutil.formatchangeid(ctx),)
+            b'can\'t fix immutable changeset %s'
+            % (scmutil.formatchangeid(ctx),)
         )
     if ctx.obsolete():
         # It would be better to actually check if the revision has a successor.
         allowdivergence = ui.configbool(
-            'experimental', 'evolution.allowdivergence'
+            b'experimental', b'evolution.allowdivergence'
         )
         if not allowdivergence:
-            raise error.Abort('fixing obsolete revision could cause divergence')
+            raise error.Abort(
+                b'fixing obsolete revision could cause divergence'
+            )
 
 
 def pathstofix(ui, repo, pats, opts, match, basectxs, fixctx):
@@ -473,10 +476,10 b' def lineranges(opts, path, basectxs, fix'
     Another way to understand this is that we exclude line ranges that are
     common to the file in all base contexts.
     """
-    if opts.get('whole'):
+    if opts.get(b'whole'):
         # Return a range containing all lines. Rely on the diff implementation's
         # idea of how many lines are in the file, instead of reimplementing it.
-        return difflineranges('', content2)
+        return difflineranges(b'', content2)
 
     rangeslist = []
     for basectx in basectxs:
@@ -484,7 +487,7 b' def lineranges(opts, path, basectxs, fix'
         if basepath in basectx:
             content1 = basectx[basepath].data()
         else:
-            content1 = ''
+            content1 = b''
         rangeslist.extend(difflineranges(content1, content2))
     return unionranges(rangeslist)
 
@@ -566,7 +569,7 b' def difflineranges(content1, content2):'
     ranges = []
     for lines, kind in mdiff.allblocks(content1, content2):
         firstline, lastline = lines[2:4]
-        if kind == '!' and firstline != lastline:
+        if kind == b'!' and firstline != lastline:
             ranges.append((firstline + 1, lastline))
     return ranges
 
@@ -581,8 +584,8 b' def getbasectxs(repo, opts, revstofix):'
     """
     # The --base flag overrides the usual logic, and we give every revision
     # exactly the set of baserevs that the user specified.
-    if opts.get('base'):
-        baserevs = set(scmutil.revrange(repo, opts.get('base')))
+    if opts.get(b'base'):
+        baserevs = set(scmutil.revrange(repo, opts.get(b'base')))
         if not baserevs:
             baserevs = {nullrev}
         basectxs = {repo[rev] for rev in baserevs}
@@ -621,7 +624,7 b' def fixfile(ui, repo, opts, fixers, fixc'
             command = fixer.command(ui, path, ranges)
             if command is None:
                 continue
-            ui.debug('subprocess: %s\n' % (command,))
+            ui.debug(b'subprocess: %s\n' % (command,))
             proc = subprocess.Popen(
                 procutil.tonativestr(command),
                 shell=True,
@@ -636,11 +639,11 b' def fixfile(ui, repo, opts, fixers, fixc'
             newerdata = stdout
             if fixer.shouldoutputmetadata():
                 try:
-                    metadatajson, newerdata = stdout.split('\0', 1)
+                    metadatajson, newerdata = stdout.split(b'\0', 1)
                     metadata[fixername] = json.loads(metadatajson)
                 except ValueError:
                     ui.warn(
-                        _('ignored invalid output from fixer tool: %s\n')
+                        _(b'ignored invalid output from fixer tool: %s\n')
                         % (fixername,)
                     )
                     continue
@@ -650,14 +653,14 b' def fixfile(ui, repo, opts, fixers, fixc'
                 newdata = newerdata
             else:
                 if not stderr:
-                    message = _('exited with status %d\n') % (proc.returncode,)
+                    message = _(b'exited with status %d\n') % (proc.returncode,)
                     showstderr(ui, fixctx.rev(), fixername, message)
                 checktoolfailureaction(
                     ui,
-                    _('no fixes will be applied'),
+                    _(b'no fixes will be applied'),
                     hint=_(
-                        'use --config fix.failure=continue to apply any '
-                        'successful fixes anyway'
+                        b'use --config fix.failure=continue to apply any '
+                        b'successful fixes anyway'
                     ),
                 )
     return metadata, newdata
@@ -671,14 +674,14 b' def showstderr(ui, rev, fixername, stder'
     space and would tend to be included in the error message if they were
     relevant.
     """
-    for line in re.split('[\r\n]+', stderr):
+    for line in re.split(b'[\r\n]+', stderr):
         if line:
-            ui.warn('[')
+            ui.warn(b'[')
             if rev is None:
-                ui.warn(_('wdir'), label='evolve.rev')
+                ui.warn(_(b'wdir'), label=b'evolve.rev')
             else:
-                ui.warn((str(rev)), label='evolve.rev')
-            ui.warn('] %s: %s\n' % (fixername, line))
+                ui.warn((str(rev)), label=b'evolve.rev')
+            ui.warn(b'] %s: %s\n' % (fixername, line))
 
 
 def writeworkingdir(repo, ctx, filedata, replacements):
@@ -694,7 +697,7 b' def writeworkingdir(repo, ctx, filedata,'
     for path, data in filedata.iteritems():
         fctx = ctx[path]
         fctx.write(data, fctx.flags())
-        if repo.dirstate[path] == 'n':
+        if repo.dirstate[path] == b'n':
             repo.dirstate.normallookup(path)
 
     oldparentnodes = repo.dirstate.parents()
@@ -757,7 +760,7 b' def replacerev(ui, repo, ctx, filedata, '
         )
 
     extra = ctx.extra().copy()
-    extra['fix_source'] = ctx.hex()
+    extra[b'fix_source'] = ctx.hex()
 
     memctx = context.memctx(
         repo,
@@ -774,7 +777,7 b' def replacerev(ui, repo, ctx, filedata, '
     sucnode = memctx.commit()
     prenode = ctx.node()
     if prenode == sucnode:
-        ui.debug('node %s already existed\n' % (ctx.hex()))
+        ui.debug(b'node %s already existed\n' % (ctx.hex()))
     else:
         replacements[ctx.node()] = sucnode
 
@@ -788,11 +791,11 b' def getfixers(ui):'
     fixers = {}
     for name in fixernames(ui):
         fixers[name] = Fixer()
-        attrs = ui.configsuboptions('fix', name)[1]
+        attrs = ui.configsuboptions(b'fix', name)[1]
         for key, default in FIXER_ATTRS.items():
             setattr(
                 fixers[name],
-                pycompat.sysstr('_' + key),
+                pycompat.sysstr(b'_' + key),
                 attrs.get(key, default),
             )
         fixers[name]._priority = int(fixers[name]._priority)
@@ -805,11 +808,11 b' def getfixers(ui):'
         # default.
         if fixers[name]._pattern is None:
             ui.warn(
-                _('fixer tool has no pattern configuration: %s\n') % (name,)
+                _(b'fixer tool has no pattern configuration: %s\n') % (name,)
             )
             del fixers[name]
         elif not fixers[name]._enabled:
-            ui.debug('ignoring disabled fixer tool: %s\n' % (name,))
+            ui.debug(b'ignoring disabled fixer tool: %s\n' % (name,))
             del fixers[name]
     return collections.OrderedDict(
         sorted(fixers.items(), key=lambda item: item[1]._priority, reverse=True)
@@ -819,9 +822,9 b' def getfixers(ui):'
 def fixernames(ui):
     """Returns the names of [fix] config options that have suboptions"""
     names = set()
-    for k, v in ui.configitems('fix'):
-        if ':' in k:
-            names.add(k.split(':', 1)[0])
+    for k, v in ui.configitems(b'fix'):
+        if b':' in k:
+            names.add(k.split(b':', 1)[0])
     return names
 
 
@@ -849,7 +852,7 b' class Fixer(object):'
             expand(
                 ui,
                 self._command,
-                {'rootpath': path, 'basename': os.path.basename(path)},
+                {b'rootpath': path, b'basename': os.path.basename(path)},
             )
         ]
         if self._linerange:
@@ -858,6 +861,8 b' class Fixer(object):'
                 return None
             for first, last in ranges:
                 parts.append(
-                    expand(ui, self._linerange, {'first': first, 'last': last})
+                    expand(
+                        ui, self._linerange, {b'first': first, b'last': last}
+                    )
                 )
-        return ' '.join(parts)
+        return b' '.join(parts)

hgext/fsmonitor/__init__.py

@@ -143,60 +143,60 b' from . import ('
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
-testedwith = 'ships-with-hg-core'
+testedwith = b'ships-with-hg-core'
 
 configtable = {}
 configitem = registrar.configitem(configtable)
 
 configitem(
-    'fsmonitor', 'mode', default='on',
+    b'fsmonitor', b'mode', default=b'on',
 )
 configitem(
-    'fsmonitor', 'walk_on_invalidate', default=False,
+    b'fsmonitor', b'walk_on_invalidate', default=False,
 )
 configitem(
-    'fsmonitor', 'timeout', default='2',
+    b'fsmonitor', b'timeout', default=b'2',
 )
 configitem(
-    'fsmonitor', 'blacklistusers', default=list,
+    b'fsmonitor', b'blacklistusers', default=list,
 )
 configitem(
-    'fsmonitor', 'watchman_exe', default='watchman',
+    b'fsmonitor', b'watchman_exe', default=b'watchman',
 )
 configitem(
-    'fsmonitor', 'verbose', default=True, experimental=True,
+    b'fsmonitor', b'verbose', default=True, experimental=True,
 )
 configitem(
-    'experimental', 'fsmonitor.transaction_notify', default=False,
+    b'experimental', b'fsmonitor.transaction_notify', default=False,
 )
 
 # This extension is incompatible with the following blacklisted extensions
 # and will disable itself when encountering one of these:
-_blacklist = ['largefiles', 'eol']
+_blacklist = [b'largefiles', b'eol']
 
 
 def debuginstall(ui, fm):
     fm.write(
-        "fsmonitor-watchman",
-        _("fsmonitor checking for watchman binary... (%s)\n"),
-        ui.configpath("fsmonitor", "watchman_exe"),
+        b"fsmonitor-watchman",
+        _(b"fsmonitor checking for watchman binary... (%s)\n"),
+        ui.configpath(b"fsmonitor", b"watchman_exe"),
     )
     root = tempfile.mkdtemp()
     c = watchmanclient.client(ui, root)
     err = None
     try:
-        v = c.command("version")
+        v = c.command(b"version")
         fm.write(
-            "fsmonitor-watchman-version",
-            _(" watchman binary version %s\n"),
-            v["version"],
+            b"fsmonitor-watchman-version",
+            _(b" watchman binary version %s\n"),
+            v[b"version"],
         )
     except watchmanclient.Unavailable as e:
         err = str(e)
     fm.condwrite(
         err,
-        "fsmonitor-watchman-error",
-        _(" watchman binary missing or broken: %s\n"),
+        b"fsmonitor-watchman-error",
+        _(b" watchman binary missing or broken: %s\n"),
         err,
     )
     return 1 if err else 0
@@ -206,16 +206,16 b' def _handleunavailable(ui, state, ex):'
     """Exception handler for Watchman interaction exceptions"""
     if isinstance(ex, watchmanclient.Unavailable):
         # experimental config: fsmonitor.verbose
-        if ex.warn and ui.configbool('fsmonitor', 'verbose'):
-            if 'illegal_fstypes' not in str(ex):
-                ui.warn(str(ex) + '\n')
+        if ex.warn and ui.configbool(b'fsmonitor', b'verbose'):
+            if b'illegal_fstypes' not in str(ex):
+                ui.warn(str(ex) + b'\n')
         if ex.invalidate:
             state.invalidate()
         # experimental config: fsmonitor.verbose
-        if ui.configbool('fsmonitor', 'verbose'):
-            ui.log('fsmonitor', 'Watchman unavailable: %s\n', ex.msg)
+        if ui.configbool(b'fsmonitor', b'verbose'):
+            ui.log(b'fsmonitor', b'Watchman unavailable: %s\n', ex.msg)
     else:
-        ui.log('fsmonitor', 'Watchman exception: %s\n', ex)
+        ui.log(b'fsmonitor', b'Watchman exception: %s\n', ex)
 
 
 def _hashignore(ignore):
@@ -245,7 +245,7 b' def _watchmantofsencoding(path):'
     try:
         decoded = path.decode(_watchmanencoding)
     except UnicodeDecodeError as e:
-        raise error.Abort(str(e), hint='watchman encoding error')
+        raise error.Abort(str(e), hint=b'watchman encoding error')
 
     try:
         encoded = decoded.encode(_fsencoding, 'strict')
@@ -263,34 +263,34 b' def overridewalk(orig, self, match, subr'
     subset of files.'''
 
     def bail(reason):
-        self._ui.debug('fsmonitor: fallback to core status, %s\n' % reason)
+        self._ui.debug(b'fsmonitor: fallback to core status, %s\n' % reason)
         return orig(match, subrepos, unknown, ignored, full=True)
 
     if full:
-        return bail('full rewalk requested')
+        return bail(b'full rewalk requested')
     if ignored:
-        return bail('listing ignored files')
+        return bail(b'listing ignored files')
     if not self._watchmanclient.available():
-        return bail('client unavailable')
+        return bail(b'client unavailable')
     state = self._fsmonitorstate
     clock, ignorehash, notefiles = state.get()
     if not clock:
         if state.walk_on_invalidate:
-            return bail('no clock')
+            return bail(b'no clock')
         # Initial NULL clock value, see
         # https://facebook.github.io/watchman/docs/clockspec.html
-        clock = 'c:0:0'
+        clock = b'c:0:0'
         notefiles = []
 
     ignore = self._ignore
     dirignore = self._dirignore
     if unknown:
-        if _hashignore(ignore) != ignorehash and clock != 'c:0:0':
+        if _hashignore(ignore) != ignorehash and clock != b'c:0:0':
             # ignore list changed -- can't rely on Watchman state any more
             if state.walk_on_invalidate:
-                return bail('ignore rules changed')
+                return bail(b'ignore rules changed')
             notefiles = []
-            clock = 'c:0:0'
+            clock = b'c:0:0'
     else:
         # always ignore
         ignore = util.always
@@ -299,7 +299,7 b' def overridewalk(orig, self, match, subr'
     matchfn = match.matchfn
     matchalways = match.always()
     dmap = self._map
-    if util.safehasattr(dmap, '_map'):
+    if util.safehasattr(dmap, b'_map'):
         # for better performance, directly access the inner dirstate map if the
         # standard dirstate implementation is in use.
         dmap = dmap._map
@@ -339,7 +339,7 b' def overridewalk(orig, self, match, subr'
     if not work and (exact or skipstep3):
         for s in subrepos:
             del results[s]
-        del results['.hg']
+        del results[b'.hg']
         return results
 
     # step 2: query Watchman
@@ -349,30 +349,34 b' def overridewalk(orig, self, match, subr'
         # overheads while transferring the data
         self._watchmanclient.settimeout(state.timeout + 0.1)
         result = self._watchmanclient.command(
-            'query',
+            b'query',
             {
-                'fields': ['mode', 'mtime', 'size', 'exists', 'name'],
-                'since': clock,
-                'expression': [
-                    'not',
-                    ['anyof', ['dirname', '.hg'], ['name', '.hg', 'wholename']],
+                b'fields': [b'mode', b'mtime', b'size', b'exists', b'name'],
+                b'since': clock,
+                b'expression': [
+                    b'not',
+                    [
+                        b'anyof',
+                        [b'dirname', b'.hg'],
+                        [b'name', b'.hg', b'wholename'],
+                    ],
                 ],
-                'sync_timeout': int(state.timeout * 1000),
-                'empty_on_fresh_instance': state.walk_on_invalidate,
+                b'sync_timeout': int(state.timeout * 1000),
+                b'empty_on_fresh_instance': state.walk_on_invalidate,
             },
         )
     except Exception as ex:
         _handleunavailable(self._ui, state, ex)
         self._watchmanclient.clearconnection()
-        return bail('exception during run')
+        return bail(b'exception during run')
     else:
         # We need to propagate the last observed clock up so that we
         # can use it for our next query
-        state.setlastclock(result['clock'])
-        if result['is_fresh_instance']:
+        state.setlastclock(result[b'clock'])
+        if result[b'is_fresh_instance']:
             if state.walk_on_invalidate:
                 state.invalidate()
-                return bail('fresh instance')
+                return bail(b'fresh instance')
             fresh_instance = True
             # Ignore any prior noteable files from the state info
             notefiles = []
@@ -382,7 +386,7 b' def overridewalk(orig, self, match, subr'
     if normalize:
         foldmap = dict((normcase(k), k) for k in results)
 
-    switch_slashes = pycompat.ossep == '\\'
+    switch_slashes = pycompat.ossep == b'\\'
     # The order of the results is, strictly speaking, undefined.
     # For case changes on a case insensitive filesystem we may receive
     # two entries, one with exists=True and another with exists=False.
@@ -390,22 +394,22 b' def overridewalk(orig, self, match, subr'
     # as being happens-after the exists=False entries due to the way that
     # Watchman tracks files.  We use this property to reconcile deletes
     # for name case changes.
-    for entry in result['files']:
-        fname = entry['name']
+    for entry in result[b'files']:
+        fname = entry[b'name']
         if _fixencoding:
             fname = _watchmantofsencoding(fname)
         if switch_slashes:
-            fname = fname.replace('\\', '/')
+            fname = fname.replace(b'\\', b'/')
         if normalize:
             normed = normcase(fname)
             fname = normalize(fname, True, True)
             foldmap[normed] = fname
-        fmode = entry['mode']
-        fexists = entry['exists']
+        fmode = entry[b'mode']
+        fexists = entry[b'exists']
         kind = getkind(fmode)
 
-        if '/.hg/' in fname or fname.endswith('/.hg'):
-            return bail('nested-repo-detected')
+        if b'/.hg/' in fname or fname.endswith(b'/.hg'):
+            return bail(b'nested-repo-detected')
 
         if not fexists:
             # if marked as deleted and we don't already have a change
@@ -488,14 +492,14 b' def overridewalk(orig, self, match, subr'
 
     for s in subrepos:
         del results[s]
-    del results['.hg']
+    del results[b'.hg']
     return results
 
 
 def overridestatus(
     orig,
     self,
-    node1='.',
+    node1=b'.',
     node2=None,
     match=None,
     ignored=False,
@@ -509,22 +513,22 b' def overridestatus('
 
     def _cmpsets(l1, l2):
         try:
-            if 'FSMONITOR_LOG_FILE' in encoding.environ:
-                fn = encoding.environ['FSMONITOR_LOG_FILE']
-                f = open(fn, 'wb')
+            if b'FSMONITOR_LOG_FILE' in encoding.environ:
+                fn = encoding.environ[b'FSMONITOR_LOG_FILE']
+                f = open(fn, b'wb')
             else:
-                fn = 'fsmonitorfail.log'
-                f = self.vfs.open(fn, 'wb')
+                fn = b'fsmonitorfail.log'
+                f = self.vfs.open(fn, b'wb')
         except (IOError, OSError):
-            self.ui.warn(_('warning: unable to write to %s\n') % fn)
+            self.ui.warn(_(b'warning: unable to write to %s\n') % fn)
             return
 
         try:
             for i, (s1, s2) in enumerate(zip(l1, l2)):
                 if set(s1) != set(s2):
-                    f.write('sets at position %d are unequal\n' % i)
-                    f.write('watchman returned: %s\n' % s1)
-                    f.write('stat returned: %s\n' % s2)
+                    f.write(b'sets at position %d are unequal\n' % i)
+                    f.write(b'watchman returned: %s\n' % s1)
+                    f.write(b'stat returned: %s\n' % s2)
         finally:
             f.close()
 
@@ -538,7 +542,7 b' def overridestatus('
         ctx2 = self[node2]
 
     working = ctx2.rev() is None
-    parentworking = working and ctx1 == self['.']
+    parentworking = working and ctx1 == self[b'.']
     match = match or matchmod.always()
 
     # Maybe we can use this opportunity to update Watchman's state.
@@ -552,7 +556,7 b' def overridestatus('
         parentworking
         and match.always()
         and not isinstance(ctx2, (context.workingcommitctx, context.memctx))
-        and 'HG_PENDING' not in encoding.environ
+        and b'HG_PENDING' not in encoding.environ
     )
 
     try:
@@ -607,7 +611,7 b' def overridestatus('
 
     # don't do paranoid checks if we're not going to query Watchman anyway
     full = listclean or match.traversedir is not None
-    if self._fsmonitorstate.mode == 'paranoid' and not full:
+    if self._fsmonitorstate.mode == b'paranoid' and not full:
         # run status again and fall back to the old walk this time
         self.dirstate._fsmonitordisable = True
 
@@ -615,7 +619,7 b' def overridestatus('
         quiet = self.ui.quiet
         self.ui.quiet = True
         fout, ferr = self.ui.fout, self.ui.ferr
-        self.ui.fout = self.ui.ferr = open(os.devnull, 'wb')
+        self.ui.fout = self.ui.ferr = open(os.devnull, b'wb')
 
         try:
             rv2 = orig(
@@ -692,20 +696,20 b' def makedirstate(repo, dirstate):'
 def wrapdirstate(orig, self):
     ds = orig(self)
     # only override the dirstate when Watchman is available for the repo
-    if util.safehasattr(self, '_fsmonitorstate'):
+    if util.safehasattr(self, b'_fsmonitorstate'):
         makedirstate(self, ds)
     return ds
 
 
 def extsetup(ui):
     extensions.wrapfilecache(
-        localrepo.localrepository, 'dirstate', wrapdirstate
+        localrepo.localrepository, b'dirstate', wrapdirstate
     )
     if pycompat.isdarwin:
         # An assist for avoiding the dangling-symlink fsevents bug
-        extensions.wrapfunction(os, 'symlink', wrapsymlink)
+        extensions.wrapfunction(os, b'symlink', wrapsymlink)
 
-    extensions.wrapfunction(merge, 'update', wrapupdate)
+    extensions.wrapfunction(merge, b'update', wrapupdate)
 
 
 def wrapsymlink(orig, source, link_name):
@@ -756,14 +760,14 b' class state_update(object):'
         # merge.update is going to take the wlock almost immediately. We are
         # effectively extending the lock around several short sanity checks.
         if self.oldnode is None:
-            self.oldnode = self.repo['.'].node()
+            self.oldnode = self.repo[b'.'].node()
 
         if self.repo.currentwlock() is None:
-            if util.safehasattr(self.repo, 'wlocknostateupdate'):
+            if util.safehasattr(self.repo, b'wlocknostateupdate'):
                 self._lock = self.repo.wlocknostateupdate()
             else:
                 self._lock = self.repo.wlock()
-        self.need_leave = self._state('state-enter', hex(self.oldnode))
+        self.need_leave = self._state(b'state-enter', hex(self.oldnode))
         return self
 
     def __exit__(self, type_, value, tb):
@@ -773,36 +777,36 b' class state_update(object):'
     def exit(self, abort=False):
         try:
             if self.need_leave:
-                status = 'failed' if abort else 'ok'
+                status = b'failed' if abort else b'ok'
                 if self.newnode is None:
-                    self.newnode = self.repo['.'].node()
+                    self.newnode = self.repo[b'.'].node()
                 if self.distance is None:
                     self.distance = calcdistance(
                         self.repo, self.oldnode, self.newnode
                     )
-                self._state('state-leave', hex(self.newnode), status=status)
+                self._state(b'state-leave', hex(self.newnode), status=status)
         finally:
             self.need_leave = False
             if self._lock:
                 self._lock.release()
 
-    def _state(self, cmd, commithash, status='ok'):
-        if not util.safehasattr(self.repo, '_watchmanclient'):
+    def _state(self, cmd, commithash, status=b'ok'):
+        if not util.safehasattr(self.repo, b'_watchmanclient'):
             return False
         try:
             self.repo._watchmanclient.command(
                 cmd,
                 {
-                    'name': self.name,
-                    'metadata': {
+                    b'name': self.name,
+                    b'metadata': {
                         # the target revision
-                        'rev': commithash,
+                        b'rev': commithash,
                         # approximate number of commits between current and target
-                        'distance': self.distance if self.distance else 0,
+                        b'distance': self.distance if self.distance else 0,
                         # success/failure (only really meaningful for state-leave)
-                        'status': status,
+                        b'status': status,
                         # whether the working copy parent is changing
-                        'partial': self.partial,
+                        b'partial': self.partial,
                     },
                 },
             )
@@ -810,7 +814,7 b' class state_update(object):'
         except Exception as e:
             # Swallow any errors; fire and forget
             self.repo.ui.log(
-                'watchman', 'Exception %s while running %s\n', e, cmd
+                b'watchman', b'Exception %s while running %s\n', e, cmd
             )
             return False
 
@@ -844,7 +848,7 b' def wrapupdate('
 
     distance = 0
     partial = True
-    oldnode = repo['.'].node()
+    oldnode = repo[b'.'].node()
     newnode = repo[node].node()
     if matcher is None or matcher.always():
         partial = False
@@ -852,7 +856,7 b' def wrapupdate('
 
     with state_update(
         repo,
-        name="hg.update",
+        name=b"hg.update",
         oldnode=oldnode,
         newnode=newnode,
         distance=distance,
@@ -873,8 +877,8 b' def wrapupdate('
 
 def repo_has_depth_one_nested_repo(repo):
     for f in repo.wvfs.listdir():
-        if os.path.isdir(os.path.join(repo.root, f, '.hg')):
-            msg = 'fsmonitor: sub-repository %r detected, fsmonitor disabled\n'
+        if os.path.isdir(os.path.join(repo.root, f, b'.hg')):
+            msg = b'fsmonitor: sub-repository %r detected, fsmonitor disabled\n'
             repo.ui.debug(msg % f)
             return True
     return False
@@ -887,8 +891,8 b' def reposetup(ui, repo):'
         if ext in exts:
             ui.warn(
                 _(
-                    'The fsmonitor extension is incompatible with the %s '
-                    'extension and has been disabled.\n'
+                    b'The fsmonitor extension is incompatible with the %s '
+                    b'extension and has been disabled.\n'
                 )
                 % ext
             )
@@ -899,14 +903,14 b' def reposetup(ui, repo):'
         #
         # if repo[None].substate can cause a dirstate parse, which is too
         # slow. Instead, look for a file called hgsubstate,
-        if repo.wvfs.exists('.hgsubstate') or repo.wvfs.exists('.hgsub'):
+        if repo.wvfs.exists(b'.hgsubstate') or repo.wvfs.exists(b'.hgsub'):
             return
 
         if repo_has_depth_one_nested_repo(repo):
             return
 
         fsmonitorstate = state.state(repo)
-        if fsmonitorstate.mode == 'off':
+        if fsmonitorstate.mode == b'off':
             return
 
         try:
@@ -918,7 +922,7 b' def reposetup(ui, repo):'
         repo._fsmonitorstate = fsmonitorstate
         repo._watchmanclient = client
 
-        dirstate, cached = localrepo.isfilecached(repo, 'dirstate')
+        dirstate, cached = localrepo.isfilecached(repo, b'dirstate')
         if cached:
             # at this point since fsmonitorstate wasn't present,
             # repo.dirstate is not a fsmonitordirstate
@@ -935,7 +939,7 b' def reposetup(ui, repo):'
             def wlock(self, *args, **kwargs):
                 l = super(fsmonitorrepo, self).wlock(*args, **kwargs)
                 if not ui.configbool(
-                    "experimental", "fsmonitor.transaction_notify"
+                    b"experimental", b"fsmonitor.transaction_notify"
                 ):
                     return l
                 if l.held != 1:
@@ -951,12 +955,14 b' def reposetup(ui, repo):'
 
                 try:
                     l.stateupdate = None
-                    l.stateupdate = state_update(self, name="hg.transaction")
+                    l.stateupdate = state_update(self, name=b"hg.transaction")
                     l.stateupdate.enter()
                     l.releasefn = staterelease
                 except Exception as e:
                     # Swallow any errors; fire and forget
-                    self.ui.log('watchman', 'Exception in state update %s\n', e)
+                    self.ui.log(
+                        b'watchman', b'Exception in state update %s\n', e
+                    )
                 return l
 
         repo.__class__ = fsmonitorrepo

hgext/fsmonitor/state.py

@@ -19,7 +19,7 b' from mercurial import ('
 )
 
 _version = 4
-_versionformat = ">I"
+_versionformat = b">I"
 
 
 class state(object):
@@ -30,15 +30,15 b' class state(object):'
         self._lastclock = None
         self._identity = util.filestat(None)
 
-        self.mode = self._ui.config('fsmonitor', 'mode')
+        self.mode = self._ui.config(b'fsmonitor', b'mode')
         self.walk_on_invalidate = self._ui.configbool(
-            'fsmonitor', 'walk_on_invalidate'
+            b'fsmonitor', b'walk_on_invalidate'
         )
-        self.timeout = float(self._ui.config('fsmonitor', 'timeout'))
+        self.timeout = float(self._ui.config(b'fsmonitor', b'timeout'))
 
     def get(self):
         try:
-            file = self._vfs('fsmonitor.state', 'rb')
+            file = self._vfs(b'fsmonitor.state', b'rb')
         except IOError as inst:
             self._identity = util.filestat(None)
             if inst.errno != errno.ENOENT:
@@ -50,9 +50,9 b' class state(object):'
         versionbytes = file.read(4)
         if len(versionbytes) < 4:
             self._ui.log(
-                'fsmonitor',
-                'fsmonitor: state file only has %d bytes, '
-                'nuking state\n' % len(versionbytes),
+                b'fsmonitor',
+                b'fsmonitor: state file only has %d bytes, '
+                b'nuking state\n' % len(versionbytes),
             )
             self.invalidate()
             return None, None, None
@@ -61,21 +61,21 b' class state(object):'
             if diskversion != _version:
                 # different version, nuke state and start over
                 self._ui.log(
-                    'fsmonitor',
-                    'fsmonitor: version switch from %d to '
-                    '%d, nuking state\n' % (diskversion, _version),
+                    b'fsmonitor',
+                    b'fsmonitor: version switch from %d to '
+                    b'%d, nuking state\n' % (diskversion, _version),
                 )
                 self.invalidate()
                 return None, None, None
 
-            state = file.read().split('\0')
+            state = file.read().split(b'\0')
             # state = hostname\0clock\0ignorehash\0 + list of files, each
             # followed by a \0
             if len(state) < 3:
                 self._ui.log(
-                    'fsmonitor',
-                    'fsmonitor: state file truncated (expected '
-                    '3 chunks, found %d), nuking state\n',
+                    b'fsmonitor',
+                    b'fsmonitor: state file truncated (expected '
+                    b'3 chunks, found %d), nuking state\n',
                     len(state),
                 )
                 self.invalidate()
@@ -85,9 +85,9 b' class state(object):'
             if diskhostname != hostname:
                 # file got moved to a different host
                 self._ui.log(
-                    'fsmonitor',
-                    'fsmonitor: stored hostname "%s" '
-                    'different from current "%s", nuking state\n'
+                    b'fsmonitor',
+                    b'fsmonitor: stored hostname "%s" '
+                    b'different from current "%s", nuking state\n'
                     % (diskhostname, hostname),
                 )
                 self.invalidate()
@@ -110,31 +110,33 b' class state(object):'
 
         # Read the identity from the file on disk rather than from the open file
         # pointer below, because the latter is actually a brand new file.
-        identity = util.filestat.frompath(self._vfs.join('fsmonitor.state'))
+        identity = util.filestat.frompath(self._vfs.join(b'fsmonitor.state'))
         if identity != self._identity:
-            self._ui.debug('skip updating fsmonitor.state: identity mismatch\n')
+            self._ui.debug(
+                b'skip updating fsmonitor.state: identity mismatch\n'
+            )
             return
 
         try:
             file = self._vfs(
-                'fsmonitor.state', 'wb', atomictemp=True, checkambig=True
+                b'fsmonitor.state', b'wb', atomictemp=True, checkambig=True
             )
         except (IOError, OSError):
-            self._ui.warn(_("warning: unable to write out fsmonitor state\n"))
+            self._ui.warn(_(b"warning: unable to write out fsmonitor state\n"))
             return
 
         with file:
             file.write(struct.pack(_versionformat, _version))
-            file.write(socket.gethostname() + '\0')
-            file.write(clock + '\0')
-            file.write(ignorehash + '\0')
+            file.write(socket.gethostname() + b'\0')
+            file.write(clock + b'\0')
+            file.write(ignorehash + b'\0')
             if notefiles:
-                file.write('\0'.join(notefiles))
-                file.write('\0')
+                file.write(b'\0'.join(notefiles))
+                file.write(b'\0')
 
     def invalidate(self):
         try:
-            os.unlink(os.path.join(self._rootdir, '.hg', 'fsmonitor.state'))
+            os.unlink(os.path.join(self._rootdir, b'.hg', b'fsmonitor.state'))
         except OSError as inst:
             if inst.errno != errno.ENOENT:
                 raise

hgext/fsmonitor/watchmanclient.py

@@ -18,15 +18,15 b' class Unavailable(Exception):'
     def __init__(self, msg, warn=True, invalidate=False):
         self.msg = msg
         self.warn = warn
-        if self.msg == 'timed out waiting for response':
+        if self.msg == b'timed out waiting for response':
             self.warn = False
         self.invalidate = invalidate
 
     def __str__(self):
         if self.warn:
-            return 'warning: Watchman unavailable: %s' % self.msg
+            return b'warning: Watchman unavailable: %s' % self.msg
         else:
-            return 'Watchman unavailable: %s' % self.msg
+            return b'Watchman unavailable: %s' % self.msg
 
 
 class WatchmanNoRoot(Unavailable):
@@ -39,10 +39,10 b' class client(object):'
     def __init__(self, ui, root, timeout=1.0):
         err = None
         if not self._user:
-            err = "couldn't get user"
+            err = b"couldn't get user"
             warn = True
-        if self._user in ui.configlist('fsmonitor', 'blacklistusers'):
-            err = 'user %s in blacklist' % self._user
+        if self._user in ui.configlist(b'fsmonitor', b'blacklistusers'):
+            err = b'user %s in blacklist' % self._user
             warn = False
 
         if err:
@@ -60,10 +60,10 b' class client(object):'
             self._watchmanclient.setTimeout(timeout)
 
     def getcurrentclock(self):
-        result = self.command('clock')
-        if not util.safehasattr(result, 'clock'):
+        result = self.command(b'clock')
+        if not util.safehasattr(result, b'clock'):
             raise Unavailable(
-                'clock result is missing clock value', invalidate=True
+                b'clock result is missing clock value', invalidate=True
             )
         return result.clock
 
@@ -86,7 +86,9 b' class client(object):'
         try:
             if self._watchmanclient is None:
                 self._firsttime = False
-                watchman_exe = self._ui.configpath('fsmonitor', 'watchman_exe')
+                watchman_exe = self._ui.configpath(
+                    b'fsmonitor', b'watchman_exe'
+                )
                 self._watchmanclient = pywatchman.client(
                     timeout=self._timeout,
                     useImmutableBser=True,
@@ -94,7 +96,7 b' class client(object):'
                 )
             return self._watchmanclient.query(*watchmanargs)
         except pywatchman.CommandError as ex:
-            if 'unable to resolve root' in ex.msg:
+            if b'unable to resolve root' in ex.msg:
                 raise WatchmanNoRoot(self._root, ex.msg)
             raise Unavailable(ex.msg)
         except pywatchman.WatchmanError as ex:
@@ -107,7 +109,7 b' class client(object):'
             except WatchmanNoRoot:
                 # this 'watch' command can also raise a WatchmanNoRoot if
                 # watchman refuses to accept this root
-                self._command('watch')
+                self._command(b'watch')
                 return self._command(*args)
         except Unavailable:
             # this is in an outer scope to catch Unavailable form any of the