[PATCH evolve-ext v2] py3: broad pass for python3 compatibility

Ludovic Chabant ludovic at chabant.com
Mon Jul 1 01:39:01 EDT 2019


# HG changeset patch
# User Ludovic Chabant <ludovic at chabant.com>
# Date 1561959530 0
#      Mon Jul 01 05:38:50 2019 +0000
# Branch stable
# Node ID 89e3ab4dcbc56ee72ce1d4d17527337e01d99467
# Parent  90daf413dfc7a7e4762e6445f05c52b123c6188f
py3: broad pass for python3 compatibility

- ran mercurial's bytify-strings script
- excluded some places where we use strings to pass to setattr()
- re-decode some template funcions' docstrings that were previously encoded
  (probably by the hgloader?)

diff --git a/hgext3rd/evolve/__init__.py b/hgext3rd/evolve/__init__.py
--- a/hgext3rd/evolve/__init__.py
+++ b/hgext3rd/evolve/__init__.py
@@ -258,7 +258,7 @@
     registrar.templatekeyword # new in hg-3.8
 except ImportError:
     from . import metadata
-    raise ImportError('evolve needs Mercurial version %s or above' %
+    raise ImportError(b'evolve needs Mercurial version %s or above' %
                       min(metadata.testedwith.split()))
 
 import mercurial
@@ -311,25 +311,25 @@
 buglink = metadata.buglink
 
 # Flags for enabling optional parts of evolve
-commandopt = 'allnewcommands'
+commandopt = b'allnewcommands'
 
 obsexcmsg = utility.obsexcmsg
 shorttemplate = utility.shorttemplate
 
-colortable = {'evolve.node': 'yellow',
-              'evolve.user': 'green',
-              'evolve.rev': 'blue',
-              'evolve.short_description': '',
-              'evolve.date': 'cyan',
-              'evolve.current_rev': 'bold',
-              'evolve.verb': '',
-              'evolve.operation': 'bold'
+colortable = {b'evolve.node': b'yellow',
+              b'evolve.user': b'green',
+              b'evolve.rev': b'blue',
+              b'evolve.short_description': b'',
+              b'evolve.date': b'cyan',
+              b'evolve.current_rev': b'bold',
+              b'evolve.verb': b'',
+              b'evolve.operation': b'bold'
               }
 
 _pack = struct.pack
 _unpack = struct.unpack
 
-aliases, entry = cmdutil.findcmd('commit', commands.table)
+aliases, entry = cmdutil.findcmd(b'commit', commands.table)
 commitopts3 = cmdrewrite.commitopts3
 interactiveopt = cmdrewrite.interactiveopt
 rewrite = rewriteutil.rewrite
@@ -362,13 +362,13 @@
 templatekeyword = eh.templatekeyword
 
 # Configuration
-eh.configitem('experimental', 'evolutioncommands', [])
-eh.configitem('experimental', 'evolution.allnewcommands', None)
-eh.configitem('experimental', 'prunestrip', False)
+eh.configitem(b'experimental', b'evolutioncommands', [])
+eh.configitem(b'experimental', b'evolution.allnewcommands', None)
+eh.configitem(b'experimental', b'prunestrip', False)
 
 # pre hg 4.0 compat
 
-if not util.safehasattr(dirstate.dirstate, 'parentchange'):
+if not util.safehasattr(dirstate.dirstate, b'parentchange'):
     import contextlib
 
     @contextlib.contextmanager
@@ -397,14 +397,14 @@
 def _configureoptions(ui, repo):
     # If no capabilities are specified, enable everything.
     # This is so existing evolve users don't need to change their config.
-    evolveopts = repo.ui.configlist('experimental', 'evolution')
+    evolveopts = repo.ui.configlist(b'experimental', b'evolution')
     if not evolveopts:
-        evolveopts = ['all']
-        repo.ui.setconfig('experimental', 'evolution', evolveopts, 'evolve')
-    if obsolete.isenabled(repo, 'exchange'):
+        evolveopts = [b'all']
+        repo.ui.setconfig(b'experimental', b'evolution', evolveopts, b'evolve')
+    if obsolete.isenabled(repo, b'exchange'):
         # if no config explicitly set, disable bundle1
-        if not isinstance(repo.ui.config('server', 'bundle1'), str):
-            repo.ui.setconfig('server', 'bundle1', False)
+        if not isinstance(repo.ui.config(b'server', b'bundle1'), str):
+            repo.ui.setconfig(b'server', b'bundle1', False)
 
     class trdescrepo(repo.__class__):
 
@@ -422,18 +422,18 @@
     # This must be in the same function as the option configuration above to
     # guarantee it happens after the above configuration, but before the
     # extsetup functions.
-    evolvecommands = ui.configlist('experimental', 'evolutioncommands')
-    evolveopts = ui.configlist('experimental', 'evolution')
+    evolvecommands = ui.configlist(b'experimental', b'evolutioncommands')
+    evolveopts = ui.configlist(b'experimental', b'evolution')
     if evolveopts and (commandopt not in evolveopts
-                       and 'all' not in evolveopts):
+                       and b'all' not in evolveopts):
         # We build whitelist containing the commands we want to enable
         whitelist = set()
         for cmd in evolvecommands:
             matchingevolvecommands = [e for e in cmdtable.keys() if cmd in e]
             if not matchingevolvecommands:
-                raise error.Abort(_('unknown command: %s') % cmd)
+                raise error.Abort(_(b'unknown command: %s') % cmd)
             elif len(matchingevolvecommands) > 1:
-                msg = _('ambiguous command specification: "%s" matches %r')
+                msg = _(b'ambiguous command specification: "%s" matches %r')
                 raise error.Abort(msg % (cmd, matchingevolvecommands))
             else:
                 whitelist.add(matchingevolvecommands[0])
@@ -464,10 +464,10 @@
 @eh.uisetup
 def setupparentcommand(ui):
 
-    _alias, statuscmd = cmdutil.findcmd('status', commands.table)
-    pstatusopts = [o for o in statuscmd[1] if o[1] != 'rev']
+    _alias, statuscmd = cmdutil.findcmd(b'status', commands.table)
+    pstatusopts = [o for o in statuscmd[1] if o[1] != b'rev']
 
-    @eh.command('pstatus', pstatusopts)
+    @eh.command(b'pstatus', pstatusopts)
     def pstatus(ui, repo, *args, **kwargs):
         """show status combining committed and uncommited changes
 
@@ -476,13 +476,13 @@
         match the content of the commit that a bare :hg:`amend` will creates.
 
         See :hg:`help status` for details."""
-        kwargs['rev'] = ['.^']
+        kwargs[b'rev'] = [b'.^']
         return statuscmd[0](ui, repo, *args, **kwargs)
 
-    _alias, diffcmd = cmdutil.findcmd('diff', commands.table)
-    pdiffopts = [o for o in diffcmd[1] if o[1] != 'rev']
+    _alias, diffcmd = cmdutil.findcmd(b'diff', commands.table)
+    pdiffopts = [o for o in diffcmd[1] if o[1] != b'rev']
 
-    @eh.command('pdiff', pdiffopts)
+    @eh.command(b'pdiff', pdiffopts)
     def pdiff(ui, repo, *args, **kwargs):
         """show diff combining committed and uncommited changes
 
@@ -491,32 +491,32 @@
         match the content of the commit that a bare :hg:`amend` will creates.
 
         See :hg:`help diff` for details."""
-        kwargs['rev'] = ['.^']
+        kwargs[b'rev'] = [b'.^']
         return diffcmd[0](ui, repo, *args, **kwargs)
 
 @eh.uisetup
 def _installalias(ui):
-    if ui.config('alias', 'odiff', None) is None:
-        ui.setconfig('alias', 'odiff',
-                     "diff --hidden --rev 'limit(predecessors(.),1)' --rev .",
-                     'evolve')
+    if ui.config(b'alias', b'odiff', None) is None:
+        ui.setconfig(b'alias', b'odiff',
+                     b"diff --hidden --rev 'limit(predecessors(.),1)' --rev .",
+                     b'evolve')
 
 ### Unstable revset symbol
 
- at eh.revsetpredicate('unstable()')
+ at eh.revsetpredicate(b'unstable()')
 def revsetunstable(repo, subset, x):
     """Changesets with instabilities.
     """
-    revset.getargs(x, 0, 0, 'unstable takes no arguments')
+    revset.getargs(x, 0, 0, b'unstable takes no arguments')
     troubled = set()
-    troubled.update(getrevs(repo, 'orphan'))
-    troubled.update(getrevs(repo, 'phasedivergent'))
-    troubled.update(getrevs(repo, 'contentdivergent'))
+    troubled.update(getrevs(repo, b'orphan'))
+    troubled.update(getrevs(repo, b'phasedivergent'))
+    troubled.update(getrevs(repo, b'contentdivergent'))
     troubled = revset.baseset(troubled)
     troubled.sort() # set is non-ordered, enforce order
     return subset & troubled
 
- at eh.revsetpredicate('troubled()')    # legacy name
+ at eh.revsetpredicate(b'troubled()')    # legacy name
 def revsettroubled(repo, subset, x):
     return revsetunstable(repo, subset, x)
 
@@ -615,17 +615,17 @@
 
 
 ### XXX I'm not sure this revset is useful
- at eh.revsetpredicate('suspended()')
+ at eh.revsetpredicate(b'suspended()')
 def revsetsuspended(repo, subset, x):
     """Obsolete changesets with non-obsolete descendants.
     """
-    revset.getargs(x, 0, 0, 'suspended takes no arguments')
-    suspended = revset.baseset(getrevs(repo, 'suspended'))
+    revset.getargs(x, 0, 0, b'suspended takes no arguments')
+    suspended = revset.baseset(getrevs(repo, b'suspended'))
     suspended.sort()
     return subset & suspended
 
 
- at eh.revsetpredicate('predecessors(set)')
+ at eh.revsetpredicate(b'predecessors(set)')
 def revsetpredecessors(repo, subset, x):
     """Immediate predecessors of changesets in set.
     """
@@ -635,12 +635,12 @@
     return subset & s
 
 
- at eh.revsetpredicate('precursors(set)')   # legacy name for predecessors
+ at eh.revsetpredicate(b'precursors(set)')   # legacy name for predecessors
 def revsetprecursors(repo, subset, x):
     return revsetpredecessors(repo, subset, x)
 
 
- at eh.revsetpredicate('allpredecessors(set)')
+ at eh.revsetpredicate(b'allpredecessors(set)')
 def revsetallpredecessors(repo, subset, x):
     """Transitive predecessors of changesets in set.
     """
@@ -650,12 +650,12 @@
     return subset & s
 
 
- at eh.revsetpredicate('allprecursors(set)')   # legacy name for allpredecessors
+ at eh.revsetpredicate(b'allprecursors(set)')   # legacy name for allpredecessors
 def revsetallprecursors(repo, subset, x):
     return revsetallpredecessors(repo, subset, x)
 
 
- at eh.revsetpredicate('successors(set)')
+ at eh.revsetpredicate(b'successors(set)')
 def revsetsuccessors(repo, subset, x):
     """Immediate successors of changesets in set.
     """
@@ -664,7 +664,7 @@
     s.sort()
     return subset & s
 
- at eh.revsetpredicate('allsuccessors(set)')
+ at eh.revsetpredicate(b'allsuccessors(set)')
 def revsetallsuccessors(repo, subset, x):
     """Transitive successors of changesets in set.
     """
@@ -681,87 +681,87 @@
 # This section take care of issue warning to the user when troubles appear
 
 def _warnobsoletewc(ui, repo, prevnode=None, wasobs=None):
-    rev = repo['.']
+    rev = repo[b'.']
 
     if not rev.obsolete():
         return
 
     if rev.node() == prevnode and wasobs:
         return
-    msg = _("working directory parent is obsolete! (%s)\n")
+    msg = _(b"working directory parent is obsolete! (%s)\n")
     shortnode = node.short(rev.node())
 
     ui.warn(msg % shortnode)
 
     # Check that evolve is activated for performance reasons
-    evolvecommandenabled = any('evolve' in e for e in cmdtable)
+    evolvecommandenabled = any(b'evolve' in e for e in cmdtable)
     if ui.quiet or not evolvecommandenabled:
         return
 
     # Show a warning for helping the user to solve the issue
     reason, successors = obshistory._getobsfateandsuccs(repo, rev.node())
 
-    if reason == 'pruned':
-        solvemsg = _("use 'hg evolve' to update to its parent successor")
-    elif reason == 'diverged':
-        debugcommand = "hg evolve --list --content-divergent"
-        basemsg = _("%s has diverged, use '%s' to resolve the issue")
+    if reason == b'pruned':
+        solvemsg = _(b"use 'hg evolve' to update to its parent successor")
+    elif reason == b'diverged':
+        debugcommand = b"hg evolve --list --content-divergent"
+        basemsg = _(b"%s has diverged, use '%s' to resolve the issue")
         solvemsg = basemsg % (shortnode, debugcommand)
-    elif reason == 'superseed':
-        msg = _("use 'hg evolve' to update to its successor: %s")
+    elif reason == b'superseed':
+        msg = _(b"use 'hg evolve' to update to its successor: %s")
         solvemsg = msg % successors[0]
-    elif reason == 'superseed_split':
-        msg = _("use 'hg evolve' to update to its tipmost successor: %s")
+    elif reason == b'superseed_split':
+        msg = _(b"use 'hg evolve' to update to its tipmost successor: %s")
 
         if len(successors) <= 2:
-            solvemsg = msg % ", ".join(successors)
+            solvemsg = msg % b", ".join(successors)
         else:
-            firstsuccessors = ", ".join(successors[:2])
+            firstsuccessors = b", ".join(successors[:2])
             remainingnumber = len(successors) - 2
-            successorsmsg = _("%s and %d more") % (firstsuccessors, remainingnumber)
+            successorsmsg = _(b"%s and %d more") % (firstsuccessors, remainingnumber)
             solvemsg = msg % successorsmsg
     else:
         raise ValueError(reason)
 
-    ui.warn("(%s)\n" % solvemsg)
+    ui.warn(b"(%s)\n" % solvemsg)
 
-if util.safehasattr(context, '_filterederror'): # <= hg-4.5
-    @eh.wrapfunction(context, '_filterederror')
+if util.safehasattr(context, b'_filterederror'): # <= hg-4.5
+    @eh.wrapfunction(context, b'_filterederror')
     def evolve_filtererror(original, repo, changeid):
         """build an exception to be raised about a filtered changeid
 
         This is extracted in a function to help extensions (eg: evolve) to
         experiment with various message variants."""
-        if repo.filtername.startswith('visible'):
+        if repo.filtername.startswith(b'visible'):
 
             unfilteredrepo = repo.unfiltered()
             rev = repo[scmutil.revsingle(unfilteredrepo, changeid)]
             reason, successors = obshistory._getobsfateandsuccs(unfilteredrepo, rev.node())
 
             # Be more precise in case the revision is superseed
-            if reason == 'superseed':
-                reason = _("successor: %s") % successors[0]
-            elif reason == 'superseed_split':
+            if reason == b'superseed':
+                reason = _(b"successor: %s") % successors[0]
+            elif reason == b'superseed_split':
                 if len(successors) <= 2:
-                    reason = _("successors: %s") % ", ".join(successors)
+                    reason = _(b"successors: %s") % b", ".join(successors)
                 else:
-                    firstsuccessors = ", ".join(successors[:2])
+                    firstsuccessors = b", ".join(successors[:2])
                     remainingnumber = len(successors) - 2
-                    successorsmsg = _("%s and %d more") % (firstsuccessors, remainingnumber)
-                    reason = _("successors: %s") % successorsmsg
+                    successorsmsg = _(b"%s and %d more") % (firstsuccessors, remainingnumber)
+                    reason = _(b"successors: %s") % successorsmsg
 
-            msg = _("hidden revision '%s'") % changeid
-            hint = _('use --hidden to access hidden revisions; %s') % reason
+            msg = _(b"hidden revision '%s'") % changeid
+            hint = _(b'use --hidden to access hidden revisions; %s') % reason
             return error.FilteredRepoLookupError(msg, hint=hint)
-        msg = _("filtered revision '%s' (not in '%s' subset)")
+        msg = _(b"filtered revision '%s' (not in '%s' subset)")
         msg %= (changeid, repo.filtername)
         return error.FilteredRepoLookupError(msg)
 
- at eh.wrapcommand("update")
- at eh.wrapcommand("pull")
+ at eh.wrapcommand(b"update")
+ at eh.wrapcommand(b"pull")
 def wrapmayobsoletewc(origfn, ui, repo, *args, **opts):
     """Warn that the working directory parent is an obsolete changeset"""
-    ctx = repo['.']
+    ctx = repo[b'.']
     node = ctx.node()
     isobs = ctx.obsolete()
 
@@ -776,23 +776,23 @@
         lockmod.release(wlock)
     return res
 
- at eh.wrapcommand("parents")
+ at eh.wrapcommand(b"parents")
 def wrapparents(origfn, ui, repo, *args, **opts):
     res = origfn(ui, repo, *args, **opts)
     _warnobsoletewc(ui, repo)
     return res
 
- at eh.wrapfunction(mercurial.exchange, 'push')
+ at eh.wrapfunction(mercurial.exchange, b'push')
 def push(orig, repo, *args, **opts):
     """Add a hint for "hg evolve" when troubles make push fails
     """
     try:
         return orig(repo, *args, **opts)
     except error.Abort as ex:
-        hint = _("use 'hg evolve' to get a stable history "
-                 "or --force to ignore warnings")
+        hint = _(b"use 'hg evolve' to get a stable history "
+                 b"or --force to ignore warnings")
         if (len(ex.args) >= 1
-            and ex.args[0].startswith('push includes ')
+            and ex.args[0].startswith(b'push includes ')
             and ex.hint is None):
             ex.hint = hint
         raise
@@ -801,11 +801,11 @@
     evolvestate = state.cmdstate(repo)
     if evolvestate:
         # i18n: column positioning for "hg summary"
-        ui.status(_('evolve: (evolve --continue)\n'))
+        ui.status(_(b'evolve: (evolve --continue)\n'))
 
 @eh.extsetup
 def obssummarysetup(ui):
-    cmdutil.summaryhooks.add('evolve', summaryhook)
+    cmdutil.summaryhooks.add(b'evolve', summaryhook)
 
 #####################################################################
 ### Old Evolve extension content                                  ###
@@ -816,20 +816,20 @@
 
 @eh.uisetup
 def _installimportobsolete(ui):
-    entry = cmdutil.findcmd('import', commands.table)[1]
-    entry[1].append(('', 'obsolete', False,
-                    _('mark the old node as obsoleted by '
-                      'the created commit')))
+    entry = cmdutil.findcmd(b'import', commands.table)[1]
+    entry[1].append((b'', b'obsolete', False,
+                     _(b'mark the old node as obsoleted by '
+                       b'the created commit')))
 
 def _getnodefrompatch(patch, dest):
-    patchnode = patch.get('nodeid')
+    patchnode = patch.get(b'nodeid')
     if patchnode is not None:
-        dest['node'] = node.bin(patchnode)
+        dest[b'node'] = node.bin(patchnode)
 
- at eh.wrapfunction(mercurial.cmdutil, 'tryimportone')
+ at eh.wrapfunction(mercurial.cmdutil, b'tryimportone')
 def tryimportone(orig, ui, repo, hunk, parents, opts, *args, **kwargs):
-    expected = {'node': None}
-    if not util.safehasattr(hunk, 'get'): # hg < 4.6
+    expected = {b'node': None}
+    if not util.safehasattr(hunk, b'get'): # hg < 4.6
         oldextract = patch.extract
 
         def extract(*args, **kwargs):
@@ -845,12 +845,12 @@
         _getnodefrompatch(hunk, expected)
         ret = orig(ui, repo, hunk, parents, opts, *args, **kwargs)
     created = ret[1]
-    if (opts['obsolete'] and None not in (created, expected['node'])
-        and created != expected['node']):
-        tr = repo.transaction('import-obs')
+    if (opts[b'obsolete'] and None not in (created, expected[b'node'])
+        and created != expected[b'node']):
+        tr = repo.transaction(b'import-obs')
         try:
-            metadata = {'user': ui.username()}
-            repo.obsstore.create(tr, expected['node'], (created,),
+            metadata = {b'user': ui.username()}
+            repo.obsstore.create(tr, expected[b'node'], (created,),
                                  metadata=metadata)
             tr.close()
         finally:
@@ -878,62 +878,62 @@
         if e is entry:
             break
 
-    synopsis = '(DEPRECATED)'
+    synopsis = b'(DEPRECATED)'
     if len(entry) > 2:
         fn, opts, _syn = entry
     else:
         fn, opts, = entry
-    deprecationwarning = _('%s have been deprecated in favor of %s\n') % (
+    deprecationwarning = _(b'%s have been deprecated in favor of %s\n') % (
         oldalias, newalias)
 
     def newfn(*args, **kwargs):
         ui = args[0]
         ui.warn(deprecationwarning)
         util.checksignature(fn)(*args, **kwargs)
-    newfn.__doc__ = deprecationwarning + ' (DEPRECATED)'
+    newfn.__doc__ = deprecationwarning + b' (DEPRECATED)'
     cmdwrapper = eh.command(oldalias, opts, synopsis)
     cmdwrapper(newfn)
 
 @eh.extsetup
 def deprecatealiases(ui):
-    _deprecatealias('gup', 'next')
-    _deprecatealias('gdown', 'previous')
+    _deprecatealias(b'gup', b'next')
+    _deprecatealias(b'gdown', b'previous')
 
 def _gettopic(ctx):
     """handle topic fetching with or without the extension"""
-    return getattr(ctx, 'topic', lambda: '')()
+    return getattr(ctx, 'topic', lambda: b'')()
 
 def _gettopicidx(ctx):
     """handle topic fetching with or without the extension"""
     return getattr(ctx, 'topicidx', lambda: None)()
 
 def _getcurrenttopic(repo):
-    return getattr(repo, 'currenttopic', '')
+    return getattr(repo, 'currenttopic', b'')
 
 def _prevupdate(repo, displayer, target, bookmark, dryrun, mergeopt):
     if dryrun:
-        repo.ui.write(_('hg update %s;\n') % target)
+        repo.ui.write(_(b'hg update %s;\n') % target)
         if bookmark is not None:
-            repo.ui.write(_('hg bookmark %s -r %s;\n')
+            repo.ui.write(_(b'hg bookmark %s -r %s;\n')
                           % (bookmark, target))
     else:
         updatecheck = None
         # --merge is passed, we don't need to care about commands.update.check
         # config option
         if mergeopt:
-            updatecheck = 'none'
+            updatecheck = b'none'
         try:
             ret = hg.updatetotally(repo.ui, repo, target.node(), None,
                                    updatecheck=updatecheck)
         except error.Abort as exc:
             # replace the hint to mention about --merge option
-            exc.hint = _('do you want --merge?')
+            exc.hint = _(b'do you want --merge?')
             raise
         if not ret:
             tr = lock = None
             try:
                 lock = repo.lock()
-                tr = repo.transaction('previous')
+                tr = repo.transaction(b'previous')
                 if bookmark is not None:
                     bmchanges = [(bookmark, target.node())]
                     repo._bookmarks.applychanges(repo, tr, bmchanges)
@@ -961,75 +961,75 @@
 
     # issue message for the various case
     if p1.node() == node.nullid:
-        repo.ui.warn(_('already at repository root\n'))
+        repo.ui.warn(_(b'already at repository root\n'))
     elif not parents and currenttopic:
-        repo.ui.warn(_('no parent in topic "%s"\n') % currenttopic)
-        repo.ui.warn(_('(do you want --no-topic)\n'))
+        repo.ui.warn(_(b'no parent in topic "%s"\n') % currenttopic)
+        repo.ui.warn(_(b'(do you want --no-topic)\n'))
     elif len(parents) == 1:
         target = parents[0]
         bookmark = None
         if movebookmark:
             bookmark = repo._activebookmark
     else:
-        header = _("multiple parents, choose one to update:")
+        header = _(b"multiple parents, choose one to update:")
         prevs = [p.rev() for p in parents]
         choosedrev = utility.revselectionprompt(repo.ui, repo, prevs, header)
         if choosedrev is None:
             for p in parents:
                 displayer.show(p)
-            repo.ui.warn(_('multiple parents, explicitly update to one\n'))
+            repo.ui.warn(_(b'multiple parents, explicitly update to one\n'))
         else:
             target = repo[choosedrev]
     return target, bookmark
 
 @eh.command(
-    'previous',
-    [('B', 'move-bookmark', False,
-        _('move active bookmark after update')),
-     ('m', 'merge', False, _('bring uncommitted change along')),
-     ('', 'no-topic', False, _('ignore topic and move topologically')),
-     ('n', 'dry-run', False,
-        _('do not perform actions, just print what would be done'))],
-    '[OPTION]...',
+    b'previous',
+    [(b'B', b'move-bookmark', False,
+        _(b'move active bookmark after update')),
+     (b'm', b'merge', False, _(b'bring uncommitted change along')),
+     (b'', b'no-topic', False, _(b'ignore topic and move topologically')),
+     (b'n', b'dry-run', False,
+        _(b'do not perform actions, just print what would be done'))],
+    b'[OPTION]...',
     helpbasic=True)
 def cmdprevious(ui, repo, **opts):
     """update to parent revision
 
     Displays the summary line of the destination for clarity."""
     wlock = None
-    dryrunopt = opts['dry_run']
-    mergeopt = opts['merge']
+    dryrunopt = opts[b'dry_run']
+    mergeopt = opts[b'merge']
     if not dryrunopt:
         wlock = repo.wlock()
     try:
         wkctx = repo[None]
         wparents = wkctx.parents()
         if len(wparents) != 1:
-            raise error.Abort(_('merge in progress'))
+            raise error.Abort(_(b'merge in progress'))
         if not mergeopt:
             # we only skip the check if noconflict is set
-            if ui.config('commands', 'update.check') == 'noconflict':
+            if ui.config(b'commands', b'update.check') == b'noconflict':
                 pass
             else:
-                cmdutil.bailifchanged(repo, hint=_('do you want --merge?'))
+                cmdutil.bailifchanged(repo, hint=_(b'do you want --merge?'))
 
-        topic = not opts.get("no_topic", False)
+        topic = not opts.get(b"no_topic", False)
         hastopic = bool(_getcurrenttopic(repo))
 
         template = shorttemplate
         if topic and hastopic:
             template = utility.stacktemplate
 
-        displayer = compat.changesetdisplayer(ui, repo, {'template': template})
+        displayer = compat.changesetdisplayer(ui, repo, {b'template': template})
 
         target, bookmark = _findprevtarget(repo, displayer,
-                                           opts.get('move_bookmark'), topic)
+                                           opts.get(b'move_bookmark'), topic)
         if target is not None:
-            backup = repo.ui.backupconfig('_internal', 'keep-topic')
+            backup = repo.ui.backupconfig(b'_internal', b'keep-topic')
             try:
                 if topic and _getcurrenttopic(repo) != _gettopic(target):
-                    repo.ui.setconfig('_internal', 'keep-topic', 'yes',
-                                      source='topic-extension')
+                    repo.ui.setconfig(b'_internal', b'keep-topic', b'yes',
+                                      source=b'topic-extension')
                 _prevupdate(repo, displayer, target, bookmark, dryrunopt,
                             mergeopt)
             finally:
@@ -1041,15 +1041,15 @@
         lockmod.release(wlock)
 
 @eh.command(
-    'next',
-    [('B', 'move-bookmark', False,
-        _('move active bookmark after update')),
-     ('m', 'merge', False, _('bring uncommitted change along')),
-     ('', 'evolve', True, _('evolve the next changeset if necessary')),
-     ('', 'no-topic', False, _('ignore topic and move topologically')),
-     ('n', 'dry-run', False,
-      _('do not perform actions, just print what would be done'))],
-    '[OPTION]...',
+    b'next',
+    [(b'B', b'move-bookmark', False,
+        _(b'move active bookmark after update')),
+     (b'm', b'merge', False, _(b'bring uncommitted change along')),
+     (b'', b'evolve', True, _(b'evolve the next changeset if necessary')),
+     (b'', b'no-topic', False, _(b'ignore topic and move topologically')),
+     (b'n', b'dry-run', False,
+      _(b'do not perform actions, just print what would be done'))],
+    b'[OPTION]...',
     helpbasic=True)
 def cmdnext(ui, repo, **opts):
     """update to next child revision
@@ -1060,29 +1060,29 @@
     Displays the summary line of the destination for clarity.
     """
     wlock = None
-    dryrunopt = opts['dry_run']
+    dryrunopt = opts[b'dry_run']
     if not dryrunopt:
         wlock = repo.wlock()
     try:
         wkctx = repo[None]
         wparents = wkctx.parents()
         if len(wparents) != 1:
-            raise error.Abort(_('merge in progress'))
+            raise error.Abort(_(b'merge in progress'))
 
         children = [ctx for ctx in wparents[0].children() if not ctx.obsolete()]
         topic = _getcurrenttopic(repo)
         filtered = set()
         template = shorttemplate
-        if topic and not opts.get("no_topic", False):
+        if topic and not opts.get(b"no_topic", False):
             filtered = set(ctx for ctx in children if ctx.topic() != topic)
             children = [ctx for ctx in children if ctx not in filtered]
             template = utility.stacktemplate
-            opts['stacktemplate'] = True
-        displayer = compat.changesetdisplayer(ui, repo, {'template': template})
+            opts[b'stacktemplate'] = True
+        displayer = compat.changesetdisplayer(ui, repo, {b'template': template})
 
         # check if we need to evolve while updating to the next child revision
         needevolve = False
-        aspchildren = evolvecmd._aspiringchildren(repo, [repo['.'].rev()])
+        aspchildren = evolvecmd._aspiringchildren(repo, [repo[b'.'].rev()])
         if topic:
             filtered.update(repo[c] for c in aspchildren
                             if repo[c].topic() != topic)
@@ -1101,54 +1101,54 @@
             needevolve = True
 
         # check if working directory is clean before we evolve the next cset
-        if needevolve and opts['evolve']:
-            hint = _('use `hg amend`, `hg revert` or `hg shelve`')
+        if needevolve and opts[b'evolve']:
+            hint = _(b'use `hg amend`, `hg revert` or `hg shelve`')
             cmdutil.bailifchanged(repo, hint=hint)
 
-        if not (opts['merge'] or (needevolve and opts['evolve'])):
+        if not (opts[b'merge'] or (needevolve and opts[b'evolve'])):
             # we only skip the check if noconflict is set
-            if ui.config('commands', 'update.check') == 'noconflict':
+            if ui.config(b'commands', b'update.check') == b'noconflict':
                 pass
             else:
-                cmdutil.bailifchanged(repo, hint=_('do you want --merge?'))
+                cmdutil.bailifchanged(repo, hint=_(b'do you want --merge?'))
 
         if len(children) == 1:
             c = children[0]
             return _updatetonext(ui, repo, c, displayer, opts)
         elif children:
-            cheader = _("ambiguous next changeset, choose one to update:")
+            cheader = _(b"ambiguous next changeset, choose one to update:")
             crevs = [c.rev() for c in children]
             choosedrev = utility.revselectionprompt(ui, repo, crevs, cheader)
             if choosedrev is None:
-                ui.warn(_("ambiguous next changeset:\n"))
+                ui.warn(_(b"ambiguous next changeset:\n"))
                 for c in children:
                     displayer.show(c)
-                ui.warn(_("explicitly update to one of them\n"))
+                ui.warn(_(b"explicitly update to one of them\n"))
                 return 1
             else:
                 return _updatetonext(ui, repo, repo[choosedrev], displayer, opts)
         else:
-            if not opts['evolve'] or not aspchildren:
+            if not opts[b'evolve'] or not aspchildren:
                 if filtered:
-                    ui.warn(_('no children on topic "%s"\n') % topic)
-                    ui.warn(_('do you want --no-topic\n'))
+                    ui.warn(_(b'no children on topic "%s"\n') % topic)
+                    ui.warn(_(b'do you want --no-topic\n'))
                 else:
-                    ui.warn(_('no children\n'))
+                    ui.warn(_(b'no children\n'))
                 if aspchildren:
-                    msg = _('(%i unstable changesets to be evolved here, '
-                            'do you want --evolve?)\n')
+                    msg = _(b'(%i unstable changesets to be evolved here, '
+                            b'do you want --evolve?)\n')
                     ui.warn(msg % len(aspchildren))
                 return 1
             elif len(aspchildren) > 1:
-                cheader = _("ambiguous next (unstable) changeset, choose one to"
-                            " evolve and update:")
+                cheader = _(b"ambiguous next (unstable) changeset, choose one to"
+                            b" evolve and update:")
                 choosedrev = utility.revselectionprompt(ui, repo,
                                                         aspchildren, cheader)
                 if choosedrev is None:
-                    ui.warn(_("ambiguous next (unstable) changeset:\n"))
+                    ui.warn(_(b"ambiguous next (unstable) changeset:\n"))
                     for c in aspchildren:
                         displayer.show(repo[c])
-                    ui.warn(_("(run 'hg evolve --rev REV' on one of them)\n"))
+                    ui.warn(_(b"(run 'hg evolve --rev REV' on one of them)\n"))
                     return 1
                 else:
                     return _nextevolve(ui, repo, repo[choosedrev], opts)
@@ -1161,51 +1161,51 @@
     """logic for hg next command to evolve and update to an aspiring children"""
 
     cmdutil.bailifchanged(repo)
-    evolvestate = state.cmdstate(repo, opts={'command': 'next',
-                                             'bookmarkchanges': []})
+    evolvestate = state.cmdstate(repo, opts={b'command': b'next',
+                                             b'bookmarkchanges': []})
     with repo.wlock(), repo.lock():
-        tr = repo.transaction("evolve")
+        tr = repo.transaction(b"evolve")
         with util.acceptintervention(tr):
             result = evolvecmd._solveone(ui, repo, repo[aspchildren],
-                                         evolvestate, opts.get('dry_run'),
+                                         evolvestate, opts.get(b'dry_run'),
                                          False,
-                                         lambda: None, category='orphan',
-                                         stacktmplt=opts.get('stacktemplate',
+                                         lambda: None, category=b'orphan',
+                                         stacktmplt=opts.get(b'stacktemplate',
                                                              False))
     # making sure a next commit is formed
     if result[0] and result[1]:
-        ui.status(_('working directory is now at %s\n')
-                  % ui.label(str(repo['.']), 'evolve.node'))
+        ui.status(_(b'working directory is now at %s\n')
+                  % ui.label(str(repo[b'.']), b'evolve.node'))
     return 0
 
 def _updatetonext(ui, repo, children, displayer, opts):
     """ logic for `hg next` command to update to children and move bookmarks if
     required """
     bm = repo._activebookmark
-    shouldmove = opts.get('move_bookmark') and bm is not None
-    if opts.get('dry_run'):
-        ui.write(_('hg update %s;\n') % children)
+    shouldmove = opts.get(b'move_bookmark') and bm is not None
+    if opts.get(b'dry_run'):
+        ui.write(_(b'hg update %s;\n') % children)
         if shouldmove:
-            ui.write(_('hg bookmark %s -r %s;\n') % (bm, children))
+            ui.write(_(b'hg bookmark %s -r %s;\n') % (bm, children))
     else:
         updatecheck = None
         # --merge is passed, we don't need to care about commands.update.check
         # config option
-        if opts['merge']:
-            updatecheck = 'none'
+        if opts[b'merge']:
+            updatecheck = b'none'
         try:
             ret = hg.updatetotally(ui, repo, children.node(), None,
                                    updatecheck=updatecheck)
         except error.Abort as exc:
             # replace the hint to mention about --merge option
-            exc.hint = _('do you want --merge?')
+            exc.hint = _(b'do you want --merge?')
             raise
 
         if not ret:
             lock = tr = None
             try:
                 lock = repo.lock()
-                tr = repo.transaction('next')
+                tr = repo.transaction(b'next')
                 if shouldmove:
                     bmchanges = [(bm, children.node())]
                     repo._bookmarks.applychanges(repo, tr, bmchanges)
@@ -1218,28 +1218,28 @@
         displayer.show(children)
     return 0
 
- at eh.wrapcommand('commit')
+ at eh.wrapcommand(b'commit')
 def commitwrapper(orig, ui, repo, *arg, **kwargs):
     tr = None
-    if kwargs.get('amend', False):
+    if kwargs.get(b'amend', False):
         wlock = lock = None
     else:
         wlock = repo.wlock()
         lock = repo.lock()
     try:
-        obsoleted = kwargs.get('obsolete', [])
+        obsoleted = kwargs.get(b'obsolete', [])
         if obsoleted:
-            obsoleted = repo.set('%lr', obsoleted)
+            obsoleted = repo.set(b'%lr', obsoleted)
         result = orig(ui, repo, *arg, **kwargs)
         if not result: # commit succeeded
-            new = repo['tip']
+            new = repo[b'tip']
             oldbookmarks = []
             markers = []
             for old in obsoleted:
                 oldbookmarks.extend(repo.nodebookmarks(old.node()))
                 markers.append((old, (new,)))
             if markers:
-                obsolete.createmarkers(repo, markers, operation="amend")
+                obsolete.createmarkers(repo, markers, operation=b"amend")
             bmchanges = []
             for book in oldbookmarks:
                 bmchanges.append((book, new.node()))
@@ -1248,70 +1248,70 @@
                     wlock = repo.wlock()
                 if not lock:
                     lock = repo.lock()
-                tr = repo.transaction('commit')
+                tr = repo.transaction(b'commit')
                 repo._bookmarks.applychanges(repo, tr, bmchanges)
                 tr.close()
         return result
     finally:
         lockmod.release(tr, lock, wlock)
 
- at eh.wrapcommand('strip', extension='strip', opts=[
-    ('', 'bundle', None, _("delete the commit entirely and move it to a "
-                           "backup bundle")),
+ at eh.wrapcommand(b'strip', extension=b'strip', opts=[
+    (b'', b'bundle', None, _(b"delete the commit entirely and move it to a "
+                             b"backup bundle")),
     ])
 def stripwrapper(orig, ui, repo, *revs, **kwargs):
-    if (not ui.configbool('experimental', 'prunestrip')
-        or kwargs.get('bundle', False)):
+    if (not ui.configbool(b'experimental', b'prunestrip')
+        or kwargs.get(b'bundle', False)):
         return orig(ui, repo, *revs, **kwargs)
 
-    if kwargs.get('force'):
-        ui.warn(_("warning: --force has no effect during strip with evolve "
-                  "enabled\n"))
-    if kwargs.get('no_backup', False):
-        ui.warn(_("warning: --no-backup has no effect during strips with "
-                  "evolve enabled\n"))
+    if kwargs.get(b'force'):
+        ui.warn(_(b"warning: --force has no effect during strip with evolve "
+                  b"enabled\n"))
+    if kwargs.get(b'no_backup', False):
+        ui.warn(_(b"warning: --no-backup has no effect during strips with "
+                  b"evolve enabled\n"))
 
-    revs = list(revs) + kwargs.pop('rev', [])
+    revs = list(revs) + kwargs.pop(b'rev', [])
     revs = set(scmutil.revrange(repo, revs))
-    revs = repo.revs("(%ld)::", revs)
-    kwargs['rev'] = []
-    kwargs['new'] = []
-    kwargs['succ'] = []
-    kwargs['biject'] = False
+    revs = repo.revs(b"(%ld)::", revs)
+    kwargs[b'rev'] = []
+    kwargs[b'new'] = []
+    kwargs[b'succ'] = []
+    kwargs[b'biject'] = False
     return cmdrewrite.cmdprune(ui, repo, *revs, **kwargs)
 
 @eh.extsetup
 def oldevolveextsetup(ui):
-    entry = cmdutil.findcmd('commit', commands.table)[1]
-    entry[1].append(('o', 'obsolete', [],
-                     _("make commit obsolete this revision (DEPRECATED)")))
+    entry = cmdutil.findcmd(b'commit', commands.table)[1]
+    entry[1].append((b'o', b'obsolete', [],
+                     _(b"make commit obsolete this revision (DEPRECATED)")))
 
- at eh.wrapfunction(obsolete, '_checkinvalidmarkers')
+ at eh.wrapfunction(obsolete, b'_checkinvalidmarkers')
 def _checkinvalidmarkers(orig, markers):
     """search for marker with invalid data and raise error if needed
 
     Exist as a separated function to allow the evolve extension for a more
     subtle handling.
     """
-    if 'debugobsconvert' in sys.argv:
+    if b'debugobsconvert' in sys.argv:
         return
     for mark in markers:
         if node.nullid in mark[1]:
-            msg = _('bad obsolescence marker detected: invalid successors nullid')
-            hint = _('You should run `hg debugobsconvert`')
+            msg = _(b'bad obsolescence marker detected: invalid successors nullid')
+            hint = _(b'You should run `hg debugobsconvert`')
             raise error.Abort(msg, hint=hint)
 
 @eh.command(
-    'debugobsconvert',
-    [('', 'new-format', obsexchange._bestformat, _('Destination format for markers.'))],
-    '')
+    b'debugobsconvert',
+    [(b'', b'new-format', obsexchange._bestformat, _(b'Destination format for markers.'))],
+    b'')
 def debugobsconvert(ui, repo, new_format):
     origmarkers = repo.obsstore._all  # settle version
     if new_format == repo.obsstore._version:
-        msg = _('New format is the same as the old format, not upgrading!')
+        msg = _(b'New format is the same as the old format, not upgrading!')
         raise error.Abort(msg)
     with repo.lock():
-        f = repo.svfs('obsstore', 'wb', atomictemp=True)
+        f = repo.svfs(b'obsstore', b'wb', atomictemp=True)
         known = set()
         markers = []
         for m in origmarkers:
@@ -1324,11 +1324,11 @@
                 continue
             known.add(m)
             markers.append(m)
-        ui.write(_('Old store is version %d, will rewrite in version %d\n') % (
+        ui.write(_(b'Old store is version %d, will rewrite in version %d\n') % (
             repo.obsstore._version, new_format))
         map(f.write, obsolete.encodemarkers(markers, True, new_format))
         f.close()
-    ui.write(_('Done!\n'))
+    ui.write(_(b'Done!\n'))
 
 
 def _helploader(ui):
@@ -1337,40 +1337,40 @@
 @eh.uisetup
 def _setuphelp(ui):
     for entry in help.helptable:
-        if entry[0] == "evolution":
+        if entry[0] == b"evolution":
             break
     else:
-        help.helptable.append((["evolution"], _("Safely Rewriting History"),
-                              _helploader))
+        help.helptable.append(([b"evolution"], _(b"Safely Rewriting History"),
+                               _helploader))
         help.helptable.sort()
 
 evolvestateversion = 0
 
 def _evolvemessage():
-    _msg = _('To continue:    hg evolve --continue\n'
-             'To abort:       hg evolve --abort\n'
-             'To stop:        hg evolve --stop\n'
-             '(also see `hg help evolve.interrupted`)')
+    _msg = _(b'To continue:    hg evolve --continue\n'
+             b'To abort:       hg evolve --abort\n'
+             b'To stop:        hg evolve --stop\n'
+             b'(also see `hg help evolve.interrupted`)')
     return cmdutil._commentlines(_msg)
 
 @eh.uisetup
 def setupevolveunfinished(ui):
-    data = ('evolvestate', False, False, _('evolve in progress'),
-            _("use 'hg evolve --continue' or 'hg evolve --abort' to abort"))
+    data = (b'evolvestate', False, False, _(b'evolve in progress'),
+            _(b"use 'hg evolve --continue' or 'hg evolve --abort' to abort"))
     cmdutil.unfinishedstates.append(data)
 
-    afterresolved = ('evolvestate', _('hg evolve --continue'))
-    pickresolved = ('pickstate', _('hg pick --continue'))
+    afterresolved = (b'evolvestate', _(b'hg evolve --continue'))
+    pickresolved = (b'pickstate', _(b'hg pick --continue'))
     cmdutil.afterresolvedstates.append(afterresolved)
     cmdutil.afterresolvedstates.append(pickresolved)
 
-    if util.safehasattr(cmdutil, 'STATES'):
-        statedata = ('evolve', cmdutil.fileexistspredicate('evolvestate'),
+    if util.safehasattr(cmdutil, b'STATES'):
+        statedata = (b'evolve', cmdutil.fileexistspredicate(b'evolvestate'),
                      _evolvemessage)
         cmdutil.STATES = (statedata, ) + cmdutil.STATES
 
- at eh.wrapfunction(hg, 'clean')
+ at eh.wrapfunction(hg, b'clean')
 def clean(orig, repo, *args, **kwargs):
     ret = orig(repo, *args, **kwargs)
-    util.unlinkpath(repo.vfs.join('evolvestate'), ignoremissing=True)
+    util.unlinkpath(repo.vfs.join(b'evolvestate'), ignoremissing=True)
     return ret
diff --git a/hgext3rd/evolve/cmdrewrite.py b/hgext3rd/evolve/cmdrewrite.py
--- a/hgext3rd/evolve/cmdrewrite.py
+++ b/hgext3rd/evolve/cmdrewrite.py
@@ -61,17 +61,17 @@
 def _checknotesize(ui, opts):
     """ make sure note is of valid format """
 
-    note = opts.get('note')
+    note = opts.get(b'note')
     if not note:
         return
 
     if not compat.isobsnotesupported():
-        ui.warn(_("current hg version does not support storing"
-                  " note in obsmarker\n"))
+        ui.warn(_(b"current hg version does not support storing"
+                  b" note in obsmarker\n"))
     if len(note) > 255:
-        raise error.Abort(_("cannot store a note of more than 255 bytes"))
-    if '\n' in note:
-        raise error.Abort(_("note cannot contain a newline"))
+        raise error.Abort(_(b"cannot store a note of more than 255 bytes"))
+    if b'\n' in note:
+        raise error.Abort(_(b"note cannot contain a newline"))
 
 def _resolveoptions(ui, opts):
     """modify commit options dict to handle related options
@@ -80,34 +80,34 @@
     -d was supplied.
     """
     # N.B. this is extremely similar to setupheaderopts() in mq.py
-    if not opts.get('date') and opts.get('current_date'):
-        opts['date'] = '%d %d' % compat.makedate()
-    if not opts.get('user') and opts.get('current_user'):
-        opts['user'] = ui.username()
+    if not opts.get(b'date') and opts.get(b'current_date'):
+        opts[b'date'] = b'%d %d' % compat.makedate()
+    if not opts.get(b'user') and opts.get(b'current_user'):
+        opts[b'user'] = ui.username()
 
 commitopts3 = [
-    ('D', 'current-date', None,
-     _('record the current date as commit date')),
-    ('U', 'current-user', None,
-     _('record the current user as committer')),
+    (b'D', b'current-date', None,
+     _(b'record the current date as commit date')),
+    (b'U', b'current-user', None,
+     _(b'record the current user as committer')),
 ]
 
-interactiveopt = [['i', 'interactive', None, _('use interactive mode')]]
+interactiveopt = [[b'i', b'interactive', None, _(b'use interactive mode')]]
 
 @eh.command(
-    'amend|refresh',
-    [('A', 'addremove', None,
-      _('mark new/missing files as added/removed before committing')),
-     ('a', 'all', False, _("match all files")),
-     ('e', 'edit', False, _('invoke editor on commit messages')),
-     ('', 'extract', False, _('extract changes from the commit to the working copy')),
-     ('', 'patch', False, _('make changes to wdir parent by editing patch')),
-     ('', 'close-branch', None,
-      _('mark a branch as closed, hiding it from the branch list')),
-     ('s', 'secret', None, _('use the secret phase for committing')),
-     ('n', 'note', '', _('store a note on amend'), _('TEXT')),
-    ] + walkopts + commitopts + commitopts2 + commitopts3 + interactiveopt,
-    _('[OPTION]... [FILE]...'),
+    b'amend|refresh',
+    [(b'A', b'addremove', None,
+      _(b'mark new/missing files as added/removed before committing')),
+     (b'a', b'all', False, _(b"match all files")),
+     (b'e', b'edit', False, _(b'invoke editor on commit messages')),
+     (b'', b'extract', False, _(b'extract changes from the commit to the working copy')),
+     (b'', b'patch', False, _(b'make changes to wdir parent by editing patch')),
+     (b'', b'close-branch', None,
+      _(b'mark a branch as closed, hiding it from the branch list')),
+     (b's', b'secret', None, _(b'use the secret phase for committing')),
+     (b'n', b'note', b'', _(b'store a note on amend'), _(b'TEXT')),
+     ] + walkopts + commitopts + commitopts2 + commitopts3 + interactiveopt,
+    _(b'[OPTION]... [FILE]...'),
     helpbasic=True)
 def amend(ui, repo, *pats, **opts):
     """combine a changeset with updates and replace it with a new one
@@ -127,34 +127,34 @@
     """
     _checknotesize(ui, opts)
     opts = opts.copy()
-    if opts.get('patch'):
+    if opts.get(b'patch'):
         return amendpatch(ui, repo, *pats, **opts)
-    if opts.get('extract'):
+    if opts.get(b'extract'):
         return uncommit(ui, repo, *pats, **opts)
     else:
-        if opts.pop('all', False):
+        if opts.pop(b'all', False):
             # add an include for all
-            include = list(opts.get('include'))
-            include.append('re:.*')
-        edit = opts.pop('edit', False)
-        log = opts.get('logfile')
-        opts['amend'] = True
+            include = list(opts.get(b'include'))
+            include.append(b're:.*')
+        edit = opts.pop(b'edit', False)
+        log = opts.get(b'logfile')
+        opts[b'amend'] = True
         _resolveoptions(ui, opts)
-        _alias, commitcmd = cmdutil.findcmd('commit', commands.table)
+        _alias, commitcmd = cmdutil.findcmd(b'commit', commands.table)
         with repo.wlock(), repo.lock():
-            if not (edit or opts['message'] or log):
-                opts['message'] = repo['.'].description()
-            rewriteutil.precheck(repo, [repo['.'].rev()], action='amend')
+            if not (edit or opts[b'message'] or log):
+                opts[b'message'] = repo[b'.'].description()
+            rewriteutil.precheck(repo, [repo[b'.'].rev()], action=b'amend')
             return commitcmd[0](ui, repo, *pats, **opts)
 
 def amendpatch(ui, repo, *pats, **opts):
     """logic for --patch flag of `hg amend` command."""
-    with repo.wlock(), repo.lock(), repo.transaction('amend') as tr:
+    with repo.wlock(), repo.lock(), repo.transaction(b'amend') as tr:
         cmdutil.bailifchanged(repo)
         # first get the patch
-        old = repo['.']
+        old = repo[b'.']
         p1 = old.p1()
-        rewriteutil.precheck(repo, [old.rev()], 'amend')
+        rewriteutil.precheck(repo, [old.rev()], b'amend')
         diffopts = patch.difffeatureopts(repo.ui, whitespace=True)
         diffopts.nodates = True
         diffopts.git = True
@@ -167,12 +167,12 @@
             fp.write(chunk)
         newnode = _editandapply(ui, repo, pats, old, p1, fp, diffopts)
         if newnode == old.node():
-            raise error.Abort(_("nothing changed"))
+            raise error.Abort(_(b"nothing changed"))
         metadata = {}
-        if opts.get('note'):
-            metadata['note'] = opts['note']
+        if opts.get(b'note'):
+            metadata[b'note'] = opts[b'note']
         replacements = {old.node(): [newnode]}
-        scmutil.cleanupnodes(repo, replacements, operation='amend',
+        scmutil.cleanupnodes(repo, replacements, operation=b'amend',
                              metadata=metadata)
         phases.retractboundary(repo, tr, old.phase(), [newnode])
         hg.updaterepo(repo, newnode, True)
@@ -183,7 +183,7 @@
         fp.seek(0)
         previous_patch = fp.getvalue()
         if 5 <= len(ui.edit.im_func.func_defaults):
-            newpatch = ui.edit(fp.getvalue(), old.user(), action="diff")
+            newpatch = ui.edit(fp.getvalue(), old.user(), action=b"diff")
         else:
             newpatch = ui.edit(fp.getvalue(), old.user())
 
@@ -191,7 +191,7 @@
         afp.write(newpatch)
         if pats:
             # write rest of the files in the patch
-            restmatcher = scmutil.match(old, [], opts={'exclude': pats})
+            restmatcher = scmutil.match(old, [], opts={b'exclude': pats})
             for chunk, label in patch.diffui(repo, p1.node(), old.node(),
                                              match=restmatcher,
                                              opts=diffopts):
@@ -199,21 +199,21 @@
 
         user_patch = afp.getvalue()
         if not user_patch:
-            raise error.Abort(_("empty patch file, amend aborted"))
+            raise error.Abort(_(b"empty patch file, amend aborted"))
         if user_patch == previous_patch:
-            raise error.Abort(_("patch unchanged"))
+            raise error.Abort(_(b"patch unchanged"))
         afp.seek(0)
         # write the patch to repo and get the newnode
         try:
             newnode = _writepatch(ui, repo, old, afp)
         except patch.PatchError as err:
-            ui.write_err(_("failed to apply edited patch: %s\n") % err)
+            ui.write_err(_(b"failed to apply edited patch: %s\n") % err)
             defaultchoice = 0 # yes
             if not ui.interactive:
                 defaultchoice = 1 # no
-            retrychoice = _('try to fix the patch (yn)?$$ &Yes $$ &No')
+            retrychoice = _(b'try to fix the patch (yn)?$$ &Yes $$ &No')
             if ui.promptchoice(retrychoice, default=defaultchoice):
-                raise error.Abort(_("Could not apply amended path"))
+                raise error.Abort(_(b"Could not apply amended path"))
             else:
                 # consider a third choice where we restore the original patch
                 fp = stringio()
@@ -224,7 +224,7 @@
     """utility function to use filestore and patchrepo to apply a patch to the
     repository with metadata being extracted from the patch"""
     metadata = patch.extract(ui, fp)
-    if util.safehasattr(metadata, 'get'): # < hg-4.6
+    if util.safehasattr(metadata, b'get'): # < hg-4.6
         @contextlib.contextmanager
         def patchcontext():
             yield metadata
@@ -235,20 +235,20 @@
 
     with patchcontext as metadata:
         # store the metadata from the patch to variables
-        parents = (metadata.get('p1'), metadata.get('p2'))
-        date = metadata.get('date') or old.date()
-        branch = metadata.get('branch') or old.branch()
-        user = metadata.get('user') or old.user()
+        parents = (metadata.get(b'p1'), metadata.get(b'p2'))
+        date = metadata.get(b'date') or old.date()
+        branch = metadata.get(b'branch') or old.branch()
+        user = metadata.get(b'user') or old.user()
         # XXX: we must extract extras from the patchfile too
         extra = old.extra()
-        message = metadata.get('message') or old.description()
+        message = metadata.get(b'message') or old.description()
         store = patch.filestore()
         fp.seek(0)
         try:
             files = set()
             # beware: next line may raise a PatchError to be handled by the caller
             # of this function
-            patch.patchrepo(ui, repo, pold, store, fp, 1, '',
+            patch.patchrepo(ui, repo, pold, store, fp, 1, b'',
                             files=files, eolmode=None)
 
             memctx = context.memctx(repo, parents, message, files=files,
@@ -271,23 +271,23 @@
     else:
         prev = node.nullid
 
-    fp.write("# HG changeset patch\n")
-    fp.write("# User %s\n" % ctx.user())
-    fp.write("# Date %d %d\n" % ctx.date())
-    fp.write("#      %s\n" % datestr(ctx.date()))
-    if branch and branch != 'default':
-        fp.write("# Branch %s\n" % branch)
-    fp.write("# Node ID %s\n" % node.hex(nodeval))
-    fp.write("# Parent  %s\n" % node.hex(prev))
+    fp.write(b"# HG changeset patch\n")
+    fp.write(b"# User %s\n" % ctx.user())
+    fp.write(b"# Date %d %d\n" % ctx.date())
+    fp.write(b"#      %s\n" % datestr(ctx.date()))
+    if branch and branch != b'default':
+        fp.write(b"# Branch %s\n" % branch)
+    fp.write(b"# Node ID %s\n" % node.hex(nodeval))
+    fp.write(b"# Parent  %s\n" % node.hex(prev))
     if len(parents) > 1:
-        fp.write("# Parent  %s\n" % node.hex(parents[1]))
+        fp.write(b"# Parent  %s\n" % node.hex(parents[1]))
 
     for headerid in cmdutil.extraexport:
         header = cmdutil.extraexportmap[headerid](1, ctx)
         if header is not None:
-            fp.write('# %s\n' % header)
+            fp.write(b'# %s\n' % header)
     fp.write(ctx.description().rstrip())
-    fp.write("\n\n")
+    fp.write(b"\n\n")
 
 def _touchedbetween(repo, source, dest, match=None):
     touched = set()
@@ -320,7 +320,7 @@
 
     # Filter copies
     copied = copies.pathcopies(target, ctx)
-    copied = dict((dst, src) for dst, src in copied.iteritems()
+    copied = dict((dst, src) for dst, src in copied.items()
                   if dst in files)
 
     def filectxfn(repo, memctx, path, contentctx=ctx, redirect=newcontent):
@@ -356,7 +356,7 @@
     oldctx to a copy of oldctx not containing changed files matched by
     match.
     """
-    ctx = repo['.']
+    ctx = repo[b'.']
     ds = repo.dirstate
     copies = dict(ds.copies())
     if interactive:
@@ -375,7 +375,7 @@
             # Also any modifications to a removed file will result the status as
             # added, so we have only two cases. So in either of the cases, the
             # resulting status can be modified or clean.
-            if ds[f] == 'r':
+            if ds[f] == b'r':
                 # But the file is removed in the working directory, leaving that
                 # as removed
                 continue
@@ -389,7 +389,7 @@
             # does not adds it back. If it's adds it back, we do a normallookup.
             # The file can't be removed in working directory, because it was
             # removed in oldctx
-            if ds[f] == 'a':
+            if ds[f] == b'a':
                 ds.normallookup(f)
                 continue
             ds.remove(f)
@@ -401,7 +401,7 @@
             # would have resulted in modified status, not removed.
             # So a file added in a commit, and uncommitting that addition must
             # result in file being stated as unknown.
-            if ds[f] == 'r':
+            if ds[f] == b'r':
                 # The working directory say it's removed, so lets make the file
                 # unknown
                 ds.drop(f)
@@ -410,23 +410,23 @@
     else:
         m, a, r = repo.status(oldctx.p1(), oldctx, match=match)[:3]
         for f in m:
-            if ds[f] == 'r':
+            if ds[f] == b'r':
                 # modified + removed -> removed
                 continue
             ds.normallookup(f)
 
         for f in a:
-            if ds[f] == 'r':
+            if ds[f] == b'r':
                 # added + removed -> unknown
                 ds.drop(f)
-            elif ds[f] != 'a':
+            elif ds[f] != b'a':
                 ds.add(f)
 
         for f in r:
-            if ds[f] == 'a':
+            if ds[f] == b'a':
                 # removed + added -> normal
                 ds.normallookup(f)
-            elif ds[f] != 'r':
+            elif ds[f] != b'r':
                 ds.remove(f)
 
     # Merge old parent and old working dir copies
@@ -441,22 +441,22 @@
             oldcopies[f] = src[0]
     oldcopies.update(copies)
     copies = dict((dst, oldcopies.get(src, src))
-                  for dst, src in oldcopies.iteritems())
+                  for dst, src in oldcopies.items())
     # Adjust the dirstate copies
-    for dst, src in copies.iteritems():
-        if (src not in ctx or dst in ctx or ds[dst] != 'a'):
+    for dst, src in copies.items():
+        if (src not in ctx or dst in ctx or ds[dst] != b'a'):
             src = None
         ds.copy(src, dst)
 
 @eh.command(
-    'uncommit',
-    [('a', 'all', None, _('uncommit all changes when no arguments given')),
-     ('i', 'interactive', False, _('interactive mode to uncommit (EXPERIMENTAL)')),
-     ('r', 'rev', '', _('revert commit content to REV instead'), _('REV')),
-     ('', 'revert', False, _('discard working directory changes after uncommit')),
-     ('n', 'note', '', _('store a note on uncommit'), _('TEXT')),
+    b'uncommit',
+    [(b'a', b'all', None, _(b'uncommit all changes when no arguments given')),
+     (b'i', b'interactive', False, _(b'interactive mode to uncommit (EXPERIMENTAL)')),
+     (b'r', b'rev', b'', _(b'revert commit content to REV instead'), _(b'REV')),
+     (b'', b'revert', False, _(b'discard working directory changes after uncommit')),
+     (b'n', b'note', b'', _(b'store a note on uncommit'), _(b'TEXT')),
      ] + commands.walkopts + commitopts + commitopts2 + commitopts3,
-    _('[OPTION]... [NAME]'))
+    _(b'[OPTION]... [NAME]'))
 def uncommit(ui, repo, *pats, **opts):
     """move changes from parent revision to working directory
 
@@ -482,34 +482,34 @@
 
     _checknotesize(ui, opts)
     _resolveoptions(ui, opts) # process commitopts3
-    interactive = opts.get('interactive')
+    interactive = opts.get(b'interactive')
     wlock = lock = tr = None
     try:
         wlock = repo.wlock()
         lock = repo.lock()
         wctx = repo[None]
         if len(wctx.parents()) <= 0:
-            raise error.Abort(_("cannot uncommit null changeset"))
+            raise error.Abort(_(b"cannot uncommit null changeset"))
         if len(wctx.parents()) > 1:
-            raise error.Abort(_("cannot uncommit while merging"))
-        old = repo['.']
-        rewriteutil.precheck(repo, [repo['.'].rev()], action='uncommit')
+            raise error.Abort(_(b"cannot uncommit while merging"))
+        old = repo[b'.']
+        rewriteutil.precheck(repo, [repo[b'.'].rev()], action=b'uncommit')
         if len(old.parents()) > 1:
-            raise error.Abort(_("cannot uncommit merge changeset"))
+            raise error.Abort(_(b"cannot uncommit merge changeset"))
         oldphase = old.phase()
 
         rev = None
-        if opts.get('rev'):
-            rev = scmutil.revsingle(repo, opts.get('rev'))
+        if opts.get(b'rev'):
+            rev = scmutil.revsingle(repo, opts.get(b'rev'))
             ctx = repo[None]
             if ctx.p1() == rev or ctx.p2() == rev:
-                raise error.Abort(_("cannot uncommit to parent changeset"))
+                raise error.Abort(_(b"cannot uncommit to parent changeset"))
 
         onahead = old.rev() in repo.changelog.headrevs()
         disallowunstable = not obsolete.isenabled(repo,
                                                   obsolete.allowunstableopt)
         if disallowunstable and not onahead:
-            raise error.Abort(_("cannot uncommit in the middle of a stack"))
+            raise error.Abort(_(b"cannot uncommit in the middle of a stack"))
 
         match = scmutil.match(old, pats, opts)
 
@@ -544,42 +544,42 @@
                                   % uipathfn(f), hint=hint)
 
         # Recommit the filtered changeset
-        tr = repo.transaction('uncommit')
+        tr = repo.transaction(b'uncommit')
         if interactive:
-            opts['all'] = True
+            opts[b'all'] = True
             newid = _interactiveuncommit(ui, repo, old, match)
         else:
             newid = None
-            includeorexclude = opts.get('include') or opts.get('exclude')
-            if (pats or includeorexclude or opts.get('all')):
-                if not (opts['message'] or opts['logfile']):
-                    opts['message'] = old.description()
+            includeorexclude = opts.get(b'include') or opts.get(b'exclude')
+            if (pats or includeorexclude or opts.get(b'all')):
+                if not (opts[b'message'] or opts[b'logfile']):
+                    opts[b'message'] = old.description()
                 message = cmdutil.logmessage(ui, opts)
                 newid = _commitfiltered(repo, old, match, target=rev,
-                                        message=message, user=opts.get('user'),
-                                        date=opts.get('date'))
+                                        message=message, user=opts.get(b'user'),
+                                        date=opts.get(b'date'))
             if newid is None:
-                raise error.Abort(_('nothing to uncommit'),
-                                  hint=_("use --all to uncommit all files"))
+                raise error.Abort(_(b'nothing to uncommit'),
+                                  hint=_(b"use --all to uncommit all files"))
 
         # metadata to be stored in obsmarker
         metadata = {}
-        if opts.get('note'):
-            metadata['note'] = opts['note']
+        if opts.get(b'note'):
+            metadata[b'note'] = opts[b'note']
 
         replacements = {old.node(): [newid]}
-        scmutil.cleanupnodes(repo, replacements, operation="uncommit",
+        scmutil.cleanupnodes(repo, replacements, operation=b"uncommit",
                              metadata=metadata)
         phases.retractboundary(repo, tr, oldphase, [newid])
-        if opts.get('revert'):
+        if opts.get(b'revert'):
             hg.updaterepo(repo, newid, True)
         else:
             with repo.dirstate.parentchange():
                 repo.dirstate.setparents(newid, node.nullid)
                 _uncommitdirstate(repo, old, match, interactive)
         if not repo[newid].files():
-            ui.warn(_("new changeset is empty\n"))
-            ui.status(_("(use 'hg prune .' to remove it)\n"))
+            ui.warn(_(b"new changeset is empty\n"))
+            ui.status(_(b"(use 'hg prune .' to remove it)\n"))
         tr.close()
     finally:
         lockmod.release(tr, lock, wlock)
@@ -606,7 +606,7 @@
     fp.seek(0)
     newnode = _patchtocommit(ui, repo, old, fp)
     # creating obs marker temp -> ()
-    obsolete.createmarkers(repo, [(repo[tempnode], ())], operation="uncommit")
+    obsolete.createmarkers(repo, [(repo[tempnode], ())], operation=b"uncommit")
     return newnode
 
 def _createtempcommit(ui, repo, old, match):
@@ -628,20 +628,20 @@
     # to add uncommit as an operation taking care of BC.
     try:
         chunks, opts = cmdutil.recordfilter(repo.ui, originalchunks, match,
-                                            operation='discard')
+                                            operation=b'discard')
     except TypeError:
         # hg <= 4.9 (db72f9f6580e)
         chunks, opts = cmdutil.recordfilter(repo.ui, originalchunks,
-                                            operation='discard')
+                                            operation=b'discard')
     if not chunks:
-        raise error.Abort(_("nothing selected to uncommit"))
+        raise error.Abort(_(b"nothing selected to uncommit"))
     fp = stringio()
     for c in chunks:
         c.write(fp)
 
     fp.seek(0)
     oldnode = node.hex(old.node())[:12]
-    message = 'temporary commit for uncommiting %s' % oldnode
+    message = b'temporary commit for uncommiting %s' % oldnode
     tempnode = _patchtocommit(ui, repo, old, fp, message, oldnode)
     return tempnode
 
@@ -658,14 +658,14 @@
     user = old.user()
     extra = old.extra()
     if extras:
-        extra['uncommit_source'] = extras
+        extra[b'uncommit_source'] = extras
     if not message:
         message = old.description()
     store = patch.filestore()
     try:
         files = set()
         try:
-            patch.patchrepo(ui, repo, pold, store, fp, 1, '',
+            patch.patchrepo(ui, repo, pold, store, fp, 1, b'',
                             files=files, eolmode=None)
         except patch.PatchError as err:
             raise error.Abort(str(err))
@@ -685,13 +685,13 @@
     return newcm
 
 @eh.command(
-    'fold|squash',
-    [('r', 'rev', [], _("revision to fold"), _('REV')),
-     ('', 'exact', None, _("only fold specified revisions")),
-     ('', 'from', None, _("fold revisions linearly to working copy parent")),
-     ('n', 'note', '', _('store a note on fold'), _('TEXT')),
-    ] + commitopts + commitopts2 + commitopts3,
-    _('hg fold [OPTION]... [-r] REV'),
+    b'fold|squash',
+    [(b'r', b'rev', [], _(b"revision to fold"), _(b'REV')),
+     (b'', b'exact', None, _(b"only fold specified revisions")),
+     (b'', b'from', None, _(b"fold revisions linearly to working copy parent")),
+     (b'n', b'note', b'', _(b'store a note on fold'), _(b'TEXT')),
+     ] + commitopts + commitopts2 + commitopts3,
+    _(b'hg fold [OPTION]... [-r] REV'),
     helpbasic=True)
 def fold(ui, repo, *revs, **opts):
     """fold multiple revisions into a single one
@@ -733,35 +733,35 @@
     _checknotesize(ui, opts)
     _resolveoptions(ui, opts)
     revs = list(revs)
-    revs.extend(opts['rev'])
+    revs.extend(opts[b'rev'])
     if not revs:
-        raise error.Abort(_('no revisions specified'))
+        raise error.Abort(_(b'no revisions specified'))
 
     revs = scmutil.revrange(repo, revs)
 
-    if opts['from'] and opts['exact']:
-        raise error.Abort(_('cannot use both --from and --exact'))
-    elif opts['from']:
+    if opts[b'from'] and opts[b'exact']:
+        raise error.Abort(_(b'cannot use both --from and --exact'))
+    elif opts[b'from']:
         # Try to extend given revision starting from the working directory
-        extrevs = repo.revs('(%ld::.) or (.::%ld)', revs, revs)
+        extrevs = repo.revs(b'(%ld::.) or (.::%ld)', revs, revs)
         discardedrevs = [r for r in revs if r not in extrevs]
         if discardedrevs:
-            msg = _("cannot fold non-linear revisions")
-            hint = _("given revisions are unrelated to parent of working"
-                     " directory")
+            msg = _(b"cannot fold non-linear revisions")
+            hint = _(b"given revisions are unrelated to parent of working"
+                     b" directory")
             raise error.Abort(msg, hint=hint)
         revs = extrevs
-    elif opts['exact']:
+    elif opts[b'exact']:
         # Nothing to do; "revs" is already set correctly
         pass
     else:
-        raise error.Abort(_('must specify either --from or --exact'))
+        raise error.Abort(_(b'must specify either --from or --exact'))
 
     if not revs:
-        raise error.Abort(_('specified revisions evaluate to an empty set'),
-                          hint=_('use different revision arguments'))
+        raise error.Abort(_(b'specified revisions evaluate to an empty set'),
+                          hint=_(b'use different revision arguments'))
     elif len(revs) == 1:
-        ui.write_err(_('single revision specified, nothing to fold\n'))
+        ui.write_err(_(b'single revision specified, nothing to fold\n'))
         return 1
 
     # Sort so combined commit message of `hg fold --exact -r . -r .^` is
@@ -775,24 +775,24 @@
 
         root, head = rewriteutil.foldcheck(repo, revs)
 
-        tr = repo.transaction('fold')
+        tr = repo.transaction(b'fold')
         try:
             commitopts = opts.copy()
             allctx = [repo[r] for r in revs]
             targetphase = max(c.phase() for c in allctx)
 
-            if commitopts.get('message') or commitopts.get('logfile'):
-                commitopts['edit'] = False
+            if commitopts.get(b'message') or commitopts.get(b'logfile'):
+                commitopts[b'edit'] = False
             else:
-                msgs = ["HG: This is a fold of %d changesets." % len(allctx)]
-                msgs += ["HG: Commit message of changeset %s.\n\n%s\n" %
+                msgs = [b"HG: This is a fold of %d changesets." % len(allctx)]
+                msgs += [b"HG: Commit message of changeset %s.\n\n%s\n" %
                          (c.rev(), c.description()) for c in allctx]
-                commitopts['message'] = "\n".join(msgs)
-                commitopts['edit'] = True
+                commitopts[b'message'] = b"\n".join(msgs)
+                commitopts[b'edit'] = True
 
             metadata = {}
-            if opts.get('note'):
-                metadata['note'] = opts['note']
+            if opts.get(b'note'):
+                metadata[b'note'] = opts[b'note']
 
             newid, unusedvariable = rewriteutil.rewrite(repo, root, allctx,
                                                         head,
@@ -801,24 +801,24 @@
                                                         commitopts=commitopts)
             phases.retractboundary(repo, tr, targetphase, [newid])
             replacements = {ctx.node(): [newid] for ctx in allctx}
-            scmutil.cleanupnodes(repo, replacements, operation="fold",
+            scmutil.cleanupnodes(repo, replacements, operation=b"fold",
                                  metadata=metadata)
             tr.close()
         finally:
             tr.release()
-        ui.status('%i changesets folded\n' % len(revs))
-        if repo['.'].rev() in revs:
+        ui.status(b'%i changesets folded\n' % len(revs))
+        if repo[b'.'].rev() in revs:
             hg.update(repo, newid)
     finally:
         lockmod.release(lock, wlock)
 
 @eh.command(
-    'metaedit',
-    [('r', 'rev', [], _("revision to edit"), _('REV')),
-     ('', 'fold', None, _("also fold specified revisions into one")),
-     ('n', 'note', '', _('store a note on metaedit'), _('TEXT')),
-    ] + commitopts + commitopts2 + commitopts3,
-    _('hg metaedit [OPTION]... [-r] [REV]'))
+    b'metaedit',
+    [(b'r', b'rev', [], _(b"revision to edit"), _(b'REV')),
+     (b'', b'fold', None, _(b"also fold specified revisions into one")),
+     (b'n', b'note', b'', _(b'store a note on metaedit'), _(b'TEXT')),
+     ] + commitopts + commitopts2 + commitopts3,
+    _(b'hg metaedit [OPTION]... [-r] [REV]'))
 def metaedit(ui, repo, *revs, **opts):
     """edit commit information
 
@@ -851,15 +851,15 @@
     _checknotesize(ui, opts)
     _resolveoptions(ui, opts)
     revs = list(revs)
-    revs.extend(opts['rev'])
+    revs.extend(opts[b'rev'])
     if not revs:
-        if opts['fold']:
-            raise error.Abort(_('revisions must be specified with --fold'))
-        revs = ['.']
+        if opts[b'fold']:
+            raise error.Abort(_(b'revisions must be specified with --fold'))
+        revs = [b'.']
 
     with repo.wlock(), repo.lock():
         revs = scmutil.revrange(repo, revs)
-        if not opts['fold'] and len(revs) > 1:
+        if not opts[b'fold'] and len(revs) > 1:
             # TODO: handle multiple revisions. This is somewhat tricky because
             # if we want to edit a series of commits:
             #
@@ -868,45 +868,45 @@
             # we need to rewrite a first, then directly rewrite b on top of the
             # new a, then rewrite c on top of the new b. So we need to handle
             # revisions in topological order.
-            raise error.Abort(_('editing multiple revisions without --fold is '
-                                'not currently supported'))
+            raise error.Abort(_(b'editing multiple revisions without --fold is '
+                                b'not currently supported'))
 
-        if opts['fold']:
+        if opts[b'fold']:
             root, head = rewriteutil.foldcheck(repo, revs)
         else:
-            if repo.revs("%ld and public()", revs):
-                raise error.Abort(_('cannot edit commit information for public '
-                                    'revisions'))
+            if repo.revs(b"%ld and public()", revs):
+                raise error.Abort(_(b'cannot edit commit information for public '
+                                    b'revisions'))
             newunstable = rewriteutil.disallowednewunstable(repo, revs)
             if newunstable:
-                msg = _('cannot edit commit information in the middle'
-                        ' of a stack')
-                hint = _('%s will become unstable and new unstable changes'
-                         ' are not allowed')
+                msg = _(b'cannot edit commit information in the middle'
+                        b' of a stack')
+                hint = _(b'%s will become unstable and new unstable changes'
+                         b' are not allowed')
                 hint %= repo[newunstable.first()]
                 raise error.Abort(msg, hint=hint)
             root = head = repo[revs.first()]
 
         wctx = repo[None]
         p1 = wctx.p1()
-        tr = repo.transaction('metaedit')
+        tr = repo.transaction(b'metaedit')
         newp1 = None
         try:
             commitopts = opts.copy()
             allctx = [repo[r] for r in revs]
             targetphase = max(c.phase() for c in allctx)
 
-            if commitopts.get('message') or commitopts.get('logfile'):
-                commitopts['edit'] = False
+            if commitopts.get(b'message') or commitopts.get(b'logfile'):
+                commitopts[b'edit'] = False
             else:
-                if opts['fold']:
-                    msgs = ["HG: This is a fold of %d changesets." % len(allctx)]
-                    msgs += ["HG: Commit message of changeset %s.\n\n%s\n" %
+                if opts[b'fold']:
+                    msgs = [b"HG: This is a fold of %d changesets." % len(allctx)]
+                    msgs += [b"HG: Commit message of changeset %s.\n\n%s\n" %
                              (c.rev(), c.description()) for c in allctx]
                 else:
                     msgs = [head.description()]
-                commitopts['message'] = "\n".join(msgs)
-                commitopts['edit'] = True
+                commitopts[b'message'] = b"\n".join(msgs)
+                commitopts[b'edit'] = True
 
             # TODO: if the author and message are the same, don't create a new
             # hash. Right now we create a new hash because the date can be
@@ -920,58 +920,58 @@
                     newp1 = newid
                 # metadata to be stored on obsmarker
                 metadata = {}
-                if opts.get('note'):
-                    metadata['note'] = opts['note']
+                if opts.get(b'note'):
+                    metadata[b'note'] = opts[b'note']
 
                 phases.retractboundary(repo, tr, targetphase, [newid])
                 obsolete.createmarkers(repo, [(ctx, (repo[newid],))
                                               for ctx in allctx],
-                                       metadata=metadata, operation="metaedit")
+                                       metadata=metadata, operation=b"metaedit")
             else:
-                ui.status(_("nothing changed\n"))
+                ui.status(_(b"nothing changed\n"))
             tr.close()
         finally:
             tr.release()
 
-        if opts['fold']:
-            ui.status('%i changesets folded\n' % len(revs))
+        if opts[b'fold']:
+            ui.status(b'%i changesets folded\n' % len(revs))
         if newp1 is not None:
             hg.update(repo, newp1)
 
 metadataopts = [
-    ('d', 'date', '',
-     _('record the specified date in metadata'), _('DATE')),
-    ('u', 'user', '',
-     _('record the specified user in metadata'), _('USER')),
+    (b'd', b'date', b'',
+     _(b'record the specified date in metadata'), _(b'DATE')),
+    (b'u', b'user', b'',
+     _(b'record the specified user in metadata'), _(b'USER')),
 ]
 
 def _getmetadata(**opts):
     metadata = {}
-    date = opts.get('date')
-    user = opts.get('user')
+    date = opts.get(b'date')
+    user = opts.get(b'user')
     if date:
-        metadata['date'] = '%i %i' % compat.parsedate(date)
+        metadata[b'date'] = b'%i %i' % compat.parsedate(date)
     if user:
-        metadata['user'] = user
+        metadata[b'user'] = user
     return metadata
 
 @eh.command(
-    'prune|obsolete',
-    [('n', 'new', [], _("successor changeset (DEPRECATED)")),
-     ('s', 'succ', [], _("successor changeset"), _('REV')),
-     ('r', 'rev', [], _("revisions to prune"), _('REV')),
-     ('k', 'keep', None, _("does not modify working copy during prune")),
-     ('n', 'note', '', _('store a note on prune'), _('TEXT')),
-     ('', 'pair', False, _("record a pairing, such as a rebase or divergence resolution "
-                           "(pairing multiple precursors to multiple successors)")),
-     ('', 'biject', False, _("alias to --pair (DEPRECATED)")),
-     ('', 'fold', False,
-      _("record a fold (multiple precursors, one successors)")),
-     ('', 'split', False,
-      _("record a split (on precursor, multiple successors)")),
-     ('B', 'bookmark', [], _("remove revs only reachable from given"
-                             " bookmark"), _('BOOKMARK'))] + metadataopts,
-    _('[OPTION] [-r] REV...'),
+    b'prune|obsolete',
+    [(b'n', b'new', [], _(b"successor changeset (DEPRECATED)")),
+     (b's', b'succ', [], _(b"successor changeset"), _(b'REV')),
+     (b'r', b'rev', [], _(b"revisions to prune"), _(b'REV')),
+     (b'k', b'keep', None, _(b"does not modify working copy during prune")),
+     (b'n', b'note', b'', _(b'store a note on prune'), _(b'TEXT')),
+     (b'', b'pair', False, _(b"record a pairing, such as a rebase or divergence resolution "
+                             b"(pairing multiple precursors to multiple successors)")),
+     (b'', b'biject', False, _(b"alias to --pair (DEPRECATED)")),
+     (b'', b'fold', False,
+      _(b"record a fold (multiple precursors, one successors)")),
+     (b'', b'split', False,
+      _(b"record a split (on precursor, multiple successors)")),
+     (b'B', b'bookmark', [], _(b"remove revs only reachable from given"
+                               b" bookmark"), _(b'BOOKMARK'))] + metadataopts,
+    _(b'[OPTION] [-r] REV...'),
     helpbasic=True)
 # XXX -U  --noupdate option to prevent wc update and or bookmarks update ?
 def cmdprune(ui, repo, *revs, **opts):
@@ -1000,17 +1000,17 @@
     else does edits history without obsolescence enabled.
     """
     _checknotesize(ui, opts)
-    revs = scmutil.revrange(repo, list(revs) + opts.get('rev'))
-    succs = opts['new'] + opts['succ']
-    bookmarks = set(opts.get('bookmark'))
+    revs = scmutil.revrange(repo, list(revs) + opts.get(b'rev'))
+    succs = opts[b'new'] + opts[b'succ']
+    bookmarks = set(opts.get(b'bookmark'))
     metadata = _getmetadata(**opts)
-    biject = opts.get('pair') or opts.get('biject')
-    fold = opts.get('fold')
-    split = opts.get('split')
+    biject = opts.get(b'pair') or opts.get(b'biject')
+    fold = opts.get(b'fold')
+    split = opts.get(b'split')
 
-    options = [o for o in ('pair', 'fold', 'split') if opts.get(o)]
+    options = [o for o in (b'pair', b'fold', b'split') if opts.get(o)]
     if 1 < len(options):
-        raise error.Abort(_("can only specify one of %s") % ', '.join(options))
+        raise error.Abort(_(b"can only specify one of %s") % b', '.join(options))
 
     if bookmarks:
         reachablefrombookmark = rewriteutil.reachablefrombookmark
@@ -1020,14 +1020,14 @@
             rewriteutil.deletebookmark(repo, repomarks, bookmarks)
 
     if not revs:
-        raise error.Abort(_('nothing to prune'))
+        raise error.Abort(_(b'nothing to prune'))
 
     wlock = lock = tr = None
     try:
         wlock = repo.wlock()
         lock = repo.lock()
-        rewriteutil.precheck(repo, revs, 'prune')
-        tr = repo.transaction('prune')
+        rewriteutil.precheck(repo, revs, b'prune')
+        tr = repo.transaction(b'prune')
         # defines pruned changesets
         precs = []
         revs.sort()
@@ -1035,33 +1035,33 @@
             cp = repo[p]
             precs.append(cp)
         if not precs:
-            raise error.Abort('nothing to prune')
+            raise error.Abort(b'nothing to prune')
 
         # defines successors changesets
         sucs = scmutil.revrange(repo, succs)
         sucs.sort()
         sucs = tuple(repo[n] for n in sucs)
         if not biject and len(sucs) > 1 and len(precs) > 1:
-            msg = "Can't use multiple successors for multiple precursors"
-            hint = _("use --pair to mark a series as a replacement"
-                     " for another")
+            msg = b"Can't use multiple successors for multiple precursors"
+            hint = _(b"use --pair to mark a series as a replacement"
+                     b" for another")
             raise error.Abort(msg, hint=hint)
         elif biject and len(sucs) != len(precs):
-            msg = "Can't use %d successors for %d precursors" \
+            msg = b"Can't use %d successors for %d precursors"\
                 % (len(sucs), len(precs))
             raise error.Abort(msg)
         elif (len(precs) == 1 and len(sucs) > 1) and not split:
-            msg = "please add --split if you want to do a split"
+            msg = b"please add --split if you want to do a split"
             raise error.Abort(msg)
         elif len(sucs) == 1 and len(precs) > 1 and not fold:
-            msg = "please add --fold if you want to do a fold"
+            msg = b"please add --fold if you want to do a fold"
             raise error.Abort(msg)
         elif biject:
             replacements = {p.node(): [s.node()] for p, s in zip(precs, sucs)}
         else:
             replacements = {p.node(): [s.node() for s in sucs] for p in precs}
 
-        wdp = repo['.']
+        wdp = repo[b'.']
 
         if len(sucs) == 1 and len(precs) == 1 and wdp in precs:
             # '.' killed, so update to the successor
@@ -1074,14 +1074,14 @@
                 newnode = newnode.parents()[0]
 
         if newnode.node() != wdp.node():
-            if opts.get('keep', False):
+            if opts.get(b'keep', False):
                 # This is largely the same as the implementation in
                 # strip.stripcmd(). We might want to refactor this somewhere
                 # common at some point.
 
                 # only reset the dirstate for files that would actually change
                 # between the working context and uctx
-                descendantrevs = repo.revs("%d::." % newnode.rev())
+                descendantrevs = repo.revs(b"%d::." % newnode.rev())
                 changedfiles = []
                 for rev in descendantrevs:
                     # blindly reset the files, regardless of what actually
@@ -1090,7 +1090,7 @@
 
                 # reset files that only changed in the dirstate too
                 dirstate = repo.dirstate
-                dirchanges = [f for f in dirstate if dirstate[f] != 'n']
+                dirchanges = [f for f in dirstate if dirstate[f] != b'n']
                 changedfiles.extend(dirchanges)
                 repo.dirstate.rebuild(newnode.node(), newnode.manifest(),
                                       changedfiles)
@@ -1106,8 +1106,8 @@
                     bmchanges = [(bookactive, newnode.node())]
                     repo._bookmarks.applychanges(repo, tr, bmchanges)
                 commands.update(ui, repo, newnode.hex())
-                ui.status(_('working directory is now at %s\n')
-                          % ui.label(str(newnode), 'evolve.node'))
+                ui.status(_(b'working directory is now at %s\n')
+                          % ui.label(str(newnode), b'evolve.node'))
                 if movebookmark:
                     bookmarksmod.activate(repo, bookactive)
 
@@ -1116,12 +1116,12 @@
             rewriteutil.deletebookmark(repo, repomarks, bookmarks)
 
         # store note in metadata
-        if opts.get('note'):
-            metadata['note'] = opts['note']
+        if opts.get(b'note'):
+            metadata[b'note'] = opts[b'note']
 
         precrevs = (precursor.rev() for precursor in precs)
         moves = {}
-        for ctx in repo.unfiltered().set('bookmark() and %ld', precrevs):
+        for ctx in repo.unfiltered().set(b'bookmark() and %ld', precrevs):
             # used to be:
             #
             #   ldest = list(repo.set('max((::%d) - obsolete())', ctx))
@@ -1134,23 +1134,23 @@
                 if not dest.obsolete() and dest.node() not in replacements:
                     moves[ctx.node()] = dest.node()
                     break
-        scmutil.cleanupnodes(repo, replacements, operation="prune", moves=moves,
+        scmutil.cleanupnodes(repo, replacements, operation=b"prune", moves=moves,
                              metadata=metadata)
 
         # informs that changeset have been pruned
-        ui.status(_('%i changesets pruned\n') % len(precs))
+        ui.status(_(b'%i changesets pruned\n') % len(precs))
 
         tr.close()
     finally:
         lockmod.release(tr, lock, wlock)
 
 @eh.command(
-    'split',
-    [('i', 'interactive', True, _('use interactive mode')),
-     ('r', 'rev', [], _("revision to split"), _('REV')),
-     ('n', 'note', '', _("store a note on split"), _('TEXT')),
-    ] + commitopts + commitopts2 + commitopts3,
-    _('hg split [OPTION] [-r REV] [FILES]'),
+    b'split',
+    [(b'i', b'interactive', True, _(b'use interactive mode')),
+     (b'r', b'rev', [], _(b"revision to split"), _(b'REV')),
+     (b'n', b'note', b'', _(b"store a note on split"), _(b'TEXT')),
+     ] + commitopts + commitopts2 + commitopts3,
+    _(b'hg split [OPTION] [-r REV] [FILES]'),
     helpbasic=True)
 def cmdsplit(ui, repo, *pats, **opts):
     """split a changeset into smaller changesets
@@ -1168,17 +1168,17 @@
     _resolveoptions(ui, opts)
     tr = wlock = lock = None
     newcommits = []
-    iselect = opts.pop('interactive')
+    iselect = opts.pop(b'interactive')
 
-    revs = opts.get('rev') or '.'
+    revs = opts.get(b'rev') or b'.'
     if not revs:
-        revarg = '.'
+        revarg = b'.'
     elif len(revs) == 1:
         revarg = revs[0]
     else:
         # XXX --rev often accept multiple value, it seems safer to explicitly
         # complains here instead of just taking the last value.
-        raise error.Abort(_('more than one revset is given'))
+        raise error.Abort(_(b'more than one revset is given'))
 
     # Save the current branch to restore it in the end
     savedbranch = repo.dirstate.branch()
@@ -1189,18 +1189,18 @@
         ctx = scmutil.revsingle(repo, revarg)
         rev = ctx.rev()
         cmdutil.bailifchanged(repo)
-        rewriteutil.precheck(repo, [rev], action='split')
-        tr = repo.transaction('split')
+        rewriteutil.precheck(repo, [rev], action=b'split')
+        tr = repo.transaction(b'split')
         # make sure we respect the phase while splitting
-        overrides = {('phases', 'new-commit'): ctx.phase()}
+        overrides = {(b'phases', b'new-commit'): ctx.phase()}
 
         if len(ctx.parents()) > 1:
-            raise error.Abort(_("cannot split merge commits"))
+            raise error.Abort(_(b"cannot split merge commits"))
         prev = ctx.p1()
         bmupdate = rewriteutil.bookmarksupdater(repo, ctx.node(), tr)
         bookactive = repo._activebookmark
         if bookactive is not None:
-            repo.ui.status(_("(leaving bookmark %s)\n") % repo._activebookmark)
+            repo.ui.status(_(b"(leaving bookmark %s)\n") % repo._activebookmark)
         bookmarksmod.deactivate(repo)
 
         # Prepare the working directory
@@ -1209,13 +1209,13 @@
         def haschanges(matcher=None):
             modified, added, removed, deleted = repo.status(match=matcher)[:4]
             return modified or added or removed or deleted
-        msg = ("HG: This is the original pre-split commit message. "
-               "Edit it as appropriate.\n\n")
+        msg = (b"HG: This is the original pre-split commit message. "
+               b"Edit it as appropriate.\n\n")
         msg += ctx.description()
-        opts['message'] = msg
-        opts['edit'] = True
-        if not opts['user']:
-            opts['user'] = ctx.user()
+        opts[b'message'] = msg
+        opts[b'edit'] = True
+        if not opts[b'user']:
+            opts[b'user'] = ctx.user()
 
         # Set the right branch
         # XXX-TODO: Find a way to set the branch without altering the dirstate
@@ -1231,21 +1231,21 @@
 
             if haschanges(matcher):
                 if iselect:
-                    with repo.ui.configoverride(overrides, 'split'):
-                        cmdutil.dorecord(ui, repo, commands.commit, 'commit',
+                    with repo.ui.configoverride(overrides, b'split'):
+                        cmdutil.dorecord(ui, repo, commands.commit, b'commit',
                                          False, cmdutil.recordfilter, *pats,
                                          **opts)
                     # TODO: Does no seem like the best way to do this
                     # We should make dorecord return the newly created commit
-                    newcommits.append(repo['.'])
+                    newcommits.append(repo[b'.'])
                 elif not pats:
-                    msg = _("no files of directories specified")
-                    hint = _("do you want --interactive")
+                    msg = _(b"no files of directories specified")
+                    hint = _(b"do you want --interactive")
                     raise error.Abort(msg, hint=hint)
                 else:
-                    with repo.ui.configoverride(overrides, 'split'):
+                    with repo.ui.configoverride(overrides, b'split'):
                         commands.commit(ui, repo, *pats, **opts)
-                    newcommits.append(repo['.'])
+                    newcommits.append(repo[b'.'])
             if pats:
                 # refresh the wctx used for the matcher
                 matcher = scmutil.match(repo[None], pats)
@@ -1255,20 +1255,20 @@
             if haschanges(matcher):
                 nextaction = None
                 while nextaction is None:
-                    nextaction = ui.prompt('continue splitting? [Ycdq?]', default='y')
-                    if nextaction == 'c':
-                        with repo.ui.configoverride(overrides, 'split'):
+                    nextaction = ui.prompt(b'continue splitting? [Ycdq?]', default=b'y')
+                    if nextaction == b'c':
+                        with repo.ui.configoverride(overrides, b'split'):
                             commands.commit(ui, repo, **opts)
-                        newcommits.append(repo['.'])
+                        newcommits.append(repo[b'.'])
                         break
-                    elif nextaction == 'q':
-                        raise error.Abort(_('user quit'))
-                    elif nextaction == 'd':
+                    elif nextaction == b'q':
+                        raise error.Abort(_(b'user quit'))
+                    elif nextaction == b'd':
                         # TODO: We should offer a way for the user to confirm
                         # what is the remaining changes, either via a separate
                         # diff action or by showing the remaining and
                         # prompting for confirmation
-                        ui.status(_('discarding remaining changes\n'))
+                        ui.status(_(b'discarding remaining changes\n'))
                         target = newcommits[0]
                         if pats:
                             status = repo.status(match=matcher)[:4]
@@ -1281,34 +1281,34 @@
                         else:
                             cmdutil.revert(ui, repo, repo[target],
                                            (target, node.nullid), all=True)
-                    elif nextaction == '?':
+                    elif nextaction == b'?':
                         nextaction = None
-                        ui.write(_("y - yes, continue selection\n"))
-                        ui.write(_("c - commit, select all remaining changes\n"))
-                        ui.write(_("d - discard, discard remaining changes\n"))
-                        ui.write(_("q - quit, abort the split\n"))
-                        ui.write(_("? - ?, display help\n"))
+                        ui.write(_(b"y - yes, continue selection\n"))
+                        ui.write(_(b"c - commit, select all remaining changes\n"))
+                        ui.write(_(b"d - discard, discard remaining changes\n"))
+                        ui.write(_(b"q - quit, abort the split\n"))
+                        ui.write(_(b"? - ?, display help\n"))
                 else:
                     continue
                 break # propagate the previous break
             else:
-                ui.status(_("no more change to split\n"))
+                ui.status(_(b"no more change to split\n"))
                 if haschanges():
                     # XXX: Should we show a message for informing the user
                     # that we create another commit with remaining changes?
-                    with repo.ui.configoverride(overrides, 'split'):
+                    with repo.ui.configoverride(overrides, b'split'):
                         commands.commit(ui, repo, **opts)
-                    newcommits.append(repo['.'])
+                    newcommits.append(repo[b'.'])
         if newcommits:
             tip = repo[newcommits[-1]]
             bmupdate(tip.node())
             if bookactive is not None:
                 bookmarksmod.activate(repo, bookactive)
             metadata = {}
-            if opts.get('note'):
-                metadata['note'] = opts['note']
+            if opts.get(b'note'):
+                metadata[b'note'] = opts[b'note']
             obsolete.createmarkers(repo, [(repo[rev], newcommits)],
-                                   metadata=metadata, operation="split")
+                                   metadata=metadata, operation=b"split")
         tr.close()
     finally:
         # Restore the old branch
@@ -1317,16 +1317,16 @@
         lockmod.release(tr, lock, wlock)
 
 @eh.command(
-    'touch',
-    [('r', 'rev', [], _('revision to update'), _('REV')),
-     ('n', 'note', '', _('store a note on touch'), _('TEXT')),
-     ('D', 'duplicate', False,
-      'do not mark the new revision as successor of the old one'),
-     ('A', 'allowdivergence', False,
-      'mark the new revision as successor of the old one potentially creating '
-      'divergence')],
+    b'touch',
+    [(b'r', b'rev', [], _(b'revision to update'), _(b'REV')),
+     (b'n', b'note', b'', _(b'store a note on touch'), _(b'TEXT')),
+     (b'D', b'duplicate', False,
+      b'do not mark the new revision as successor of the old one'),
+     (b'A', b'allowdivergence', False,
+      b'mark the new revision as successor of the old one potentially creating '
+      b'divergence')],
     # allow to choose the seed ?
-    _('[-r] revs'))
+    _(b'[-r] revs'))
 def touch(ui, repo, *revs, **opts):
     """create successors identical to their predecessors but the changeset ID
 
@@ -1334,33 +1334,33 @@
     """
     _checknotesize(ui, opts)
     revs = list(revs)
-    revs.extend(opts['rev'])
+    revs.extend(opts[b'rev'])
     if not revs:
-        revs = ['.']
+        revs = [b'.']
     revs = scmutil.revrange(repo, revs)
     if not revs:
-        ui.write_err('no revision to touch\n')
+        ui.write_err(b'no revision to touch\n')
         return 1
 
-    duplicate = opts['duplicate']
+    duplicate = opts[b'duplicate']
     if not duplicate:
-        rewriteutil.precheck(repo, revs, 'touch')
+        rewriteutil.precheck(repo, revs, b'touch')
     tmpl = utility.shorttemplate
-    displayer = compat.changesetdisplayer(ui, repo, {'template': tmpl})
+    displayer = compat.changesetdisplayer(ui, repo, {b'template': tmpl})
     with repo.wlock(), repo.lock():
-        tr = repo.transaction('touch')
+        tr = repo.transaction(b'touch')
         with util.acceptintervention(tr):
             touchnodes(ui, repo, revs, displayer, **opts)
 
 def touchnodes(ui, repo, revs, displayer, **opts):
-    duplicate = opts['duplicate']
-    allowdivergence = opts['allowdivergence']
+    duplicate = opts[b'duplicate']
+    allowdivergence = opts[b'allowdivergence']
     revs.sort() # ensure parent are run first
     newmapping = {}
     for r in revs:
         ctx = repo[r]
         extra = ctx.extra().copy()
-        extra['__touch-noise__'] = random.randint(0, 0xffffffff)
+        extra[b'__touch-noise__'] = random.randint(0, 0xffffffff)
         # search for touched parent
         p1 = ctx.p1().node()
         p2 = ctx.p2().node()
@@ -1381,17 +1381,17 @@
             else:
                 displayer.show(ctx)
                 index = ui.promptchoice(
-                    _("reviving this changeset will create divergence"
-                      " unless you make a duplicate.\n(a)llow divergence or"
-                      " (d)uplicate the changeset? $$ &Allowdivergence $$ "
-                      "&Duplicate"), 0)
-                choice = ['allowdivergence', 'duplicate'][index]
-                if choice == 'allowdivergence':
+                    _(b"reviving this changeset will create divergence"
+                      b" unless you make a duplicate.\n(a)llow divergence or"
+                      b" (d)uplicate the changeset? $$ &Allowdivergence $$ "
+                      b"&Duplicate"), 0)
+                choice = [b'allowdivergence', b'duplicate'][index]
+                if choice == b'allowdivergence':
                     duplicate = False
                 else:
                     duplicate = True
 
-        extradict = {'extra': extra}
+        extradict = {b'extra': extra}
         new, unusedvariable = rewriteutil.rewrite(repo, ctx, [], ctx,
                                                   [p1, p2],
                                                   commitopts=extradict)
@@ -1400,10 +1400,10 @@
 
         if not duplicate:
             metadata = {}
-            if opts.get('note'):
-                metadata['note'] = opts['note']
+            if opts.get(b'note'):
+                metadata[b'note'] = opts[b'note']
             obsolete.createmarkers(repo, [(ctx, (repo[new],))],
-                                   metadata=metadata, operation="touch")
+                                   metadata=metadata, operation=b"touch")
         tr = repo.currenttransaction()
         phases.retractboundary(repo, tr, ctx.phase(), [new])
         if ctx in repo[None].parents():
@@ -1411,80 +1411,80 @@
                 repo.dirstate.setparents(new, node.nullid)
 
 @eh.command(
-    'pick|grab',
-    [('r', 'rev', '', _('revision to pick'), _('REV')),
-     ('c', 'continue', False, 'continue interrupted pick'),
-     ('a', 'abort', False, 'abort interrupted pick'),
-    ] + mergetoolopts,
-    _('[-r] rev'))
+    b'pick|grab',
+    [(b'r', b'rev', b'', _(b'revision to pick'), _(b'REV')),
+     (b'c', b'continue', False, b'continue interrupted pick'),
+     (b'a', b'abort', False, b'abort interrupted pick'),
+     ] + mergetoolopts,
+    _(b'[-r] rev'))
 def cmdpick(ui, repo, *revs, **opts):
     """move a commit on the top of working directory parent and updates to it."""
 
-    cont = opts.get('continue')
-    abort = opts.get('abort')
+    cont = opts.get(b'continue')
+    abort = opts.get(b'abort')
 
     if cont and abort:
-        raise error.Abort(_("cannot specify both --continue and --abort"))
+        raise error.Abort(_(b"cannot specify both --continue and --abort"))
 
     revs = list(revs)
-    if opts.get('rev'):
-        revs.append(opts['rev'])
+    if opts.get(b'rev'):
+        revs.append(opts[b'rev'])
 
-    overrides = {('ui', 'forcemerge'): opts.get('tool', '')}
-    with repo.wlock(), repo.lock(), repo.transaction('pick'), ui.configoverride(overrides, 'pick'):
-        pickstate = state.cmdstate(repo, path='pickstate')
-        pctx = repo['.']
+    overrides = {(b'ui', b'forcemerge'): opts.get(b'tool', b'')}
+    with repo.wlock(), repo.lock(), repo.transaction(b'pick'), ui.configoverride(overrides, b'pick'):
+        pickstate = state.cmdstate(repo, path=b'pickstate')
+        pctx = repo[b'.']
 
         if not cont and not abort:
             cmdutil.bailifchanged(repo)
             revs = scmutil.revrange(repo, revs)
             if len(revs) > 1:
-                raise error.Abort(_("specify just one revision"))
+                raise error.Abort(_(b"specify just one revision"))
             elif not revs:
-                raise error.Abort(_("empty revision set"))
+                raise error.Abort(_(b"empty revision set"))
 
             origctx = repo[revs.first()]
 
             if origctx in pctx.ancestors() or origctx.node() == pctx.node():
-                raise error.Abort(_("cannot pick an ancestor revision"))
+                raise error.Abort(_(b"cannot pick an ancestor revision"))
 
-            rewriteutil.precheck(repo, [origctx.rev()], 'pick')
+            rewriteutil.precheck(repo, [origctx.rev()], b'pick')
 
-            ui.status(_('picking %d:%s "%s"\n') %
+            ui.status(_(b'picking %d:%s "%s"\n') %
                       (origctx.rev(), origctx,
-                       origctx.description().split("\n", 1)[0]))
-            stats = merge.graft(repo, origctx, origctx.p1(), ['local',
-                                                              'destination'])
+                       origctx.description().split(b"\n", 1)[0]))
+            stats = merge.graft(repo, origctx, origctx.p1(), [b'local',
+                                                              b'destination'])
             if compat.hasconflict(stats):
-                pickstate.addopts({'orignode': origctx.node(),
-                                   'oldpctx': pctx.node()})
+                pickstate.addopts({b'orignode': origctx.node(),
+                                   b'oldpctx': pctx.node()})
                 pickstate.save()
-                raise error.InterventionRequired(_("unresolved merge conflicts"
-                                                   " (see hg help resolve)"))
+                raise error.InterventionRequired(_(b"unresolved merge conflicts"
+                                                   b" (see hg help resolve)"))
 
         elif abort:
             if not pickstate:
-                raise error.Abort(_("no interrupted pick state exists"))
+                raise error.Abort(_(b"no interrupted pick state exists"))
             pickstate.load()
-            pctxnode = pickstate['oldpctx']
-            ui.status(_("aborting pick, updating to %s\n") %
+            pctxnode = pickstate[b'oldpctx']
+            ui.status(_(b"aborting pick, updating to %s\n") %
                       node.hex(pctxnode)[:12])
             hg.updaterepo(repo, pctxnode, True)
             return 0
 
         else:
             if revs:
-                raise error.Abort(_("cannot specify both --continue and "
-                                    "revision"))
+                raise error.Abort(_(b"cannot specify both --continue and "
+                                    b"revision"))
             if not pickstate:
-                raise error.Abort(_("no interrupted pick state exists"))
+                raise error.Abort(_(b"no interrupted pick state exists"))
 
             pickstate.load()
-            orignode = pickstate['orignode']
+            orignode = pickstate[b'orignode']
             origctx = repo[orignode]
 
-        overrides = {('phases', 'new-commit'): origctx.phase()}
-        with repo.ui.configoverride(overrides, 'pick'):
+        overrides = {(b'phases', b'new-commit'): origctx.phase()}
+        with repo.ui.configoverride(overrides, b'pick'):
             newnode = repo.commit(text=origctx.description(),
                                   user=origctx.user(),
                                   date=origctx.date(), extra=origctx.extra())
@@ -1494,10 +1494,10 @@
             pickstate.delete()
         newctx = repo[newnode] if newnode else pctx
         replacements = {origctx.node(): [newctx.node()]}
-        scmutil.cleanupnodes(repo, replacements, operation="pick")
+        scmutil.cleanupnodes(repo, replacements, operation=b"pick")
 
         if newnode is None:
-            ui.warn(_("note: picking %d:%s created no changes to commit\n") %
+            ui.warn(_(b"note: picking %d:%s created no changes to commit\n") %
                     (origctx.rev(), origctx))
             return 0
 
diff --git a/hgext3rd/evolve/compat.py b/hgext3rd/evolve/compat.py
--- a/hgext3rd/evolve/compat.py
+++ b/hgext3rd/evolve/compat.py
@@ -48,29 +48,29 @@
     # check
     if not obsutil:
         return False
-    return util.safehasattr(obsutil, 'obsfateprinter')
+    return util.safehasattr(obsutil, b'obsfateprinter')
 
 # Evolution renaming compat
 
 TROUBLES = {
-    'ORPHAN': 'orphan',
-    'CONTENTDIVERGENT': 'content-divergent',
-    'PHASEDIVERGENT': 'phase-divergent',
+    b'ORPHAN': b'orphan',
+    b'CONTENTDIVERGENT': b'content-divergent',
+    b'PHASEDIVERGENT': b'phase-divergent',
 }
 
-if util.safehasattr(uimod.ui, 'makeprogress'):
-    def progress(ui, topic, pos, item="", unit="", total=None):
+if util.safehasattr(uimod.ui, b'makeprogress'):
+    def progress(ui, topic, pos, item=b"", unit=b"", total=None):
         progress = ui.makeprogress(topic, unit, total)
         if pos is not None:
             progress.update(pos, item=item)
         else:
             progress.complete()
 else:
-    def progress(ui, topic, pos, item="", unit="", total=None):
+    def progress(ui, topic, pos, item=b"", unit=b"", total=None):
         ui.progress(topic, pos, item, unit, total)
 
 # XXX: Better detection of property cache
-if 'predecessors' not in dir(obsolete.obsstore):
+if b'predecessors' not in dir(obsolete.obsstore):
     @property
     def predecessors(self):
         return self.precursors
@@ -81,33 +81,33 @@
     # XXX Would it be better at the module level?
     varnames = context.memfilectx.__init__.__code__.co_varnames
 
-    if "copysource" in varnames:
+    if b"copysource" in varnames:
         mctx = context.memfilectx(repo, ctx, fctx.path(), fctx.data(),
-                                  islink='l' in flags,
-                                  isexec='x' in flags,
+                                  islink=b'l' in flags,
+                                  isexec=b'x' in flags,
                                   copysource=copied.get(path))
     # compat with hg <- 4.9
-    elif varnames[2] == "changectx":
+    elif varnames[2] == b"changectx":
         mctx = context.memfilectx(repo, ctx, fctx.path(), fctx.data(),
-                                  islink='l' in flags,
-                                  isexec='x' in flags,
+                                  islink=b'l' in flags,
+                                  isexec=b'x' in flags,
                                   copied=copied.get(path))
     else:
         mctx = context.memfilectx(repo, fctx.path(), fctx.data(),
-                                  islink='l' in flags,
-                                  isexec='x' in flags,
+                                  islink=b'l' in flags,
+                                  isexec=b'x' in flags,
                                   copied=copied.get(path))
     return mctx
 
 def strdiff(a, b, fn1, fn2):
     """ A version of mdiff.unidiff for comparing two strings
     """
-    args = [a, '', b, '', fn1, fn2]
+    args = [a, b'', b, b'', fn1, fn2]
 
     # hg < 4.6 compat 8b6dd3922f70
     argspec = inspect.getargspec(mdiff.unidiff)
 
-    if 'binary' in argspec.args:
+    if b'binary' in argspec.args:
         args.append(False)
 
     return mdiff.unidiff(*args)
@@ -123,7 +123,7 @@
     makedate = mercurial.util.makedate
     parsedate = mercurial.util.parsedate
 
-def wireprotocommand(exthelper, name, args='', permission='pull'):
+def wireprotocommand(exthelper, name, args=b'', permission=b'pull'):
     try:
         # Since b4d85bc1
         from mercurial.wireprotov1server import wireprotocommand
@@ -161,7 +161,7 @@
         return bool(upres[-1])
     return bool(upres.unresolvedcount)
 
-hg48 = util.safehasattr(copies, 'stringutil')
+hg48 = util.safehasattr(copies, b'stringutil')
 # code imported from Mercurial core at ae17555ef93f + patch
 def fixedcopytracing(repo, c1, c2, base):
     """A complete copy-patse of copies._fullcopytrace with a one line fix to
@@ -185,7 +185,7 @@
     # an endpoint is "dirty" if it isn't a descendant of the merge base
     # if we have a dirty endpoint, we need to trigger graft logic, and also
     # keep track of which endpoint is dirty
-    if util.safehasattr(base, 'isancestorof'):
+    if util.safehasattr(base, b'isancestorof'):
         dirtyc1 = not base.isancestorof(_c1)
         dirtyc2 = not base.isancestorof(_c2)
     else: # hg <= 4.6
@@ -204,7 +204,7 @@
     if limit is None:
         # no common ancestor, no copies
         return {}, {}, {}, {}, {}
-    repo.ui.debug("  searching for copies back to rev %d\n" % limit)
+    repo.ui.debug(b"  searching for copies back to rev %d\n" % limit)
 
     m1 = c1.manifest()
     m2 = c2.manifest()
@@ -218,18 +218,18 @@
     # - incompletediverge = record divergent partial copies here
     diverge = {} # divergence data is shared
     incompletediverge = {}
-    data1 = {'copy': {},
-             'fullcopy': {},
-             'incomplete': {},
-             'diverge': diverge,
-             'incompletediverge': incompletediverge,
-            }
-    data2 = {'copy': {},
-             'fullcopy': {},
-             'incomplete': {},
-             'diverge': diverge,
-             'incompletediverge': incompletediverge,
-            }
+    data1 = {b'copy': {},
+             b'fullcopy': {},
+             b'incomplete': {},
+             b'diverge': diverge,
+             b'incompletediverge': incompletediverge,
+             }
+    data2 = {b'copy': {},
+             b'fullcopy': {},
+             b'incomplete': {},
+             b'diverge': diverge,
+             b'incompletediverge': incompletediverge,
+             }
 
     # find interesting file sets from manifests
     if hg48:
@@ -246,20 +246,20 @@
     else:
         # unmatched file from base (DAG rotation in the graft case)
         u1r, u2r = copies._computenonoverlap(repo, c1, c2, addedinm1, addedinm2,
-                                             baselabel='base')
+                                             baselabel=b'base')
         # unmatched file from topological common ancestors (no DAG rotation)
         # need to recompute this for directory move handling when grafting
         mta = tca.manifest()
         if hg48:
             m1f = m1.filesnotin(mta, repo.narrowmatch())
             m2f = m2.filesnotin(mta, repo.narrowmatch())
-            baselabel = 'topological common ancestor'
+            baselabel = b'topological common ancestor'
             u1u, u2u = copies._computenonoverlap(repo, c1, c2, m1f, m2f,
                                                  baselabel=baselabel)
         else:
             u1u, u2u = copies._computenonoverlap(repo, c1, c2, m1.filesnotin(mta),
                                                  m2.filesnotin(mta),
-                                                 baselabel='topological common ancestor')
+                                                 baselabel=b'topological common ancestor')
 
     for f in u1u:
         copies._checkcopies(c1, c2, f, base, tca, dirtyc1, limit, data1)
@@ -267,16 +267,16 @@
     for f in u2u:
         copies._checkcopies(c2, c1, f, base, tca, dirtyc2, limit, data2)
 
-    copy = dict(data1['copy'])
-    copy.update(data2['copy'])
-    fullcopy = dict(data1['fullcopy'])
-    fullcopy.update(data2['fullcopy'])
+    copy = dict(data1[b'copy'])
+    copy.update(data2[b'copy'])
+    fullcopy = dict(data1[b'fullcopy'])
+    fullcopy.update(data2[b'fullcopy'])
 
     if dirtyc1:
-        copies._combinecopies(data2['incomplete'], data1['incomplete'], copy, diverge,
+        copies._combinecopies(data2[b'incomplete'], data1[b'incomplete'], copy, diverge,
                               incompletediverge)
     else:
-        copies._combinecopies(data1['incomplete'], data2['incomplete'], copy, diverge,
+        copies._combinecopies(data1[b'incomplete'], data2[b'incomplete'], copy, diverge,
                               incompletediverge)
 
     renamedelete = {}
@@ -294,23 +294,23 @@
             divergeset.update(fl) # reverse map for below
 
     if bothnew:
-        repo.ui.debug("  unmatched files new in both:\n   %s\n"
-                      % "\n   ".join(bothnew))
+        repo.ui.debug(b"  unmatched files new in both:\n   %s\n"
+                      % b"\n   ".join(bothnew))
     bothdiverge = {}
     bothincompletediverge = {}
     remainder = {}
-    both1 = {'copy': {},
-             'fullcopy': {},
-             'incomplete': {},
-             'diverge': bothdiverge,
-             'incompletediverge': bothincompletediverge
-            }
-    both2 = {'copy': {},
-             'fullcopy': {},
-             'incomplete': {},
-             'diverge': bothdiverge,
-             'incompletediverge': bothincompletediverge
-            }
+    both1 = {b'copy': {},
+             b'fullcopy': {},
+             b'incomplete': {},
+             b'diverge': bothdiverge,
+             b'incompletediverge': bothincompletediverge
+             }
+    both2 = {b'copy': {},
+             b'fullcopy': {},
+             b'incomplete': {},
+             b'diverge': bothdiverge,
+             b'incompletediverge': bothincompletediverge
+             }
     for f in bothnew:
         copies._checkcopies(c1, c2, f, base, tca, dirtyc1, limit, both1)
         copies._checkcopies(c2, c1, f, base, tca, dirtyc2, limit, both2)
@@ -319,17 +319,17 @@
         pass
     elif dirtyc1:
         # incomplete copies may only be found on the "dirty" side for bothnew
-        assert not both2['incomplete']
-        remainder = copies._combinecopies({}, both1['incomplete'], copy, bothdiverge,
+        assert not both2[b'incomplete']
+        remainder = copies._combinecopies({}, both1[b'incomplete'], copy, bothdiverge,
                                           bothincompletediverge)
     elif dirtyc2:
-        assert not both1['incomplete']
-        remainder = copies._combinecopies({}, both2['incomplete'], copy, bothdiverge,
+        assert not both1[b'incomplete']
+        remainder = copies._combinecopies({}, both2[b'incomplete'], copy, bothdiverge,
                                           bothincompletediverge)
     else:
         # incomplete copies and divergences can't happen outside grafts
-        assert not both1['incomplete']
-        assert not both2['incomplete']
+        assert not both1[b'incomplete']
+        assert not both2[b'incomplete']
         assert not bothincompletediverge
     for f in remainder:
         assert f not in bothdiverge
@@ -342,52 +342,52 @@
             copy[fl[0]] = of # not actually divergent, just matching renames
 
     if fullcopy and repo.ui.debugflag:
-        repo.ui.debug("  all copies found (* = to merge, ! = divergent, "
-                      "% = renamed and deleted):\n")
+        repo.ui.debug(b"  all copies found (* = to merge, ! = divergent, "
+                      b"% = renamed and deleted):\n")
         for f in sorted(fullcopy):
-            note = ""
+            note = b""
             if f in copy:
-                note += "*"
+                note += b"*"
             if f in divergeset:
-                note += "!"
+                note += b"!"
             if f in renamedeleteset:
-                note += "%"
-            repo.ui.debug("   src: '%s' -> dst: '%s' %s\n" % (fullcopy[f], f,
-                                                              note))
+                note += b"%"
+            repo.ui.debug(b"   src: '%s' -> dst: '%s' %s\n" % (fullcopy[f], f,
+                                                               note))
     del divergeset
 
     if not fullcopy:
         return copy, {}, diverge, renamedelete, {}
 
-    repo.ui.debug("  checking for directory renames\n")
+    repo.ui.debug(b"  checking for directory renames\n")
 
     # generate a directory move map
     d1, d2 = c1.dirs(), c2.dirs()
     # Hack for adding '', which is not otherwise added, to d1 and d2
-    d1.addpath('/')
-    d2.addpath('/')
+    d1.addpath(b'/')
+    d2.addpath(b'/')
     invalid = set()
     dirmove = {}
 
     # examine each file copy for a potential directory move, which is
     # when all the files in a directory are moved to a new directory
-    for dst, src in fullcopy.iteritems():
+    for dst, src in fullcopy.items():
         dsrc, ddst = pathutil.dirname(src), pathutil.dirname(dst)
         if dsrc in invalid:
             # already seen to be uninteresting
             continue
         elif dsrc in d1 and ddst in d1:
             # directory wasn't entirely moved locally
-            invalid.add(dsrc + "/")
+            invalid.add(dsrc + b"/")
         elif dsrc in d2 and ddst in d2:
             # directory wasn't entirely moved remotely
-            invalid.add(dsrc + "/")
-        elif dsrc + "/" in dirmove and dirmove[dsrc + "/"] != ddst + "/":
+            invalid.add(dsrc + b"/")
+        elif dsrc + b"/" in dirmove and dirmove[dsrc + b"/"] != ddst + b"/":
             # files from the same directory moved to two different places
-            invalid.add(dsrc + "/")
+            invalid.add(dsrc + b"/")
         else:
             # looks good so far
-            dirmove[dsrc + "/"] = ddst + "/"
+            dirmove[dsrc + b"/"] = ddst + b"/"
 
     for i in invalid:
         if i in dirmove:
@@ -398,7 +398,7 @@
         return copy, {}, diverge, renamedelete, {}
 
     for d in dirmove:
-        repo.ui.debug("   discovered dir src: '%s' -> dst: '%s'\n" %
+        repo.ui.debug(b"   discovered dir src: '%s' -> dst: '%s'\n" %
                       (d, dirmove[d]))
 
     movewithdir = {}
@@ -411,18 +411,18 @@
                     df = dirmove[d] + f[len(d):]
                     if df not in copy:
                         movewithdir[f] = df
-                        repo.ui.debug(("   pending file src: '%s' -> "
-                                       "dst: '%s'\n") % (f, df))
+                        repo.ui.debug((b"   pending file src: '%s' -> "
+                                       b"dst: '%s'\n") % (f, df))
                     break
 
     return copy, movewithdir, diverge, renamedelete, dirmove
 
 # hg <= 4.9 compat (7694b685bb10)
-fixupstreamed = util.safehasattr(scmutil, 'movedirstate')
+fixupstreamed = util.safehasattr(scmutil, b'movedirstate')
 if not fixupstreamed:
     copies._fullcopytracing = fixedcopytracing
 
-if not util.safehasattr(obsutil, "_succs"):
+if not util.safehasattr(obsutil, b"_succs"):
     class _succs(list):
         """small class to represent a successors with some metadata about it"""
 
@@ -450,12 +450,12 @@
     _succs instance
     """
 
-    if not util.safehasattr(succs, "markers"):
+    if not util.safehasattr(succs, b"markers"):
         return _succs(succs)
     else:
         return succs
 
-if not util.safehasattr(obsutil, "markersdates"):
+if not util.safehasattr(obsutil, b"markersdates"):
     MARKERS_DATE_COMPAT = True
 else:
     MARKERS_DATE_COMPAT = False
@@ -468,7 +468,7 @@
 
     return [m[4] for m in markers]
 
-if not util.safehasattr(obsutil, "markersusers"):
+if not util.safehasattr(obsutil, b"markersusers"):
     MARKERS_USERS_COMPAT = True
 else:
     MARKERS_USERS_COMPAT = False
@@ -480,12 +480,12 @@
         return obsutil.markersusers(markers)
 
     markersmeta = [dict(m[3]) for m in markers]
-    users = set(encoding.tolocal(meta['user']) for meta in markersmeta
-                if meta.get('user'))
+    users = set(encoding.tolocal(meta[b'user']) for meta in markersmeta
+                if meta.get(b'user'))
 
     return sorted(users)
 
-if not util.safehasattr(obsutil, "markersoperations"):
+if not util.safehasattr(obsutil, b"markersoperations"):
     MARKERS_OPERATIONS_COMPAT = True
 else:
     MARKERS_OPERATIONS_COMPAT = False
@@ -497,7 +497,7 @@
         return obsutil.markersoperations(markers)
 
     markersmeta = [dict(m[3]) for m in markers]
-    operations = set(meta.get('operation') for meta in markersmeta
-                     if meta.get('operation'))
+    operations = set(meta.get(b'operation') for meta in markersmeta
+                     if meta.get(b'operation'))
 
     return sorted(operations)
diff --git a/hgext3rd/evolve/dagutil.py b/hgext3rd/evolve/dagutil.py
--- a/hgext3rd/evolve/dagutil.py
+++ b/hgext3rd/evolve/dagutil.py
@@ -140,7 +140,7 @@
     def _internalize(self, id):
         ix = self._revlog.rev(id)
         if ix == nullrev:
-            raise LookupError(id, self._revlog.indexfile, _('nullid'))
+            raise LookupError(id, self._revlog.indexfile, _(b'nullid'))
         return ix
 
     def _internalizeall(self, ids, filterunknown):
diff --git a/hgext3rd/evolve/debugcmd.py b/hgext3rd/evolve/debugcmd.py
--- a/hgext3rd/evolve/debugcmd.py
+++ b/hgext3rd/evolve/debugcmd.py
@@ -21,7 +21,7 @@
 
 eh = exthelper.exthelper()
 
- at eh.command('debugobsstorestat', [], '')
+ at eh.command(b'debugobsstorestat', [], b'')
 def cmddebugobsstorestat(ui, repo):
     """print statistics about obsolescence markers in the repo"""
     def _updateclustermap(nodes, mark, clustersmap):
@@ -45,7 +45,7 @@
     unfi = repo.unfiltered()
     nm = unfi.changelog.nodemap
     nbmarkers = len(store._all)
-    ui.write(_('markers total:              %9i\n') % nbmarkers)
+    ui.write(_(b'markers total:              %9i\n') % nbmarkers)
     sucscount = [0, 0, 0, 0]
     known = 0
     parentsdata = 0
@@ -67,7 +67,7 @@
             metakeys.setdefault(key, 0)
             metakeys[key] += 1
         meta = dict(meta)
-        parents = [meta.get('p1'), meta.get('p2')]
+        parents = [meta.get(b'p1'), meta.get(b'p2')]
         parents = [node.bin(p) for p in parents if p is not None]
         if parents:
             parentsdata += 1
@@ -91,71 +91,71 @@
         fc = (frozenset(c[0]), frozenset(c[1]))
         for n in fc[0]:
             pclustersmap[n] = fc
-    numobs = len(unfi.revs('obsolete()'))
+    numobs = len(unfi.revs(b'obsolete()'))
     numtotal = len(unfi)
-    ui.write(('    for known precursors:   %9i' % known))
-    ui.write((' (%i/%i obsolete changesets)\n' % (numobs, numtotal)))
-    ui.write(('    with parents data:      %9i\n' % parentsdata))
+    ui.write((b'    for known precursors:   %9i' % known))
+    ui.write((b' (%i/%i obsolete changesets)\n' % (numobs, numtotal)))
+    ui.write((b'    with parents data:      %9i\n' % parentsdata))
     # successors data
-    ui.write(('markers with no successors: %9i\n' % sucscount[0]))
-    ui.write(('              1 successors: %9i\n' % sucscount[1]))
-    ui.write(('              2 successors: %9i\n' % sucscount[2]))
-    ui.write(('    more than 2 successors: %9i\n' % sucscount[3]))
+    ui.write((b'markers with no successors: %9i\n' % sucscount[0]))
+    ui.write((b'              1 successors: %9i\n' % sucscount[1]))
+    ui.write((b'              2 successors: %9i\n' % sucscount[2]))
+    ui.write((b'    more than 2 successors: %9i\n' % sucscount[3]))
     # meta data info
-    ui.write(('    available  keys:\n'))
+    ui.write((b'    available  keys:\n'))
     for key in sorted(metakeys):
-        ui.write(('    %15s:        %9i\n' % (key, metakeys[key])))
+        ui.write((b'    %15s:        %9i\n' % (key, metakeys[key])))
 
     size_v0.sort()
     size_v1.sort()
     if size_v0:
-        ui.write('marker size:\n')
+        ui.write(b'marker size:\n')
         # format v1
-        ui.write('    format v1:\n')
-        ui.write(('        smallest length:    %9i\n' % size_v1[0]))
-        ui.write(('        longer length:      %9i\n' % size_v1[-1]))
+        ui.write(b'    format v1:\n')
+        ui.write((b'        smallest length:    %9i\n' % size_v1[0]))
+        ui.write((b'        longer length:      %9i\n' % size_v1[-1]))
         median = size_v1[nbmarkers // 2]
-        ui.write(('        median length:      %9i\n' % median))
+        ui.write((b'        median length:      %9i\n' % median))
         mean = sum(size_v1) // nbmarkers
-        ui.write(('        mean length:        %9i\n' % mean))
+        ui.write((b'        mean length:        %9i\n' % mean))
         # format v0
-        ui.write('    format v0:\n')
-        ui.write(('        smallest length:    %9i\n' % size_v0[0]))
-        ui.write(('        longer length:      %9i\n' % size_v0[-1]))
+        ui.write(b'    format v0:\n')
+        ui.write((b'        smallest length:    %9i\n' % size_v0[0]))
+        ui.write((b'        longer length:      %9i\n' % size_v0[-1]))
         median = size_v0[nbmarkers // 2]
-        ui.write(('        median length:      %9i\n' % median))
+        ui.write((b'        median length:      %9i\n' % median))
         mean = sum(size_v0) // nbmarkers
-        ui.write(('        mean length:        %9i\n' % mean))
+        ui.write((b'        mean length:        %9i\n' % mean))
 
     allclusters = list(set(clustersmap.values()))
     allclusters.sort(key=lambda x: len(x[1]))
-    ui.write(('disconnected clusters:      %9i\n' % len(allclusters)))
+    ui.write((b'disconnected clusters:      %9i\n' % len(allclusters)))
 
-    ui.write('        any known node:     %9i\n'
+    ui.write(b'        any known node:     %9i\n'
              % len([c for c in allclusters
                     if [n for n in c[0] if nm.get(n) is not None]]))
     if allclusters:
         nbcluster = len(allclusters)
-        ui.write(('        smallest length:    %9i\n' % len(allclusters[0][1])))
-        ui.write(('        longer length:      %9i\n'
-                 % len(allclusters[-1][1])))
+        ui.write((b'        smallest length:    %9i\n' % len(allclusters[0][1])))
+        ui.write((b'        longer length:      %9i\n'
+                  % len(allclusters[-1][1])))
         median = len(allclusters[nbcluster // 2][1])
-        ui.write(('        median length:      %9i\n' % median))
+        ui.write((b'        median length:      %9i\n' % median))
         mean = sum(len(x[1]) for x in allclusters) // nbcluster
-        ui.write(('        mean length:        %9i\n' % mean))
+        ui.write((b'        mean length:        %9i\n' % mean))
     allpclusters = list(set(pclustersmap.values()))
     allpclusters.sort(key=lambda x: len(x[1]))
-    ui.write(('    using parents data:     %9i\n' % len(allpclusters)))
-    ui.write('        any known node:     %9i\n'
+    ui.write((b'    using parents data:     %9i\n' % len(allpclusters)))
+    ui.write(b'        any known node:     %9i\n'
              % len([c for c in allclusters
                     if [n for n in c[0] if nm.get(n) is not None]]))
     if allpclusters:
         nbcluster = len(allpclusters)
-        ui.write(('        smallest length:    %9i\n'
-                 % len(allpclusters[0][1])))
-        ui.write(('        longer length:      %9i\n'
-                 % len(allpclusters[-1][1])))
+        ui.write((b'        smallest length:    %9i\n'
+                  % len(allpclusters[0][1])))
+        ui.write((b'        longer length:      %9i\n'
+                  % len(allpclusters[-1][1])))
         median = len(allpclusters[nbcluster // 2][1])
-        ui.write(('        median length:      %9i\n' % median))
+        ui.write((b'        median length:      %9i\n' % median))
         mean = sum(len(x[1]) for x in allpclusters) // nbcluster
-        ui.write(('        mean length:        %9i\n' % mean))
+        ui.write((b'        mean length:        %9i\n' % mean))
diff --git a/hgext3rd/evolve/depthcache.py b/hgext3rd/evolve/depthcache.py
--- a/hgext3rd/evolve/depthcache.py
+++ b/hgext3rd/evolve/depthcache.py
@@ -32,39 +32,39 @@
 
 def simpledepth(repo, rev):
     """simple but obviously right implementation of depth"""
-    return len(repo.revs('::%d', rev))
+    return len(repo.revs(b'::%d', rev))
 
 @eh.command(
-    'debugdepth',
+    b'debugdepth',
     [
-        ('r', 'rev', [], 'revs to print depth for'),
-        ('', 'method', 'cached', "one of 'simple', 'cached', 'compare'"),
-    ],
-    _('REVS'))
+        (b'r', b'rev', [], b'revs to print depth for'),
+        (b'', b'method', b'cached', b"one of 'simple', 'cached', 'compare'"),
+     ],
+    _(b'REVS'))
 def debugdepth(ui, repo, **opts):
     """display depth of REVS
     """
-    revs = scmutil.revrange(repo, opts['rev'])
-    method = opts['method']
-    if method in ('cached', 'compare'):
+    revs = scmutil.revrange(repo, opts[b'rev'])
+    method = opts[b'method']
+    if method in (b'cached', b'compare'):
         cache = repo.depthcache
         cache.save(repo)
     for r in revs:
         ctx = repo[r]
-        if method == 'simple':
+        if method == b'simple':
             depth = simpledepth(repo, r)
-        elif method == 'cached':
+        elif method == b'cached':
             depth = cache.get(r)
-        elif method == 'compare':
+        elif method == b'compare':
             simple = simpledepth(repo, r)
             cached = cache.get(r)
             if simple != cached:
-                raise error.Abort('depth differ for revision %s: %d != %d'
+                raise error.Abort(b'depth differ for revision %s: %d != %d'
                                   % (ctx, simple, cached))
             depth = simple
         else:
-            raise error.Abort('unknown method "%s"' % method)
-        ui.write('%s %d\n' % (ctx, depth))
+            raise error.Abort(b'unknown method "%s"' % method)
+        ui.write(b'%s %d\n' % (ctx, depth))
 
 @eh.reposetup
 def setupcache(ui, repo):
@@ -79,7 +79,7 @@
 
         @localrepo.unfilteredmethod
         def destroyed(self):
-            if 'depthcache' in vars(self):
+            if b'depthcache' in vars(self):
                 self.depthcache.clear()
             super(depthcacherepo, self).destroyed()
 
@@ -94,16 +94,16 @@
 
 class depthcache(genericcaches.changelogsourcebase):
 
-    _filepath = 'evoext-depthcache-00'
-    _cachename = 'evo-ext-depthcache'
+    _filepath = b'evoext-depthcache-00'
+    _cachename = b'evo-ext-depthcache'
 
     def __init__(self):
         super(depthcache, self).__init__()
-        self._data = array.array('l')
+        self._data = array.array(b'l')
 
     def get(self, rev):
         if len(self._data) <= rev:
-            raise error.ProgrammingError('depthcache must be warmed before use')
+            raise error.ProgrammingError(b'depthcache must be warmed before use')
         return self._data[rev]
 
     def _updatefrom(self, repo, data):
@@ -113,15 +113,15 @@
         total = len(data)
 
         def progress(pos, rev):
-            compat.progress(repo.ui, 'updating depth cache',
-                            pos, 'rev %s' % rev, unit='revision', total=total)
-        progress(0, '')
+            compat.progress(repo.ui, b'updating depth cache',
+                            pos, b'rev %s' % rev, unit=b'revision', total=total)
+        progress(0, b'')
         for idx, rev in enumerate(data, 1):
             assert rev == len(self._data), (rev, len(self._data))
             self._data.append(self._depth(cl, rev))
             if not (idx % 10000): # progress as a too high performance impact
                 progress(idx, rev)
-        progress(None, '')
+        progress(None, b'')
 
     def _depth(self, changelog, rev):
         cl = changelog
@@ -170,7 +170,7 @@
         Subclasses MUST overide this method to actually affect the cache data.
         """
         super(depthcache, self).clear()
-        self._data = array.array('l')
+        self._data = array.array(b'l')
 
     # crude version of a cache, to show the kind of information we have to store
 
@@ -179,7 +179,7 @@
         assert repo.filtername is None
 
         data = repo.cachevfs.tryread(self._filepath)
-        self._data = array.array('l')
+        self._data = array.array(b'l')
         if not data:
             self._cachekey = self.emptykey
         else:
@@ -198,12 +198,12 @@
             return
 
         try:
-            cachefile = repo.cachevfs(self._filepath, 'w', atomictemp=True)
+            cachefile = repo.cachevfs(self._filepath, b'w', atomictemp=True)
             headerdata = self._serializecachekey()
             cachefile.write(headerdata)
             cachefile.write(self._data.tostring())
             cachefile.close()
             self._ondiskkey = self._cachekey
         except (IOError, OSError) as exc:
-            repo.ui.log('depthcache', 'could not write update %s\n' % exc)
-            repo.ui.debug('depthcache: could not write update %s\n' % exc)
+            repo.ui.log(b'depthcache', b'could not write update %s\n' % exc)
+            repo.ui.debug(b'depthcache: could not write update %s\n' % exc)
diff --git a/hgext3rd/evolve/evolvecmd.py b/hgext3rd/evolve/evolvecmd.py
--- a/hgext3rd/evolve/evolvecmd.py
+++ b/hgext3rd/evolve/evolvecmd.py
@@ -52,7 +52,7 @@
 eh = exthelper.exthelper()
 mergetoolopts = commands.mergetoolopts
 
-abortmessage = _("see `hg help evolve.interrupted`\n")
+abortmessage = _(b"see `hg help evolve.interrupted`\n")
 
 def _solveone(ui, repo, ctx, evolvestate, dryrun, confirm,
               progresscb, category, lastsolved=None, stacktmplt=False):
@@ -69,23 +69,23 @@
     displayer = None
     if stacktmplt:
         displayer = compat.changesetdisplayer(ui, repo,
-                                              {'template': stacktemplate})
+                                              {b'template': stacktemplate})
     else:
         displayer = compat.changesetdisplayer(ui, repo,
-                                              {'template': shorttemplate})
-    if 'orphan' == category:
+                                              {b'template': shorttemplate})
+    if b'orphan' == category:
         result = _solveunstable(ui, repo, ctx, evolvestate, displayer,
                                 dryrun, confirm, progresscb,
                                 lastsolved=lastsolved)
-    elif 'phasedivergent' == category:
+    elif b'phasedivergent' == category:
         result = _solvephasedivergence(ui, repo, ctx, evolvestate,
                                        displayer, dryrun, confirm,
                                        progresscb)
-    elif 'contentdivergent' == category:
+    elif b'contentdivergent' == category:
         result = _solvedivergent(ui, repo, ctx, evolvestate, displayer,
                                  dryrun, confirm, progresscb)
     else:
-        assert False, "unknown trouble category: %s" % (category)
+        assert False, b"unknown trouble category: %s" % (category)
     return result
 
 def _solveunstable(ui, repo, orig, evolvestate, displayer, dryrun=False,
@@ -111,7 +111,7 @@
         else:
             # store that we are resolving an orphan merge with both parents
             # obsolete and proceed with first parent
-            evolvestate['orphanmerge'] = True
+            evolvestate[b'orphanmerge'] = True
             # we should process the second parent first, so that in case of
             # no-conflicts the first parent is processed later and preserved as
             # first parent
@@ -119,40 +119,40 @@
             keepbranch = orig.p2().branch() != orig.branch()
 
     if not pctx.obsolete():
-        ui.warn(_("cannot solve instability of %s, skipping\n") % orig)
-        return (False, ".")
+        ui.warn(_(b"cannot solve instability of %s, skipping\n") % orig)
+        return (False, b".")
     obs = pctx
     newer = obsutil.successorssets(repo, obs.node())
     # search of a parent which is not killed
     while not newer or newer == [()]:
-        ui.debug("stabilize target %s is plain dead,"
-                 " trying to stabilize on its parent\n" %
+        ui.debug(b"stabilize target %s is plain dead,"
+                 b" trying to stabilize on its parent\n" %
                  obs)
         obs = obs.parents()[0]
         newer = obsutil.successorssets(repo, obs.node())
     if len(newer) > 1:
-        msg = _("skipping %s: divergent rewriting. can't choose "
-                "destination\n") % obs
+        msg = _(b"skipping %s: divergent rewriting. can't choose "
+                b"destination\n") % obs
         ui.write_err(msg)
-        return (False, ".")
+        return (False, b".")
     targets = newer[0]
     assert targets
     if len(targets) > 1:
         # split target, figure out which one to pick, are they all in line?
         targetrevs = [repo[r].rev() for r in targets]
-        roots = repo.revs('roots(%ld)', targetrevs)
-        heads = repo.revs('heads(%ld)', targetrevs)
+        roots = repo.revs(b'roots(%ld)', targetrevs)
+        heads = repo.revs(b'heads(%ld)', targetrevs)
         if len(roots) > 1 or len(heads) > 1:
-            cheader = _("ancestor '%s' split over multiple topological"
-                        " branches.\nchoose an evolve destination:") % orig
+            cheader = _(b"ancestor '%s' split over multiple topological"
+                        b" branches.\nchoose an evolve destination:") % orig
             selectedrev = utility.revselectionprompt(ui, repo, list(heads),
                                                      cheader)
             if selectedrev is None:
-                msg = _("could not solve instability, "
-                        "ambiguous destination: "
-                        "parent split across two branches\n")
+                msg = _(b"could not solve instability, "
+                        b"ambiguous destination: "
+                        b"parent split across two branches\n")
                 ui.write_err(msg)
-                return (False, ".")
+                return (False, b".")
             target = repo[selectedrev]
         else:
             target = repo[heads.first()]
@@ -160,29 +160,29 @@
         target = targets[0]
     target = repo[target]
     if not ui.quiet or confirm:
-        repo.ui.write(_('move:'), label='evolve.operation')
+        repo.ui.write(_(b'move:'), label=b'evolve.operation')
         displayer.show(orig)
         if lastsolved is None or target != repo[lastsolved]:
-            repo.ui.write(_('atop:'))
+            repo.ui.write(_(b'atop:'))
             displayer.show(target)
-    if confirm and ui.prompt('perform evolve? [Ny]', 'n') != 'y':
-        raise error.Abort(_('evolve aborted by user'))
-    todo = 'hg rebase -r %s -d %s\n' % (orig, target)
+    if confirm and ui.prompt(b'perform evolve? [Ny]', b'n') != b'y':
+        raise error.Abort(_(b'evolve aborted by user'))
+    todo = b'hg rebase -r %s -d %s\n' % (orig, target)
     if dryrun:
         if progresscb:
             progresscb()
         repo.ui.write(todo)
-        return (False, ".")
+        return (False, b".")
     else:
         repo.ui.note(todo)
         if progresscb:
             progresscb()
         try:
             newid = relocate(repo, orig, target, evolvestate, pctx,
-                             keepbranch, 'orphan')
+                             keepbranch, b'orphan')
             return (True, newid)
         except error.InterventionRequired:
-            ops = {'current': orig.node()}
+            ops = {b'current': orig.node()}
             evolvestate.addopts(ops)
             evolvestate.save()
             raise
@@ -201,32 +201,32 @@
     bumped = repo[bumped.rev()]
     # For now we deny bumped merge
     if len(bumped.parents()) > 1:
-        msg = _('skipping %s : we do not handle merge yet\n') % bumped
+        msg = _(b'skipping %s : we do not handle merge yet\n') % bumped
         ui.write_err(msg)
-        return (False, ".")
-    prec = repo.set('last(allpredecessors(%d) and public())', bumped.rev()).next()
+        return (False, b".")
+    prec = repo.set(b'last(allpredecessors(%d) and public())', bumped.rev()).next()
     # For now we deny target merge
     if len(prec.parents()) > 1:
-        msg = _('skipping: %s: public version is a merge, '
-                'this is not handled yet\n') % prec
+        msg = _(b'skipping: %s: public version is a merge, '
+                b'this is not handled yet\n') % prec
         ui.write_err(msg)
-        return (False, ".")
+        return (False, b".")
 
     if not ui.quiet or confirm:
-        repo.ui.write(_('recreate:'), label='evolve.operation')
+        repo.ui.write(_(b'recreate:'), label=b'evolve.operation')
         displayer.show(bumped)
-        repo.ui.write(_('atop:'))
+        repo.ui.write(_(b'atop:'))
         displayer.show(prec)
-    if confirm and ui.prompt('perform evolve? [Ny]', 'n') != 'y':
-        raise error.Abort(_('evolve aborted by user'))
+    if confirm and ui.prompt(b'perform evolve? [Ny]', b'n') != b'y':
+        raise error.Abort(_(b'evolve aborted by user'))
     if dryrun:
-        todo = 'hg rebase --rev %s --dest %s;\n' % (bumped, prec.p1())
+        todo = b'hg rebase --rev %s --dest %s;\n' % (bumped, prec.p1())
         repo.ui.write(todo)
-        repo.ui.write(('hg update %s;\n' % prec))
-        repo.ui.write(('hg revert --all --rev %s;\n' % bumped))
-        repo.ui.write(('hg commit --msg "%s update to %s"\n' %
-                       (TROUBLES['PHASEDIVERGENT'], bumped)))
-        return (False, ".")
+        repo.ui.write((b'hg update %s;\n' % prec))
+        repo.ui.write((b'hg revert --all --rev %s;\n' % bumped))
+        repo.ui.write((b'hg commit --msg "%s update to %s"\n' %
+                       (TROUBLES[b'PHASEDIVERGENT'], bumped)))
+        return (False, b".")
     if progresscb:
         progresscb()
 
@@ -236,22 +236,22 @@
     # evolved or any other operation which can change parent. In such cases,
     # when parents are not same, we first rebase the divergent changeset onto
     # parent or precursor and then perform later steps
-    if not list(repo.set('parents(%d) and parents(%d)', bumped.rev(), prec.rev())):
+    if not list(repo.set(b'parents(%d) and parents(%d)', bumped.rev(), prec.rev())):
         # Need to rebase the changeset at the right place
         repo.ui.status(
-            _('rebasing to destination parent: %s\n') % prec.p1())
+            _(b'rebasing to destination parent: %s\n') % prec.p1())
         try:
             newnode = relocate(repo, bumped, prec.p1(), evolvestate,
-                               category='phasedivergent')
+                               category=b'phasedivergent')
             if newnode is not None:
                 new = repo[newnode]
                 obsolete.createmarkers(repo, [(bumped, (new,))],
-                                       operation='evolve')
+                                       operation=b'evolve')
                 bumped = new
-                evolvestate['temprevs'].append(newnode)
+                evolvestate[b'temprevs'].append(newnode)
         except error.InterventionRequired:
-            evolvestate['current'] = bumped.hex()
-            evolvestate['precursor'] = prec.hex()
+            evolvestate[b'current'] = bumped.hex()
+            evolvestate[b'precursor'] = prec.hex()
             evolvestate.save()
             raise
 
@@ -283,7 +283,7 @@
     merge.update(repo, bumped.node(), ancestor=prec, mergeancestor=True,
                  branchmerge=True, force=False, wc=wctx)
     if not wctx.isempty():
-        text = '%s update to %s:\n\n' % (TROUBLES['PHASEDIVERGENT'], prec)
+        text = b'%s update to %s:\n\n' % (TROUBLES[b'PHASEDIVERGENT'], prec)
         text += bumped.description()
         memctx = wctx.tomemctx(text,
                                parents=(prec.node(), nodemod.nullid),
@@ -293,14 +293,14 @@
         newid = repo.commitctx(memctx)
         replacementnode = newid
     if newid is None:
-        repo.ui.status(_('no changes to commit\n'))
-        obsolete.createmarkers(repo, [(bumped, ())], operation='evolve')
+        repo.ui.status(_(b'no changes to commit\n'))
+        obsolete.createmarkers(repo, [(bumped, ())], operation=b'evolve')
         newid = prec.node()
     else:
-        repo.ui.status(_('committed as %s\n') % nodemod.short(newid))
+        repo.ui.status(_(b'committed as %s\n') % nodemod.short(newid))
         phases.retractboundary(repo, tr, bumped.phase(), [newid])
         obsolete.createmarkers(repo, [(bumped, (repo[newid],))],
-                               flag=obsolete.bumpedfix, operation='evolve')
+                               flag=obsolete.bumpedfix, operation=b'evolve')
     bmupdate(newid)
     # reroute the working copy parent to the new changeset
     with repo.dirstate.parentchange():
@@ -319,45 +319,45 @@
     """
     repo = repo.unfiltered()
     divergent = repo[divergent.rev()]
-    evolvestate['divergent'] = divergent.node()
-    evolvestate['orig-divergent'] = divergent.node()
+    evolvestate[b'divergent'] = divergent.node()
+    evolvestate[b'orig-divergent'] = divergent.node()
     # sometimes we will relocate a node in case of different parents and we can
     # encounter conflicts after relocation is done while solving
     # content-divergence and if the user calls `hg evolve --stop`, we need to
     # strip that relocated commit. However if `--all` is passed, we need to
     # reset this value for each content-divergence resolution which we are doing
     # below.
-    evolvestate['relocated'] = None
-    evolvestate['relocating'] = False
+    evolvestate[b'relocated'] = None
+    evolvestate[b'relocating'] = False
     # in case or relocation we get a new other node, we need to store the old
     # other for purposes like `--abort` or `--stop`
-    evolvestate['old-other'] = None
+    evolvestate[b'old-other'] = None
     base, others = divergentdata(divergent)
 
     # we don't handle split in content-divergence yet
     if len(others) > 1:
-        othersstr = "[%s]" % (','.join([str(i) for i in others]))
-        msg = _("skipping %s: %s with a changeset that got split"
-                " into multiple ones:\n"
-                "|[%s]\n"
-                "| This is not handled by automatic evolution yet\n"
-                "| You have to fallback to manual handling with commands "
-                "such as:\n"
-                "| - hg touch -D\n"
-                "| - hg prune\n"
-                "| \n"
-                "| You should contact your local evolution Guru for help.\n"
-                ) % (divergent, TROUBLES['CONTENTDIVERGENT'], othersstr)
+        othersstr = b"[%s]" % (b','.join([str(i) for i in others]))
+        msg = _(b"skipping %s: %s with a changeset that got split"
+                b" into multiple ones:\n"
+                b"|[%s]\n"
+                b"| This is not handled by automatic evolution yet\n"
+                b"| You have to fallback to manual handling with commands "
+                b"such as:\n"
+                b"| - hg touch -D\n"
+                b"| - hg prune\n"
+                b"| \n"
+                b"| You should contact your local evolution Guru for help.\n"
+                ) % (divergent, TROUBLES[b'CONTENTDIVERGENT'], othersstr)
         ui.write_err(msg)
-        return (False, ".")
+        return (False, b".")
     other = others[0]
-    evolvestate['other-divergent'] = other.node()
-    evolvestate['base'] = base.node()
+    evolvestate[b'other-divergent'] = other.node()
+    evolvestate[b'base'] = base.node()
 
     def swapnodes(div, other):
         div, other = other, div
-        evolvestate['divergent'] = div.node()
-        evolvestate['other-divergent'] = other.node()
+        evolvestate[b'divergent'] = div.node()
+        evolvestate[b'other-divergent'] = other.node()
         return div, other
     # haspubdiv: to keep track if we are solving public content-divergence
     haspubdiv = False
@@ -370,17 +370,17 @@
             divergent, other = swapnodes(divergent, other)
         else:
             publicdiv = divergent
-        evolvestate['public-divergent'] = publicdiv.node()
+        evolvestate[b'public-divergent'] = publicdiv.node()
     # we don't handle merge content-divergent changesets yet
     if len(other.parents()) > 1:
-        msg = _("skipping %s: %s changeset can't be "
-                "a merge (yet)\n") % (divergent, TROUBLES['CONTENTDIVERGENT'])
+        msg = _(b"skipping %s: %s changeset can't be "
+                b"a merge (yet)\n") % (divergent, TROUBLES[b'CONTENTDIVERGENT'])
         ui.write_err(msg)
-        hint = _("You have to fallback to solving this by hand...\n"
-                 "| This probably means redoing the merge and using \n"
-                 "| `hg prune` to kill older version.\n")
+        hint = _(b"You have to fallback to solving this by hand...\n"
+                 b"| This probably means redoing the merge and using \n"
+                 b"| `hg prune` to kill older version.\n")
         ui.write_err(hint)
-        return (False, ".")
+        return (False, b".")
 
     otherp1 = other.p1().rev()
     divp1 = divergent.p1().rev()
@@ -399,15 +399,15 @@
     # the changeset on which resolution changeset will be based on
     resolutionparent = repo[divp1].node()
 
-    gca = repo.revs("ancestor(%d, %d)" % (otherp1, divp1))
+    gca = repo.revs(b"ancestor(%d, %d)" % (otherp1, divp1))
     # divonly: non-obsolete csets which are topological ancestor of "divergent"
     # but not "other"
-    divonly = repo.revs("only(%d, %d) - obsolete()" % (divergent.rev(),
-                                                       other.rev()))
+    divonly = repo.revs(b"only(%d, %d) - obsolete()" % (divergent.rev(),
+                                                        other.rev()))
     # otheronly: non-obsolete csets which are topological ancestor of "other"
     # but not "div"
-    otheronly = repo.revs("only(%d, %d) - obsolete()" % (other.rev(),
-                                                         divergent.rev()))
+    otheronly = repo.revs(b"only(%d, %d) - obsolete()" % (other.rev(),
+                                                          divergent.rev()))
     # make it exclusive set
     divonly = set(divonly) - {divergent.rev()}
     otheronly = set(otheronly) - {other.rev()}
@@ -467,62 +467,62 @@
             divergent, other = swapnodes(divergent, other)
             resolutionparent = divergent.p1().node()
     else:
-        msg = _("skipping %s: have a different parent than %s "
-                "(not handled yet)\n") % (divergent, other)
-        hint = _("| %(d)s, %(o)s are not based on the same changeset.\n"
-                 "| With the current state of its implementation, \n"
-                 "| evolve does not work in that case.\n"
-                 "| rebase one of them next to the other and run \n"
-                 "| this command again.\n"
-                 "| - either: hg rebase --dest 'p1(%(d)s)' -r %(o)s\n"
-                 "| - or:     hg rebase --dest 'p1(%(o)s)' -r %(d)s\n"
-                 ) % {'d': divergent, 'o': other}
+        msg = _(b"skipping %s: have a different parent than %s "
+                b"(not handled yet)\n") % (divergent, other)
+        hint = _(b"| %(d)s, %(o)s are not based on the same changeset.\n"
+                 b"| With the current state of its implementation, \n"
+                 b"| evolve does not work in that case.\n"
+                 b"| rebase one of them next to the other and run \n"
+                 b"| this command again.\n"
+                 b"| - either: hg rebase --dest 'p1(%(d)s)' -r %(o)s\n"
+                 b"| - or:     hg rebase --dest 'p1(%(o)s)' -r %(d)s\n"
+                 ) % {b'd': divergent, b'o': other}
         ui.write_err(msg)
         ui.write_err(hint)
-        return (False, ".")
+        return (False, b".")
 
     if not ui.quiet or confirm:
-        ui.write(_('merge:'), label='evolve.operation')
+        ui.write(_(b'merge:'), label=b'evolve.operation')
         displayer.show(divergent)
-        ui.write(_('with: '))
+        ui.write(_(b'with: '))
         displayer.show(other)
-        ui.write(_('base: '))
+        ui.write(_(b'base: '))
         displayer.show(base)
-    if confirm and ui.prompt(_('perform evolve? [Ny]'), 'n') != 'y':
-        raise error.Abort(_('evolve aborted by user'))
+    if confirm and ui.prompt(_(b'perform evolve? [Ny]'), b'n') != b'y':
+        raise error.Abort(_(b'evolve aborted by user'))
     if dryrun:
-        ui.write(('hg update -c %s &&\n' % divergent))
-        ui.write(('hg merge %s &&\n' % other))
-        ui.write(('hg commit -m "auto merge resolving conflict between '
-                 '%s and %s"&&\n' % (divergent, other)))
-        ui.write(('hg up -C %s &&\n' % base))
-        ui.write(('hg revert --all --rev tip &&\n'))
-        ui.write(('hg commit -m "`hg log -r %s --template={desc}`";\n'
-                 % divergent))
-        return (False, ".")
+        ui.write((b'hg update -c %s &&\n' % divergent))
+        ui.write((b'hg merge %s &&\n' % other))
+        ui.write((b'hg commit -m "auto merge resolving conflict between '
+                  b'%s and %s"&&\n' % (divergent, other)))
+        ui.write((b'hg up -C %s &&\n' % base))
+        ui.write((b'hg revert --all --rev tip &&\n'))
+        ui.write((b'hg commit -m "`hg log -r %s --template={desc}`";\n'
+                  % divergent))
+        return (False, b".")
 
-    evolvestate['resolutionparent'] = resolutionparent
+    evolvestate[b'resolutionparent'] = resolutionparent
     # relocate the other divergent if required
     if relocatereq:
         # relocating will help us understand during the time of conflicts that
         # whether conflicts occur at reloacting or they occured at merging
         # content divergent changesets
-        evolvestate['relocating'] = True
-        ui.status(_('rebasing "other" content-divergent changeset %s on'
-                    ' %s\n' % (other, divergent.p1())))
+        evolvestate[b'relocating'] = True
+        ui.status(_(b'rebasing "other" content-divergent changeset %s on'
+                    b' %s\n' % (other, divergent.p1())))
         try:
             newother = relocate(repo, other, divergent.p1(), evolvestate,
                                 keepbranch=True)
         except error.InterventionRequired:
-            evolvestate['current'] = other.node()
+            evolvestate[b'current'] = other.node()
             evolvestate.save()
             raise
-        evolvestate['old-other'] = other.node()
+        evolvestate[b'old-other'] = other.node()
         other = repo[newother]
-        evolvestate['relocating'] = False
-        evolvestate['relocated'] = other.node()
-        evolvestate['temprevs'].append(other.node())
-        evolvestate['other-divergent'] = other.node()
+        evolvestate[b'relocating'] = False
+        evolvestate[b'relocated'] = other.node()
+        evolvestate[b'temprevs'].append(other.node())
+        evolvestate[b'other-divergent'] = other.node()
 
     _mergecontentdivergents(repo, progresscb, divergent, other, base,
                             evolvestate)
@@ -544,9 +544,9 @@
             # case 2)
             pubstr = str(publicdiv)
             othstr = str(other)
-            msg = _('content divergence resolution between %s '
-                    '(public) and %s has same content as %s, '
-                    'discarding %s\n')
+            msg = _(b'content divergence resolution between %s '
+                    b'(public) and %s has same content as %s, '
+                    b'discarding %s\n')
             msg %= (pubstr, othstr, pubstr, othstr)
             repo.ui.status(msg)
             return (res, newnode)
@@ -558,12 +558,12 @@
 def _mergecontentdivergents(repo, progresscb, divergent, other, base,
                             evolvestate):
     if divergent not in repo[None].parents():
-        repo.ui.note(_("updating to \"local\" side of the conflict: %s\n") %
+        repo.ui.note(_(b"updating to \"local\" side of the conflict: %s\n") %
                      divergent.hex()[:12])
         hg.updaterepo(repo, divergent.node(), False)
     # merging the two content-divergent changesets
-    repo.ui.note(_("merging \"other\" %s changeset '%s'\n") %
-                 (TROUBLES['CONTENTDIVERGENT'], other.hex()[:12]))
+    repo.ui.note(_(b"merging \"other\" %s changeset '%s'\n") %
+                 (TROUBLES[b'CONTENTDIVERGENT'], other.hex()[:12]))
     if progresscb:
         progresscb()
     mergeancestor = repo.changelog.isancestor(divergent.node(), other.node())
@@ -578,8 +578,8 @@
     # conflicts while merging content-divergent changesets
     if compat.hasconflict(stats):
         evolvestate.save()
-        raise error.InterventionRequired(_("fix conflicts and see `hg help "
-                                           "evolve.interrupted`"))
+        raise error.InterventionRequired(_(b"fix conflicts and see `hg help "
+                                           b"evolve.interrupted`"))
 
 def _completecontentdivergent(ui, repo, progresscb, divergent, other,
                               base, evolvestate):
@@ -588,20 +588,20 @@
     # resume resolution
     if progresscb:
         progresscb()
-    emtpycommitallowed = repo.ui.backupconfig('ui', 'allowemptycommit')
+    emtpycommitallowed = repo.ui.backupconfig(b'ui', b'allowemptycommit')
     tr = repo.currenttransaction()
     assert tr is not None
     # whether to store the obsmarker in the evolvestate
     storemarker = False
-    resparent = evolvestate['resolutionparent']
+    resparent = evolvestate[b'resolutionparent']
 
     # whether we are solving public divergence
     haspubdiv = False
-    if evolvestate.get('public-divergent'):
+    if evolvestate.get(b'public-divergent'):
         haspubdiv = True
-        publicnode = evolvestate['public-divergent']
+        publicnode = evolvestate[b'public-divergent']
         publicdiv = repo[publicnode]
-        othernode = evolvestate['other-divergent']
+        othernode = evolvestate[b'other-divergent']
         otherdiv = repo[othernode]
 
         with repo.dirstate.parentchange():
@@ -614,7 +614,7 @@
             warnmetadataloss(repo, publicdiv, otherdiv)
             # no changes, create markers to resolve divergence
             obsolete.createmarkers(repo, [(otherdiv, (publicdiv,))],
-                                   operation='evolve')
+                                   operation=b'evolve')
             return (True, publicnode)
     try:
         with repo.dirstate.parentchange():
@@ -640,29 +640,29 @@
             # no changes
             new = divergent
             storemarker = True
-            repo.ui.status(_("nothing changed\n"))
+            repo.ui.status(_(b"nothing changed\n"))
             hg.updaterepo(repo, divergent.rev(), False)
         else:
             new = repo[newnode]
             newnode = new.node()
             hg.updaterepo(repo, new.rev(), False)
             if haspubdiv and publicdiv == divergent:
-                bypassphase(repo, (divergent, new), operation='evolve')
+                bypassphase(repo, (divergent, new), operation=b'evolve')
             else:
                 obsolete.createmarkers(repo, [(divergent, (new,))],
-                                       operation='evolve')
+                                       operation=b'evolve')
 
         # creating markers and moving phases post-resolution
         if haspubdiv and publicdiv == other:
-            bypassphase(repo, (other, new), operation='evolve')
+            bypassphase(repo, (other, new), operation=b'evolve')
         else:
-            obsolete.createmarkers(repo, [(other, (new,))], operation='evolve')
+            obsolete.createmarkers(repo, [(other, (new,))], operation=b'evolve')
         if storemarker:
             # storing the marker in the evolvestate
             # we just store the precursors and successor pair for now, we might
             # want to store more data and serialize obsmarker in a better way in
             # future
-            evolvestate['obsmarkers'].append((other.node(), new.node()))
+            evolvestate[b'obsmarkers'].append((other.node(), new.node()))
 
         phases.retractboundary(repo, tr, other.phase(), [new.node()])
         return (True, newnode)
@@ -674,7 +674,7 @@
     public content-divergence"""
 
     # needtowarn: aspects where we need to warn user
-    needtowarn = ['branch', 'topic', 'close']
+    needtowarn = [b'branch', b'topic', b'close']
     aspects = set()
     localextra = local.extra()
     otherextra = other.extra()
@@ -686,48 +686,48 @@
             aspects.add(asp)
 
     if other.description() != local.description():
-        aspects.add('description')
+        aspects.add(b'description')
 
     if aspects:
         # warn user
         locstr = str(local)
         othstr = str(other)
-        if 'close' in aspects:
-            filteredasp = aspects - {'close'}
+        if b'close' in aspects:
+            filteredasp = aspects - {b'close'}
             if filteredasp:
-                msg = _('other divergent changeset %s is a closed branch head '
-                        'and differs from local %s by "%s" only,' %
-                        (othstr, locstr, ', '.join(sorted(filteredasp))))
+                msg = _(b'other divergent changeset %s is a closed branch head '
+                        b'and differs from local %s by "%s" only,' %
+                        (othstr, locstr, b', '.join(sorted(filteredasp))))
             else:
-                msg = _('other divergent changeset %s is a closed branch head '
-                        'and has same content as local %s,' % (othstr, locstr))
+                msg = _(b'other divergent changeset %s is a closed branch head '
+                        b'and has same content as local %s,' % (othstr, locstr))
         else:
-            msg = _('other divergent changeset %s has same content as local %s'
-                    ' and differs by "%s" only,' %
-                    (othstr, locstr, ', '.join(sorted(aspects))))
-        msg += _(' discarding %s\n' % othstr)
+            msg = _(b'other divergent changeset %s has same content as local %s'
+                    b' and differs by "%s" only,' %
+                    (othstr, locstr, b', '.join(sorted(aspects))))
+        msg += _(b' discarding %s\n' % othstr)
         repo.ui.warn(msg)
 
-def bypassphase(repo, relation, flag=0, metadata=None, operation='evolve'):
+def bypassphase(repo, relation, flag=0, metadata=None, operation=b'evolve'):
     """function to create a single obsmarker relation even for public csets
     where relation should be a single pair (prec, succ)"""
 
     # prepare metadata
     if metadata is None:
         metadata = {}
-    if 'user' not in metadata:
-        luser = repo.ui.config('devel', 'user.obsmarker') or repo.ui.username()
-        metadata['user'] = encoding.fromlocal(luser)
+    if b'user' not in metadata:
+        luser = repo.ui.config(b'devel', b'user.obsmarker') or repo.ui.username()
+        metadata[b'user'] = encoding.fromlocal(luser)
     # Operation metadata handling
-    useoperation = repo.ui.configbool('experimental',
-                                      'evolution.track-operation')
+    useoperation = repo.ui.configbool(b'experimental',
+                                      b'evolution.track-operation')
     if useoperation and operation:
-        metadata['operation'] = operation
+        metadata[b'operation'] = operation
 
     # Effect flag metadata handling
-    saveeffectflag = repo.ui.configbool('experimental',
-                                        'evolution.effect-flags')
-    with repo.transaction('add-obsolescence-marker') as tr:
+    saveeffectflag = repo.ui.configbool(b'experimental',
+                                        b'evolution.effect-flags')
+    with repo.transaction(b'add-obsolescence-marker') as tr:
         prec, succ = relation
         nprec = prec.node()
         npare = None
@@ -735,7 +735,7 @@
         if not nsucs:
             npare = tuple(p.node() for p in prec.parents())
         if nprec in nsucs:
-            raise error.Abort(_("changeset %s cannot obsolete itself") % prec)
+            raise error.Abort(_(b"changeset %s cannot obsolete itself") % prec)
 
         if saveeffectflag:
             # The effect flag is saved in a versioned field name for
@@ -745,7 +745,7 @@
             except TypeError:
                 # hg <= 4.7
                 effectflag = obsutil.geteffectflag((prec, (succ,)))
-            metadata[obsutil.EFFECTFLAGFIELD] = "%d" % effectflag
+            metadata[obsutil.EFFECTFLAGFIELD] = b"%d" % effectflag
 
         # create markers
         repo.obsstore.create(tr, nprec, nsucs, flag, parents=npare,
@@ -847,11 +847,11 @@
             repo.dirstate.setbranch(othbranch)
         else:
             # all the three branches are different
-            index = repo.ui.promptchoice(_("content divergent changesets on "
-                                           "different branches.\nchoose branch"
-                                           " for the resolution changeset. (a) "
-                                           "%s or (b) %s or (c) %s? $$ &a $$ &b"
-                                           " $$ &c") %
+            index = repo.ui.promptchoice(_(b"content divergent changesets on "
+                                           b"different branches.\nchoose branch"
+                                           b" for the resolution changeset. (a) "
+                                           b"%s or (b) %s or (c) %s? $$ &a $$ &b"
+                                           b" $$ &c") %
                                          (basebranch, divbranch, othbranch), 0)
 
             if index == 0:
@@ -868,20 +868,20 @@
     merger = simplemerge.Merge3Text(basedesc, divdesc, othdesc)
     mdesc = []
     kwargs = {}
-    kwargs['name_base'] = 'base'
-    kwargs['base_marker'] = '|||||||'
-    for line in merger.merge_lines(name_a='divergent', name_b='other',
+    kwargs[b'name_base'] = b'base'
+    kwargs[b'base_marker'] = b'|||||||'
+    for line in merger.merge_lines(name_a=b'divergent', name_b=b'other',
                                    **kwargs):
         mdesc.append(line)
 
-    desc = ''.join(mdesc)
+    desc = b''.join(mdesc)
     if merger.conflicts:
 
-        prefixes = ("HG: Conflicts while merging changeset description of"
-                    " content-divergent changesets.\nHG: Resolve conflicts"
-                    " in commit messages to continue.\n\n")
+        prefixes = (b"HG: Conflicts while merging changeset description of"
+                    b" content-divergent changesets.\nHG: Resolve conflicts"
+                    b" in commit messages to continue.\n\n")
 
-        resolveddesc = ui.edit(prefixes + desc, ui.username(), action='desc')
+        resolveddesc = ui.edit(prefixes + desc, ui.username(), action=b'desc')
         # make sure we remove the prefixes part from final commit message
         if prefixes in resolveddesc:
             # hack, we should find something better
@@ -932,17 +932,17 @@
     returns the node of new commit which is formed
     """
     if orig.rev() == dest.rev():
-        msg = _('tried to relocate a node on top of itself')
-        hint = _("This shouldn't happen. If you still need to move changesets, "
-                 "please do so manually with nothing to rebase - working "
-                 "directory parent is also destination")
+        msg = _(b'tried to relocate a node on top of itself')
+        hint = _(b"This shouldn't happen. If you still need to move changesets, "
+                 b"please do so manually with nothing to rebase - working "
+                 b"directory parent is also destination")
         raise error.ProgrammingError(msg, hint=hint)
 
     if pctx is None:
         if len(orig.parents()) == 2:
-            msg = _("tried to relocate a merge commit without specifying which "
-                    "parent should be moved")
-            hint = _("Specify the parent by passing in pctx")
+            msg = _(b"tried to relocate a merge commit without specifying which "
+                    b"parent should be moved")
+            hint = _(b"Specify the parent by passing in pctx")
             raise error.ProgrammingError(msg, hint)
         pctx = orig.p1()
 
@@ -952,7 +952,7 @@
     sha1s = re.findall(sha1re, commitmsg)
     unfi = repo.unfiltered()
     for sha1 in sha1s:
-        if util.safehasattr(scmutil, 'resolvehexnodeidprefix'): # > hg-4.6
+        if util.safehasattr(scmutil, b'resolvehexnodeidprefix'): # > hg-4.6
             fullnode = scmutil.resolvehexnodeidprefix(unfi, sha1)
         else:
             fullnode = unfi.changelog.index.partialmatch(sha1)
@@ -970,8 +970,8 @@
             newsha1 = nodemod.hex(successors[0][0])
             commitmsg = commitmsg.replace(sha1, newsha1[:len(sha1)])
         else:
-            repo.ui.note(_('The stale commit message reference to %s could '
-                           'not be updated\n') % sha1)
+            repo.ui.note(_(b'The stale commit message reference to %s could '
+                           b'not be updated\n') % sha1)
 
     tr = repo.currenttransaction()
     assert tr is not None
@@ -984,8 +984,8 @@
             copies.duplicatecopies(repo, repo[None], dest.rev(),
                                    orig.p1().rev())
             dirstatedance(repo, dest, orig.node(), None)
-        raise error.InterventionRequired(_("fix conflicts and see `hg help "
-                                           "evolve.interrupted`"))
+        raise error.InterventionRequired(_(b"fix conflicts and see `hg help "
+                                           b"evolve.interrupted`"))
     nodenew = _relocatecommit(repo, orig, commitmsg)
     _finalizerelocate(repo, orig, dest, nodenew, tr, category, evolvestate)
     return nodenew
@@ -994,14 +994,14 @@
     if commitmsg is None:
         commitmsg = orig.description()
     extra = dict(orig.extra())
-    if 'branch' in extra:
-        del extra['branch']
-    extra['rebase_source'] = orig.hex()
+    if b'branch' in extra:
+        del extra[b'branch']
+    extra[b'rebase_source'] = orig.hex()
 
-    backup = repo.ui.backupconfig('phases', 'new-commit')
+    backup = repo.ui.backupconfig(b'phases', b'new-commit')
     try:
         targetphase = max(orig.phase(), phases.draft)
-        repo.ui.setconfig('phases', 'new-commit', targetphase, 'evolve')
+        repo.ui.setconfig(b'phases', b'new-commit', targetphase, b'evolve')
         # Commit might fail if unresolved files exist
         nodenew = repo.commit(text=commitmsg, user=orig.user(),
                               date=orig.date(), extra=extra)
@@ -1017,18 +1017,18 @@
 
     if nodenew is not None:
         obsolete.createmarkers(repo, [(repo[nodesrc], (repo[nodenew],))],
-                               operation='evolve')
+                               operation=b'evolve')
         for book in oldbookmarks:
             bmchanges.append((book, nodenew))
-            evolvestate['bookmarkchanges'].append((book, nodesrc))
+            evolvestate[b'bookmarkchanges'].append((book, nodesrc))
     else:
-        if category == 'orphan':
-            repo.ui.status(_("evolution of %d:%s created no changes "
-                             "to commit\n") % (orig.rev(), orig))
-        obsolete.createmarkers(repo, [(repo[nodesrc], ())], operation='evolve')
+        if category == b'orphan':
+            repo.ui.status(_(b"evolution of %d:%s created no changes "
+                             b"to commit\n") % (orig.rev(), orig))
+        obsolete.createmarkers(repo, [(repo[nodesrc], ())], operation=b'evolve')
         # Behave like rebase, move bookmarks to dest
         for book in oldbookmarks:
-            evolvestate['bookmarkchanges'].append((book, nodesrc))
+            evolvestate[b'bookmarkchanges'].append((book, nodesrc))
             bmchanges.append((book, dest.node()))
     for book in destbookmarks: # restore bookmark that rebase move
         bmchanges.append((book, dest.node()))
@@ -1038,61 +1038,61 @@
 def _evolvemerge(repo, orig, dest, pctx, keepbranch):
     """Used by the evolve function to merge dest on top of pctx.
     return the same tuple as merge.graft"""
-    if repo['.'].rev() != dest.rev():
+    if repo[b'.'].rev() != dest.rev():
         merge.update(repo,
                      dest,
                      branchmerge=False,
                      force=True)
     if repo._activebookmark:
-        repo.ui.status(_("(leaving bookmark %s)\n") % repo._activebookmark)
+        repo.ui.status(_(b"(leaving bookmark %s)\n") % repo._activebookmark)
     bookmarksmod.deactivate(repo)
     if keepbranch:
         repo.dirstate.setbranch(orig.branch())
-    if util.safehasattr(repo, 'currenttopic'):
+    if util.safehasattr(repo, b'currenttopic'):
         # uurrgs
         # there no other topic setter yet
-        if not orig.topic() and repo.vfs.exists('topic'):
-            repo.vfs.unlink('topic')
+        if not orig.topic() and repo.vfs.exists(b'topic'):
+            repo.vfs.unlink(b'topic')
         else:
-            with repo.vfs.open('topic', 'w') as f:
+            with repo.vfs.open(b'topic', b'w') as f:
                 f.write(orig.topic())
 
-    return merge.graft(repo, orig, pctx, ['destination', 'evolving'], True)
+    return merge.graft(repo, orig, pctx, [b'destination', b'evolving'], True)
 
 instabilities_map = {
-    'contentdivergent': "content-divergent",
-    'phasedivergent': "phase-divergent"
+    b'contentdivergent': b"content-divergent",
+    b'phasedivergent': b"phase-divergent"
 }
 
 def _selectrevs(repo, allopt, revopt, anyopt, targetcat):
     """select troubles in repo matching according to given options"""
     revs = set()
     if allopt or revopt:
-        revs = repo.revs("%s()" % targetcat)
+        revs = repo.revs(b"%s()" % targetcat)
         if revopt:
             revs = scmutil.revrange(repo, revopt) & revs
         elif not anyopt:
-            topic = getattr(repo, 'currenttopic', '')
+            topic = getattr(repo, 'currenttopic', b'')
             if topic:
-                revs = repo.revs('topic(%s)', topic) & revs
-            elif targetcat == 'orphan':
+                revs = repo.revs(b'topic(%s)', topic) & revs
+            elif targetcat == b'orphan':
                 revs = _aspiringdescendant(repo,
-                                           repo.revs('(.::) - obsolete()::'))
+                                           repo.revs(b'(.::) - obsolete()::'))
                 revs = set(revs)
-        if targetcat == 'contentdivergent':
+        if targetcat == b'contentdivergent':
             # Pick one divergent per group of divergents
             revs = _dedupedivergents(repo, revs)
     elif anyopt:
-        revs = repo.revs('first(%s())' % (targetcat))
-    elif targetcat == 'orphan':
-        revs = set(_aspiringchildren(repo, repo.revs('(.::) - obsolete()::')))
+        revs = repo.revs(b'first(%s())' % (targetcat))
+    elif targetcat == b'orphan':
+        revs = set(_aspiringchildren(repo, repo.revs(b'(.::) - obsolete()::')))
         if 1 < len(revs):
-            msg = "multiple evolve candidates"
-            hint = (_("select one of %s with --rev")
-                    % ', '.join([str(repo[r]) for r in sorted(revs)]))
+            msg = b"multiple evolve candidates"
+            hint = (_(b"select one of %s with --rev")
+                    % b', '.join([str(repo[r]) for r in sorted(revs)]))
             raise error.Abort(msg, hint=hint)
-    elif instabilities_map.get(targetcat, targetcat) in repo['.'].instabilities():
-        revs = set([repo['.'].rev()])
+    elif instabilities_map.get(targetcat, targetcat) in repo[b'.'].instabilities():
+        revs = set([repo[b'.'].rev()])
     return revs
 
 def _dedupedivergents(repo, revs):
@@ -1121,14 +1121,14 @@
     XXX this woobly function won't survive XXX
     """
     repo = ctx._repo.unfiltered()
-    for base in repo.set('reverse(allpredecessors(%d))', ctx.rev()):
+    for base in repo.set(b'reverse(allpredecessors(%d))', ctx.rev()):
         newer = obsutil.successorssets(ctx._repo, base.node())
         # drop filter and solution including the original ctx
         newer = [n for n in newer if n and ctx.node() not in n]
         if newer:
             return base, tuple(ctx._repo[o] for o in newer[0])
-    raise error.Abort(_("base of divergent changeset %s not found") % ctx,
-                      hint=_('this case is not yet handled'))
+    raise error.Abort(_(b"base of divergent changeset %s not found") % ctx,
+                      hint=_(b'this case is not yet handled'))
 
 def _aspiringdescendant(repo, revs):
     """Return a list of changectx which can be stabilized on top of pctx or
@@ -1136,7 +1136,7 @@
     target = set(revs)
     result = set(target)
     paths = collections.defaultdict(set)
-    for r in repo.revs('orphan() - %ld', revs):
+    for r in repo.revs(b'orphan() - %ld', revs):
         for d in _possibledestination(repo, r):
             paths[d].add(r)
 
@@ -1155,7 +1155,7 @@
     one of its descendants. Empty list if none can be found."""
     target = set(revs)
     result = []
-    for r in repo.revs('orphan() - %ld', revs):
+    for r in repo.revs(b'orphan() - %ld', revs):
         dest = _possibledestination(repo, r)
         if target & dest:
             result.append(r)
@@ -1188,104 +1188,104 @@
 def _handlenotrouble(ui, repo, allopt, revopt, anyopt, targetcat):
     """Used by the evolve function to display an error message when
     no troubles can be resolved"""
-    troublecategories = ['phasedivergent', 'contentdivergent', 'orphan']
+    troublecategories = [b'phasedivergent', b'contentdivergent', b'orphan']
     unselectedcategories = [c for c in troublecategories if c != targetcat]
     msg = None
     hint = None
     retoverride = None
 
     troubled = {
-        "orphan": repo.revs("orphan()"),
-        "contentdivergent": repo.revs("contentdivergent()"),
-        "phasedivergent": repo.revs("phasedivergent()"),
-        "all": repo.revs("unstable()"),
+        b"orphan": repo.revs(b"orphan()"),
+        b"contentdivergent": repo.revs(b"contentdivergent()"),
+        b"phasedivergent": repo.revs(b"phasedivergent()"),
+        b"all": repo.revs(b"unstable()"),
     }
 
     hintmap = {
-        'phasedivergent': _("do you want to use --phase-divergent"),
-        'phasedivergent+contentdivergent': _("do you want to use "
-                                             "--phase-divergent or"
-                                             " --content-divergent"),
-        'phasedivergent+orphan': _("do you want to use --phase-divergent"
-                                   " or --orphan"),
-        'contentdivergent': _("do you want to use --content-divergent"),
-        'contentdivergent+orphan': _("do you want to use --content-divergent"
-                                     " or --orphan"),
-        'orphan': _("do you want to use --orphan"),
-        'any+phasedivergent': _("do you want to use --any (or --rev) and"
-                                " --phase-divergent"),
-        'any+phasedivergent+contentdivergent': _("do you want to use --any"
-                                                 " (or --rev) and"
-                                                 " --phase-divergent or"
-                                                 " --content-divergent"),
-        'any+phasedivergent+orphan': _("do you want to use --any (or --rev)"
-                                       " and --phase-divergent or --orphan"),
-        'any+contentdivergent': _("do you want to use --any (or --rev) and"
-                                  " --content-divergent"),
-        'any+contentdivergent+orphan': _("do you want to use --any (or --rev)"
-                                         " and --content-divergent or "
-                                         "--orphan"),
-        'any+orphan': _("do you want to use --any (or --rev)"
-                        "and --orphan"),
+        b'phasedivergent': _(b"do you want to use --phase-divergent"),
+        b'phasedivergent+contentdivergent': _(b"do you want to use "
+                                              b"--phase-divergent or"
+                                              b" --content-divergent"),
+        b'phasedivergent+orphan': _(b"do you want to use --phase-divergent"
+                                    b" or --orphan"),
+        b'contentdivergent': _(b"do you want to use --content-divergent"),
+        b'contentdivergent+orphan': _(b"do you want to use --content-divergent"
+                                      b" or --orphan"),
+        b'orphan': _(b"do you want to use --orphan"),
+        b'any+phasedivergent': _(b"do you want to use --any (or --rev) and"
+                                 b" --phase-divergent"),
+        b'any+phasedivergent+contentdivergent': _(b"do you want to use --any"
+                                                  b" (or --rev) and"
+                                                  b" --phase-divergent or"
+                                                  b" --content-divergent"),
+        b'any+phasedivergent+orphan': _(b"do you want to use --any (or --rev)"
+                                        b" and --phase-divergent or --orphan"),
+        b'any+contentdivergent': _(b"do you want to use --any (or --rev) and"
+                                   b" --content-divergent"),
+        b'any+contentdivergent+orphan': _(b"do you want to use --any (or --rev)"
+                                          b" and --content-divergent or "
+                                          b"--orphan"),
+        b'any+orphan': _(b"do you want to use --any (or --rev)"
+                         b"and --orphan"),
     }
 
     if revopt:
         revs = scmutil.revrange(repo, revopt)
         if not revs:
-            msg = _("set of specified revisions is empty")
+            msg = _(b"set of specified revisions is empty")
         else:
-            msg = _("no %s changesets in specified revisions") % targetcat
+            msg = _(b"no %s changesets in specified revisions") % targetcat
             othertroubles = []
             for cat in unselectedcategories:
                 if revs & troubled[cat]:
                     othertroubles.append(cat)
             if othertroubles:
-                hint = hintmap['+'.join(othertroubles)]
+                hint = hintmap[b'+'.join(othertroubles)]
 
     elif anyopt:
-        msg = _("no %s changesets to evolve") % targetcat
+        msg = _(b"no %s changesets to evolve") % targetcat
         othertroubles = []
         for cat in unselectedcategories:
             if troubled[cat]:
                 othertroubles.append(cat)
         if othertroubles:
-            hint = hintmap['+'.join(othertroubles)]
+            hint = hintmap[b'+'.join(othertroubles)]
 
     else:
         # evolve without any option = relative to the current wdir
-        if targetcat == 'orphan':
-            msg = _("nothing to evolve on current working copy parent")
+        if targetcat == b'orphan':
+            msg = _(b"nothing to evolve on current working copy parent")
         else:
-            msg = _("current working copy parent is not %s") % targetcat
+            msg = _(b"current working copy parent is not %s") % targetcat
 
-        p1 = repo['.'].rev()
+        p1 = repo[b'.'].rev()
         othertroubles = []
         for cat in unselectedcategories:
             if p1 in troubled[cat]:
                 othertroubles.append(cat)
         if othertroubles:
-            hint = hintmap['+'.join(othertroubles)]
+            hint = hintmap[b'+'.join(othertroubles)]
         else:
             length = len(troubled[targetcat])
             if length:
-                hint = _("%d other %s in the repository, do you want --any "
-                         "or --rev") % (length, targetcat)
+                hint = _(b"%d other %s in the repository, do you want --any "
+                         b"or --rev") % (length, targetcat)
             else:
                 othertroubles = []
                 for cat in unselectedcategories:
                     if troubled[cat]:
                         othertroubles.append(cat)
                 if othertroubles:
-                    hint = hintmap['any+' + ('+'.join(othertroubles))]
+                    hint = hintmap[b'any+' + (b'+'.join(othertroubles))]
                 else:
-                    msg = _("no troubled changesets")
+                    msg = _(b"no troubled changesets")
                     # Exit with a 0 (success) status in this case.
                     retoverride = 0
 
     assert msg is not None
-    ui.write_err("%s\n" % msg)
+    ui.write_err(b"%s\n" % msg)
     if hint:
-        ui.write_err("(%s)\n" % hint)
+        ui.write_err(b"(%s)\n" % hint)
         ret = 2
     else:
         ret = 1
@@ -1305,21 +1305,21 @@
 
 def listtroubles(ui, repo, troublecategories, **opts):
     """Print all the troubles for the repo (or given revset)"""
-    troublecategories = troublecategories or ['contentdivergent', 'orphan', 'phasedivergent']
-    showunstable = 'orphan' in troublecategories
-    showbumped = 'phasedivergent' in troublecategories
-    showdivergent = 'contentdivergent' in troublecategories
+    troublecategories = troublecategories or [b'contentdivergent', b'orphan', b'phasedivergent']
+    showunstable = b'orphan' in troublecategories
+    showbumped = b'phasedivergent' in troublecategories
+    showdivergent = b'contentdivergent' in troublecategories
 
-    revs = repo.revs('+'.join("%s()" % t for t in troublecategories))
-    if opts.get('rev'):
-        revs = scmutil.revrange(repo, opts.get('rev'))
+    revs = repo.revs(b'+'.join(b"%s()" % t for t in troublecategories))
+    if opts.get(b'rev'):
+        revs = scmutil.revrange(repo, opts.get(b'rev'))
 
-    fm = ui.formatter('evolvelist', opts)
+    fm = ui.formatter(b'evolvelist', opts)
     for rev in revs:
         ctx = repo[rev]
         unpars = _preparelistctxs(ctx.parents(), lambda p: p.orphan())
         obspars = _preparelistctxs(ctx.parents(), lambda p: p.obsolete())
-        imprecs = _preparelistctxs(repo.set("allpredecessors(%n)", ctx.node()),
+        imprecs = _preparelistctxs(repo.set(b"allpredecessors(%n)", ctx.node()),
                                    lambda p: not p.mutable())
         dsets = divergentsets(repo, ctx)
 
@@ -1329,55 +1329,55 @@
         desc = ctx.description()
         if desc:
             desc = desc.splitlines()[0]
-        desc = (desc[:desclen] + '...') if len(desc) > desclen else desc
-        fm.plain('%s: ' % ctx.hex()[:hashlen])
-        fm.plain('%s\n' % desc)
+        desc = (desc[:desclen] + b'...') if len(desc) > desclen else desc
+        fm.plain(b'%s: ' % ctx.hex()[:hashlen])
+        fm.plain(b'%s\n' % desc)
         fm.data(node=ctx.hex(), rev=ctx.rev(), desc=desc, phase=ctx.phasestr())
 
         for unpar in unpars if showunstable else []:
-            fm.plain('  %s: %s (%s parent)\n' % (TROUBLES['ORPHAN'],
-                                                 unpar[:hashlen],
-                                                 TROUBLES['ORPHAN']))
+            fm.plain(b'  %s: %s (%s parent)\n' % (TROUBLES[b'ORPHAN'],
+                                                  unpar[:hashlen],
+                                                  TROUBLES[b'ORPHAN']))
         for obspar in obspars if showunstable else []:
-            fm.plain('  %s: %s (obsolete parent)\n' % (TROUBLES['ORPHAN'],
-                                                       obspar[:hashlen]))
+            fm.plain(b'  %s: %s (obsolete parent)\n' % (TROUBLES[b'ORPHAN'],
+                                                        obspar[:hashlen]))
         for imprec in imprecs if showbumped else []:
-            fm.plain('  %s: %s (immutable precursor)\n' %
-                     (TROUBLES['PHASEDIVERGENT'], imprec[:hashlen]))
+            fm.plain(b'  %s: %s (immutable precursor)\n' %
+                     (TROUBLES[b'PHASEDIVERGENT'], imprec[:hashlen]))
 
         if dsets and showdivergent:
             for dset in dsets:
-                fm.plain('  %s: ' % TROUBLES['CONTENTDIVERGENT'])
+                fm.plain(b'  %s: ' % TROUBLES[b'CONTENTDIVERGENT'])
                 first = True
-                for n in dset['divergentnodes']:
-                    t = "%s (%s)" if first else " %s (%s)"
+                for n in dset[b'divergentnodes']:
+                    t = b"%s (%s)" if first else b" %s (%s)"
                     first = False
                     fm.plain(t % (nodemod.hex(n)[:hashlen], repo[n].phasestr()))
-                comprec = nodemod.hex(dset['commonprecursor'])[:hashlen]
-                fm.plain(" (precursor %s)\n" % comprec)
-        fm.plain("\n")
+                comprec = nodemod.hex(dset[b'commonprecursor'])[:hashlen]
+                fm.plain(b" (precursor %s)\n" % comprec)
+        fm.plain(b"\n")
 
         # templater-friendly section
         _formatctx(fm, ctx)
         troubles = []
         for unpar in unpars:
-            troubles.append({'troubletype': TROUBLES['ORPHAN'],
-                             'sourcenode': unpar, 'sourcetype': 'orphanparent'})
+            troubles.append({b'troubletype': TROUBLES[b'ORPHAN'],
+                             b'sourcenode': unpar, b'sourcetype': b'orphanparent'})
         for obspar in obspars:
-            troubles.append({'troubletype': TROUBLES['ORPHAN'],
-                             'sourcenode': obspar,
-                             'sourcetype': 'obsoleteparent'})
+            troubles.append({b'troubletype': TROUBLES[b'ORPHAN'],
+                             b'sourcenode': obspar,
+                             b'sourcetype': b'obsoleteparent'})
         for imprec in imprecs:
-            troubles.append({'troubletype': TROUBLES['PHASEDIVERGENT'],
-                             'sourcenode': imprec,
-                             'sourcetype': 'immutableprecursor'})
+            troubles.append({b'troubletype': TROUBLES[b'PHASEDIVERGENT'],
+                             b'sourcenode': imprec,
+                             b'sourcetype': b'immutableprecursor'})
         for dset in dsets:
-            divnodes = [{'node': nodemod.hex(n),
-                         'phase': repo[n].phasestr(),
-                        } for n in dset['divergentnodes']]
-            troubles.append({'troubletype': TROUBLES['CONTENTDIVERGENT'],
-                             'commonprecursor': nodemod.hex(dset['commonprecursor']),
-                             'divergentnodes': divnodes})
+            divnodes = [{b'node': nodemod.hex(n),
+                         b'phase': repo[n].phasestr(),
+                         } for n in dset[b'divergentnodes']]
+            troubles.append({b'troubletype': TROUBLES[b'CONTENTDIVERGENT'],
+                             b'commonprecursor': nodemod.hex(dset[b'commonprecursor']),
+                             b'divergentnodes': divnodes})
         fm.data(troubles=troubles)
 
     fm.end()
@@ -1386,65 +1386,65 @@
     """ check the options passed to `hg evolve` and warn for deprecation warning
     if any """
 
-    if opts['continue']:
-        if opts['any']:
-            raise error.Abort(_('cannot specify both "--any" and "--continue"'))
-        if opts['all']:
-            raise error.Abort(_('cannot specify both "--all" and "--continue"'))
-        if opts['rev']:
-            raise error.Abort(_('cannot specify both "--rev" and "--continue"'))
-        if opts['stop']:
-            raise error.Abort(_('cannot specify both "--stop" and'
-                                ' "--continue"'))
-        if opts['abort']:
-            raise error.Abort(_('cannot specify both "--abort" and'
-                                ' "--continue"'))
+    if opts[b'continue']:
+        if opts[b'any']:
+            raise error.Abort(_(b'cannot specify both "--any" and "--continue"'))
+        if opts[b'all']:
+            raise error.Abort(_(b'cannot specify both "--all" and "--continue"'))
+        if opts[b'rev']:
+            raise error.Abort(_(b'cannot specify both "--rev" and "--continue"'))
+        if opts[b'stop']:
+            raise error.Abort(_(b'cannot specify both "--stop" and'
+                                b' "--continue"'))
+        if opts[b'abort']:
+            raise error.Abort(_(b'cannot specify both "--abort" and'
+                                b' "--continue"'))
 
-    if opts['stop']:
-        if opts['any']:
-            raise error.Abort(_('cannot specify both "--any" and "--stop"'))
-        if opts['all']:
-            raise error.Abort(_('cannot specify both "--all" and "--stop"'))
-        if opts['rev']:
-            raise error.Abort(_('cannot specify both "--rev" and "--stop"'))
-        if opts['abort']:
-            raise error.Abort(_('cannot specify both "--abort" and "--stop"'))
+    if opts[b'stop']:
+        if opts[b'any']:
+            raise error.Abort(_(b'cannot specify both "--any" and "--stop"'))
+        if opts[b'all']:
+            raise error.Abort(_(b'cannot specify both "--all" and "--stop"'))
+        if opts[b'rev']:
+            raise error.Abort(_(b'cannot specify both "--rev" and "--stop"'))
+        if opts[b'abort']:
+            raise error.Abort(_(b'cannot specify both "--abort" and "--stop"'))
 
-    if opts['abort']:
-        if opts['any']:
-            raise error.Abort(_('cannot specify both "--any" and "--abort"'))
-        if opts['all']:
-            raise error.Abort(_('cannot specify both "--all" and "--abort"'))
-        if opts['rev']:
-            raise error.Abort(_('cannot specify both "--rev" and "--abort"'))
+    if opts[b'abort']:
+        if opts[b'any']:
+            raise error.Abort(_(b'cannot specify both "--any" and "--abort"'))
+        if opts[b'all']:
+            raise error.Abort(_(b'cannot specify both "--all" and "--abort"'))
+        if opts[b'rev']:
+            raise error.Abort(_(b'cannot specify both "--rev" and "--abort"'))
 
-    if opts['rev']:
-        if opts['any']:
-            raise error.Abort(_('cannot specify both "--rev" and "--any"'))
-        if opts['all']:
-            raise error.Abort(_('cannot specify both "--rev" and "--all"'))
+    if opts[b'rev']:
+        if opts[b'any']:
+            raise error.Abort(_(b'cannot specify both "--rev" and "--any"'))
+        if opts[b'all']:
+            raise error.Abort(_(b'cannot specify both "--rev" and "--all"'))
 
     # Backward compatibility
-    if opts['unstable']:
-        msg = ("'evolve --unstable' is deprecated, "
-               "use 'evolve --orphan'")
-        repo.ui.deprecwarn(msg, '4.4')
+    if opts[b'unstable']:
+        msg = (b"'evolve --unstable' is deprecated, "
+               b"use 'evolve --orphan'")
+        repo.ui.deprecwarn(msg, b'4.4')
 
-        opts['orphan'] = opts['divergent']
+        opts[b'orphan'] = opts[b'divergent']
 
-    if opts['divergent']:
-        msg = ("'evolve --divergent' is deprecated, "
-               "use 'evolve --content-divergent'")
-        repo.ui.deprecwarn(msg, '4.4')
+    if opts[b'divergent']:
+        msg = (b"'evolve --divergent' is deprecated, "
+               b"use 'evolve --content-divergent'")
+        repo.ui.deprecwarn(msg, b'4.4')
 
-        opts['content_divergent'] = opts['divergent']
+        opts[b'content_divergent'] = opts[b'divergent']
 
-    if opts['bumped']:
-        msg = ("'evolve --bumped' is deprecated, "
-               "use 'evolve --phase-divergent'")
-        repo.ui.deprecwarn(msg, '4.4')
+    if opts[b'bumped']:
+        msg = (b"'evolve --bumped' is deprecated, "
+               b"use 'evolve --phase-divergent'")
+        repo.ui.deprecwarn(msg, b'4.4')
 
-        opts['phase_divergent'] = opts['bumped']
+        opts[b'phase_divergent'] = opts[b'bumped']
 
     return opts
 
@@ -1455,8 +1455,8 @@
         unfi = repo.unfiltered()
         succ = utility._singlesuccessor(repo, unfi[startnode])
         hg.updaterepo(repo, repo[succ].node(), False)
-    if repo['.'].node() != startnode:
-        ui.status(_('working directory is now at %s\n') % repo['.'])
+    if repo[b'.'].node() != startnode:
+        ui.status(_(b'working directory is now at %s\n') % repo[b'.'])
 
 def divergentsets(repo, ctx):
     """Compute sets of commits divergent with a given one"""
@@ -1476,40 +1476,40 @@
                 continue
             base[tuple(nsuccset)] = n
     divergence = []
-    for divset, b in base.iteritems():
+    for divset, b in base.items():
         divergence.append({
-            'divergentnodes': divset,
-            'commonprecursor': b
+            b'divergentnodes': divset,
+            b'commonprecursor': b
         })
 
     return divergence
 
 @eh.command(
-    'evolve|stabilize|solve',
-    [('n', 'dry-run', False,
-      _('do not perform actions, just print what would be done')),
-     ('', 'confirm', False,
-      _('ask for confirmation before performing the action')),
-     ('A', 'any', False,
-      _('also consider troubled changesets unrelated to current working '
-        'directory')),
-     ('r', 'rev', [], _('solves troubles of these revisions'), _('REV')),
-     ('', 'bumped', False, _('solves only bumped changesets (DEPRECATED)')),
-     ('', 'phase-divergent', False, _('solves only phase-divergent changesets')),
-     ('', 'divergent', False, _('solves only divergent changesets (DEPRECATED)')),
-     ('', 'content-divergent', False, _('solves only content-divergent changesets')),
-     ('', 'unstable', False, _('solves only unstable changesets (DEPRECATED)')),
-     ('', 'orphan', False, _('solves only orphan changesets (default)')),
-     ('a', 'all', None, _('evolve all troubled changesets related to the current'
-                          ' working directory and its descendants (default)')),
-     ('', 'update', False, _('update to the head of evolved changesets')),
-     ('c', 'continue', False, _('continue an interrupted evolution')),
-     ('', 'stop', False, _('stop the interrupted evolution')),
-     ('', 'abort', False, _('abort the interrupted evolution')),
-     ('l', 'list', False, _('provide details on troubled changesets'
-                            ' in the repo')),
-    ] + mergetoolopts,
-    _('[OPTIONS]...'),
+    b'evolve|stabilize|solve',
+    [(b'n', b'dry-run', False,
+      _(b'do not perform actions, just print what would be done')),
+     (b'', b'confirm', False,
+      _(b'ask for confirmation before performing the action')),
+     (b'A', b'any', False,
+      _(b'also consider troubled changesets unrelated to current working '
+        b'directory')),
+     (b'r', b'rev', [], _(b'solves troubles of these revisions'), _(b'REV')),
+     (b'', b'bumped', False, _(b'solves only bumped changesets (DEPRECATED)')),
+     (b'', b'phase-divergent', False, _(b'solves only phase-divergent changesets')),
+     (b'', b'divergent', False, _(b'solves only divergent changesets (DEPRECATED)')),
+     (b'', b'content-divergent', False, _(b'solves only content-divergent changesets')),
+     (b'', b'unstable', False, _(b'solves only unstable changesets (DEPRECATED)')),
+     (b'', b'orphan', False, _(b'solves only orphan changesets (default)')),
+     (b'a', b'all', None, _(b'evolve all troubled changesets related to the current'
+                            b' working directory and its descendants (default)')),
+     (b'', b'update', False, _(b'update to the head of evolved changesets')),
+     (b'c', b'continue', False, _(b'continue an interrupted evolution')),
+     (b'', b'stop', False, _(b'stop the interrupted evolution')),
+     (b'', b'abort', False, _(b'abort the interrupted evolution')),
+     (b'l', b'list', False, _(b'provide details on troubled changesets'
+                              b' in the repo')),
+     ] + mergetoolopts,
+    _(b'[OPTIONS]...'),
     helpbasic=True
 )
 def evolve(ui, repo, **opts):
@@ -1607,72 +1607,72 @@
 
     opts = _checkevolveopts(repo, opts)
     # Options
-    contopt = opts['continue']
-    anyopt = opts['any']
-    allopt = opts['all']
+    contopt = opts[b'continue']
+    anyopt = opts[b'any']
+    allopt = opts[b'all']
     if allopt is None:
         allopt = True
-    startnode = repo['.'].node()
-    dryrunopt = opts['dry_run']
-    confirmopt = opts['confirm']
-    revopt = opts['rev']
-    stopopt = opts['stop']
-    abortopt = opts['abort']
-    shouldupdate = opts['update']
+    startnode = repo[b'.'].node()
+    dryrunopt = opts[b'dry_run']
+    confirmopt = opts[b'confirm']
+    revopt = opts[b'rev']
+    stopopt = opts[b'stop']
+    abortopt = opts[b'abort']
+    shouldupdate = opts[b'update']
 
-    troublecategories = ['phase_divergent', 'content_divergent', 'orphan']
-    specifiedcategories = [t.replace('_', '')
+    troublecategories = [b'phase_divergent', b'content_divergent', b'orphan']
+    specifiedcategories = [t.replace(b'_', b'')
                            for t in troublecategories
                            if opts[t]]
-    if opts['list']:
-        ui.pager('evolve')
+    if opts[b'list']:
+        ui.pager(b'evolve')
         listtroubles(ui, repo, specifiedcategories, **opts)
         return
 
-    targetcat = 'orphan'
+    targetcat = b'orphan'
     has_some_opts = bool(revopt or anyopt or allopt or contopt or stopopt or abortopt)
     if 1 < len(specifiedcategories):
-        msg = _('cannot specify more than one trouble category to solve (yet)')
+        msg = _(b'cannot specify more than one trouble category to solve (yet)')
         raise error.Abort(msg)
     elif len(specifiedcategories) == 1:
         targetcat = specifiedcategories[0]
-    elif repo['.'].obsolete() and not has_some_opts:
+    elif repo[b'.'].obsolete() and not has_some_opts:
         # if no args and parent is obsolete, update to successors
         return solveobswdp(ui, repo, opts)
 
-    ui.setconfig('ui', 'forcemerge', opts.get('tool', ''), 'evolve')
+    ui.setconfig(b'ui', b'forcemerge', opts.get(b'tool', b''), b'evolve')
 
     evolvestate = state.cmdstate(repo)
     # Continuation handling
     if contopt:
         if not evolvestate:
-            raise error.Abort(_('no interrupted evolve to continue'))
+            raise error.Abort(_(b'no interrupted evolve to continue'))
         evolvestate.load()
         continueevolve(ui, repo, evolvestate)
-        if evolvestate['command'] != 'evolve':
+        if evolvestate[b'command'] != b'evolve':
             evolvestate.delete()
             return
-        startnode = repo.unfiltered()[evolvestate['startnode']]
-        if 'update' in evolvestate:
-            shouldupdate = evolvestate['update']
+        startnode = repo.unfiltered()[evolvestate[b'startnode']]
+        if b'update' in evolvestate:
+            shouldupdate = evolvestate[b'update']
         evolvestate.delete()
     elif stopopt:
         if not evolvestate:
-            raise error.Abort(_('no interrupted evolve to stop'))
+            raise error.Abort(_(b'no interrupted evolve to stop'))
         evolvestate.load()
         stopevolve(ui, repo, evolvestate)
         evolvestate.delete()
         return
     elif abortopt:
         if not evolvestate:
-            raise error.Abort(_('no interrupted evolve to stop'))
+            raise error.Abort(_(b'no interrupted evolve to stop'))
         evolvestate.load()
         # `hg next --evolve` in play
-        if evolvestate['command'] != 'evolve':
-            pctx = repo['.']
+        if evolvestate[b'command'] != b'evolve':
+            pctx = repo[b'.']
             hg.updaterepo(repo, pctx.node(), True)
-            ui.status(_('evolve aborted\n'))
-            ui.status(_('working directory is now at %s\n')
+            ui.status(_(b'evolve aborted\n'))
+            ui.status(_(b'working directory is now at %s\n')
                       % pctx.hex()[:12])
             evolvestate.delete()
             return 0
@@ -1686,7 +1686,7 @@
         # Handling it here otherwise `revs` set would change, after
         # performing update to successor of obsolete wdir parent.
         # (in case when user passes a revset related to wdir parent '.::')
-        if repo['.'].obsolete():
+        if repo[b'.'].obsolete():
             result = solveobswdp(ui, repo, opts)
             if result != 0 or result is True:
                 return result
@@ -1701,27 +1701,27 @@
 
         def progresscb():
             if showprogress:
-                compat.progress(ui, _('evolve'), seen, unit=_('changesets'),
+                compat.progress(ui, _(b'evolve'), seen, unit=_(b'changesets'),
                                 total=count)
 
         # Order the revisions
         revs = _orderrevs(repo, revs)
 
         # cbor does not know how to serialize sets, using list for skippedrevs
-        stateopts = {'category': targetcat, 'replacements': {},
-                     'revs': list(revs), 'confirm': confirmopt,
-                     'startnode': startnode, 'skippedrevs': [],
-                     'command': 'evolve', 'orphanmerge': False,
-                     'bookmarkchanges': [], 'temprevs': [], 'obsmarkers': [],
-                     'update': shouldupdate}
+        stateopts = {b'category': targetcat, b'replacements': {},
+                     b'revs': list(revs), b'confirm': confirmopt,
+                     b'startnode': startnode, b'skippedrevs': [],
+                     b'command': b'evolve', b'orphanmerge': False,
+                     b'bookmarkchanges': [], b'temprevs': [], b'obsmarkers': [],
+                     b'update': shouldupdate}
         evolvestate.addopts(stateopts)
         # lastsolved: keep track of successor of last troubled cset we evolved
         # to confirm that if atop msg should be suppressed to remove redundancy
         lastsolved = None
 
-        activetopic = getattr(repo, 'currenttopic', '')
+        activetopic = getattr(repo, 'currenttopic', b'')
         with repo.wlock(), repo.lock():
-            tr = repo.transaction("evolve")
+            tr = repo.transaction(b"evolve")
             with util.acceptintervention(tr):
                 for rev in revs:
                     lastsolved = _solveonerev(ui, repo, rev, evolvestate,
@@ -1731,7 +1731,7 @@
                     seen += 1
 
         if showprogress:
-            compat.progress(ui, _('evolve'), None)
+            compat.progress(ui, _(b'evolve'), None)
 
     _cleanup(ui, repo, startnode, shouldupdate)
 
@@ -1743,7 +1743,7 @@
     stabilizes for both parents of orphan merges.
     """
     curctx = repo[rev]
-    revtopic = getattr(curctx, 'topic', lambda: '')()
+    revtopic = getattr(curctx, 'topic', lambda: b'')()
     topicidx = getattr(curctx, 'topicidx', lambda: None)()
     stacktmplt = False
     # check if revision being evolved is in active topic to make sure
@@ -1755,44 +1755,44 @@
                     confirmopt, progresscb, targetcat,
                     lastsolved=lastsolved, stacktmplt=stacktmplt)
     if ret[0]:
-        evolvestate['replacements'][curctx.node()] = ret[1]
+        evolvestate[b'replacements'][curctx.node()] = ret[1]
         lastsolved = ret[1]
     else:
-        evolvestate['skippedrevs'].append(curctx.node())
+        evolvestate[b'skippedrevs'].append(curctx.node())
 
-    if evolvestate['orphanmerge']:
+    if evolvestate[b'orphanmerge']:
         # we were processing an orphan merge with both parents obsolete,
         # stabilized for second parent, re-stabilize for the first parent
         ret = _solveone(ui, repo, repo[ret[1]], evolvestate, dryrunopt,
                         confirmopt, progresscb, targetcat,
                         stacktmplt=stacktmplt)
         if ret[0]:
-            evolvestate['replacements'][curctx.node()] = ret[1]
+            evolvestate[b'replacements'][curctx.node()] = ret[1]
             lastsolved = ret[1]
         else:
-            evolvestate['skippedrevs'].append(curctx.node())
+            evolvestate[b'skippedrevs'].append(curctx.node())
 
-        evolvestate['orphanmerge'] = False
+        evolvestate[b'orphanmerge'] = False
     return lastsolved
 
 def solveobswdp(ui, repo, opts):
     """this function updates to the successor of obsolete wdir parent"""
-    oldid = repo['.'].node()
-    startctx = repo['.']
-    dryrunopt = opts.get('dry_run', False)
+    oldid = repo[b'.'].node()
+    startctx = repo[b'.']
+    dryrunopt = opts.get(b'dry_run', False)
     displayer = compat.changesetdisplayer(ui, repo,
-                                          {'template': shorttemplate})
+                                          {b'template': shorttemplate})
     try:
-        ctx = repo[utility._singlesuccessor(repo, repo['.'])]
+        ctx = repo[utility._singlesuccessor(repo, repo[b'.'])]
     except utility.MultipleSuccessorsError as exc:
-        repo.ui.write_err(_('parent is obsolete with multiple'
-                            ' successors:\n'))
+        repo.ui.write_err(_(b'parent is obsolete with multiple'
+                            b' successors:\n'))
         for ln in exc.successorssets:
             for n in ln:
                 displayer.show(repo[n])
         return 2
 
-    ui.status(_('update:'))
+    ui.status(_(b'update:'))
     if not ui.quiet:
         displayer.show(ctx)
 
@@ -1802,33 +1802,33 @@
     newid = ctx.node()
 
     if ctx != startctx:
-        with repo.wlock(), repo.lock(), repo.transaction('evolve') as tr:
+        with repo.wlock(), repo.lock(), repo.transaction(b'evolve') as tr:
             bmupdater = rewriteutil.bookmarksupdater(repo, oldid, tr)
             bmupdater(newid)
-        ui.status(_('working directory is now at %s\n') % ctx)
+        ui.status(_(b'working directory is now at %s\n') % ctx)
     return res
 
 def stopevolve(ui, repo, evolvestate):
     """logic for handling of `hg evolve --stop`"""
     updated = False
     pctx = None
-    if (evolvestate['command'] == 'evolve'
-        and evolvestate['category'] == 'contentdivergent'
-        and evolvestate['relocated']):
-        oldother = evolvestate['old-other']
+    if (evolvestate[b'command'] == b'evolve'
+        and evolvestate[b'category'] == b'contentdivergent'
+        and evolvestate[b'relocated']):
+        oldother = evolvestate[b'old-other']
         if oldother:
             with repo.wlock(), repo.lock():
                 repo = repo.unfiltered()
                 hg.updaterepo(repo, oldother, True)
-                strips = [evolvestate['relocated']]
+                strips = [evolvestate[b'relocated']]
                 repair.strip(ui, repo, strips, False)
                 updated = True
                 pctx = repo[oldother]
     if not updated:
-        pctx = repo['.']
+        pctx = repo[b'.']
         hg.updaterepo(repo, pctx.node(), True)
-    ui.status(_('stopped the interrupted evolve\n'))
-    ui.status(_('working directory is now at %s\n') % pctx)
+    ui.status(_(b'stopped the interrupted evolve\n'))
+    ui.status(_(b'working directory is now at %s\n') % pctx)
 
 def abortevolve(ui, repo, evolvestate):
     """ logic for handling of `hg evolve --abort`"""
@@ -1838,11 +1838,11 @@
         evolvedctx = []
         # boolean value to say whether we should strip or not
         cleanup = True
-        startnode = evolvestate['startnode']
-        for old, new in evolvestate['replacements'].iteritems():
+        startnode = evolvestate[b'startnode']
+        for old, new in evolvestate[b'replacements'].items():
             if new:
                 evolvedctx.append(repo[new])
-        for temp in evolvestate['temprevs']:
+        for temp in evolvestate[b'temprevs']:
             if temp:
                 evolvedctx.append(repo[temp])
         evolvedrevs = [c.rev() for c in evolvedctx]
@@ -1850,9 +1850,9 @@
         # checking if phase changed of any of the evolved rev
         immutable = [c for c in evolvedctx if not c.mutable()]
         if immutable:
-            repo.ui.warn(_("cannot clean up public changesets: %s\n")
-                         % ', '.join(str(c) for c in immutable),
-                         hint=_("see 'hg help phases' for details"))
+            repo.ui.warn(_(b"cannot clean up public changesets: %s\n")
+                         % b', '.join(str(c) for c in immutable),
+                         hint=_(b"see 'hg help phases' for details"))
             cleanup = False
 
         # checking no new changesets are created on evolved revs
@@ -1860,15 +1860,15 @@
         if evolvedrevs:
             descendants = set(repo.changelog.descendants(evolvedrevs))
         if descendants - set(evolvedrevs):
-            repo.ui.warn(_("warning: new changesets detected on destination "
-                           "branch\n"))
+            repo.ui.warn(_(b"warning: new changesets detected on destination "
+                           b"branch\n"))
             cleanup = False
 
         # finding the indices of the obsmarkers to be stripped and stripping
         # them
-        if evolvestate['obsmarkers']:
+        if evolvestate[b'obsmarkers']:
             stripmarkers = set()
-            for m in evolvestate['obsmarkers']:
+            for m in evolvestate[b'obsmarkers']:
                 m = (m[0], m[1])
                 stripmarkers.add(m)
             indices = []
@@ -1879,12 +1879,12 @@
                     indices.append(i)
 
             repair.deleteobsmarkers(repo.obsstore, indices)
-            repo.ui.debug('deleted %d obsmarkers\n' % len(indices))
+            repo.ui.debug(b'deleted %d obsmarkers\n' % len(indices))
 
         if cleanup:
             if evolvedrevs:
                 strippoints = [c.node()
-                               for c in repo.set('roots(%ld)', evolvedrevs)]
+                               for c in repo.set(b'roots(%ld)', evolvedrevs)]
 
             # updating the working directory
             hg.updaterepo(repo, startnode, True)
@@ -1894,19 +1894,19 @@
                 # no backup of evolved cset versions needed
                 repair.strip(repo.ui, repo, strippoints, False)
 
-            with repo.transaction('evolve') as tr:
+            with repo.transaction(b'evolve') as tr:
                 # restoring bookmarks at there original place
-                bmchanges = evolvestate['bookmarkchanges']
+                bmchanges = evolvestate[b'bookmarkchanges']
                 if bmchanges:
                     repo._bookmarks.applychanges(repo, tr, bmchanges)
 
             evolvestate.delete()
-            ui.status(_('evolve aborted\n'))
-            ui.status(_('working directory is now at %s\n')
+            ui.status(_(b'evolve aborted\n'))
+            ui.status(_(b'working directory is now at %s\n')
                       % nodemod.hex(startnode)[:12])
         else:
-            raise error.Abort(_("unable to abort interrupted evolve, use 'hg "
-                                "evolve --stop' to stop evolve"))
+            raise error.Abort(_(b"unable to abort interrupted evolve, use 'hg "
+                                b"evolve --stop' to stop evolve"))
 
 def continueevolve(ui, repo, evolvestate):
     """logic for handling of `hg evolve --continue`"""
@@ -1914,81 +1914,81 @@
     with repo.wlock(), repo.lock():
         ms = merge.mergestate.read(repo)
         mergeutil.checkunresolved(ms)
-        if (evolvestate['command'] == 'next'
-            or evolvestate['category'] == 'orphan'):
+        if (evolvestate[b'command'] == b'next'
+            or evolvestate[b'category'] == b'orphan'):
             _completeorphan(ui, repo, evolvestate)
-        elif evolvestate['category'] == 'phasedivergent':
+        elif evolvestate[b'category'] == b'phasedivergent':
             _completephasedivergent(ui, repo, evolvestate)
-        elif evolvestate['category'] == 'contentdivergent':
+        elif evolvestate[b'category'] == b'contentdivergent':
             _continuecontentdivergent(ui, repo, evolvestate, None)
         else:
-            repo.ui.status(_("continuing interrupted '%s' resolution is not yet"
-                             " supported\n") % evolvestate['category'])
+            repo.ui.status(_(b"continuing interrupted '%s' resolution is not yet"
+                             b" supported\n") % evolvestate[b'category'])
             return
 
         # make sure we are continuing evolve and not `hg next --evolve`
-        if evolvestate['command'] != 'evolve':
+        if evolvestate[b'command'] != b'evolve':
             return
 
         # Progress handling
         seen = 1
-        count = len(evolvestate['revs'])
+        count = len(evolvestate[b'revs'])
 
         def progresscb():
-            compat.progress(ui, _('evolve'), seen, unit=_('changesets'),
+            compat.progress(ui, _(b'evolve'), seen, unit=_(b'changesets'),
                             total=count)
 
-        category = evolvestate['category']
-        confirm = evolvestate['confirm']
+        category = evolvestate[b'category']
+        confirm = evolvestate[b'confirm']
         unfi = repo.unfiltered()
         # lastsolved: keep track of successor of last troubled cset we
         # evolved to confirm that if atop msg should be suppressed to remove
         # redundancy
         lastsolved = None
-        activetopic = getattr(repo, 'currenttopic', '')
-        tr = repo.transaction("evolve")
+        activetopic = getattr(repo, 'currenttopic', b'')
+        tr = repo.transaction(b"evolve")
         with util.acceptintervention(tr):
-            for rev in evolvestate['revs']:
+            for rev in evolvestate[b'revs']:
                 # XXX: prevent this lookup by storing nodes instead of revnums
                 curctx = unfi[rev]
 
                 # check if we can use stack template
-                revtopic = getattr(curctx, 'topic', lambda: '')()
+                revtopic = getattr(curctx, 'topic', lambda: b'')()
                 topicidx = getattr(curctx, 'topicidx', lambda: None)()
                 stacktmplt = False
                 if (activetopic and (activetopic == revtopic)
                     and topicidx is not None):
                     stacktmplt = True
 
-                if (curctx.node() not in evolvestate['replacements']
-                    and curctx.node() not in evolvestate['skippedrevs']):
+                if (curctx.node() not in evolvestate[b'replacements']
+                    and curctx.node() not in evolvestate[b'skippedrevs']):
                     newnode = _solveone(ui, repo, curctx, evolvestate, False,
                                         confirm, progresscb, category,
                                         lastsolved=lastsolved,
                                         stacktmplt=stacktmplt)
                     if newnode[0]:
-                        evolvestate['replacements'][curctx.node()] = newnode[1]
+                        evolvestate[b'replacements'][curctx.node()] = newnode[1]
                         lastsolved = newnode[1]
                     else:
-                        evolvestate['skippedrevs'].append(curctx.node())
+                        evolvestate[b'skippedrevs'].append(curctx.node())
                 seen += 1
 
 def _continuecontentdivergent(ui, repo, evolvestate, progresscb):
     """function to continue the interrupted content-divergence resolution."""
-    tr = repo.transaction('evolve')
+    tr = repo.transaction(b'evolve')
     with util.acceptintervention(tr):
-        divergent = evolvestate['divergent']
-        base = evolvestate['base']
+        divergent = evolvestate[b'divergent']
+        base = evolvestate[b'base']
         repo = repo.unfiltered()
-        if evolvestate['relocating']:
+        if evolvestate[b'relocating']:
             newother = _completerelocation(ui, repo, evolvestate)
-            current = repo[evolvestate['current']]
+            current = repo[evolvestate[b'current']]
             obsolete.createmarkers(repo, [(current, (repo[newother],))],
-                                   operation='evolve')
-            evolvestate['relocating'] = False
-            evolvestate['relocated'] = newother
-            evolvestate['temprevs'].append(newother)
-            evolvestate['other-divergent'] = newother
+                                   operation=b'evolve')
+            evolvestate[b'relocating'] = False
+            evolvestate[b'relocated'] = newother
+            evolvestate[b'temprevs'].append(newother)
+            evolvestate[b'other-divergent'] = newother
             # continue the resolution by merging the content-divergence
             _mergecontentdivergents(repo, progresscb,
                                     repo[divergent],
@@ -1996,16 +1996,16 @@
                                     repo[base],
                                     evolvestate)
 
-        other = evolvestate['other-divergent']
+        other = evolvestate[b'other-divergent']
         ret = _completecontentdivergent(ui, repo, progresscb,
                                         repo[divergent],
                                         repo[other],
                                         repo[base],
                                         evolvestate)
-        origdivergent = evolvestate['orig-divergent']
-        evolvestate['replacements'][origdivergent] = ret[1]
+        origdivergent = evolvestate[b'orig-divergent']
+        evolvestate[b'replacements'][origdivergent] = ret[1]
         # logic to continue the public content-divergent
-        publicnode = evolvestate.get('public-divergent')
+        publicnode = evolvestate.get(b'public-divergent')
         if publicnode:
             res, newnode = ret
             if not res:
@@ -2028,19 +2028,19 @@
     phase-divergence"""
 
     # need to start transaction for bookmark changes
-    with repo.transaction('evolve'):
+    with repo.transaction(b'evolve'):
         node = _completerelocation(ui, repo, evolvestate)
-        evolvestate['temprevs'].append(node)
+        evolvestate[b'temprevs'].append(node)
         # resolving conflicts can lead to empty wdir and node can be None in
         # those cases
-        ctx = repo[evolvestate['current']]
-        newctx = repo[node] if node is not None else repo['.']
-        obsolete.createmarkers(repo, [(ctx, (newctx,))], operation='evolve')
+        ctx = repo[evolvestate[b'current']]
+        newctx = repo[node] if node is not None else repo[b'.']
+        obsolete.createmarkers(repo, [(ctx, (newctx,))], operation=b'evolve')
 
         # now continuing the phase-divergence resolution part
-        prec = repo[evolvestate['precursor']]
+        prec = repo[evolvestate[b'precursor']]
         retvalue = _resolvephasedivergent(ui, repo, prec, newctx)
-        evolvestate['replacements'][ctx.node()] = retvalue[1]
+        evolvestate[b'replacements'][ctx.node()] = retvalue[1]
 
 def _completeorphan(ui, repo, evolvestate):
     """function to complete the interrupted orphan resolution"""
@@ -2048,44 +2048,44 @@
     node = _completerelocation(ui, repo, evolvestate)
     # resolving conflicts can lead to empty wdir and node can be None in
     # those cases
-    ctx = repo[evolvestate['current']]
+    ctx = repo[evolvestate[b'current']]
     if node is None:
-        repo.ui.status(_("evolution of %d:%s created no changes"
-                         " to commit\n") % (ctx.rev(), ctx))
-    newctx = repo[node] if node is not None else repo['.']
-    obsolete.createmarkers(repo, [(ctx, (newctx,))], operation='evolve')
+        repo.ui.status(_(b"evolution of %d:%s created no changes"
+                         b" to commit\n") % (ctx.rev(), ctx))
+    newctx = repo[node] if node is not None else repo[b'.']
+    obsolete.createmarkers(repo, [(ctx, (newctx,))], operation=b'evolve')
 
     # make sure we are continuing evolve and not `hg next --evolve`
-    if evolvestate['command'] == 'evolve':
-        evolvestate['replacements'][ctx.node()] = node
-        if evolvestate['orphanmerge']:
+    if evolvestate[b'command'] == b'evolve':
+        evolvestate[b'replacements'][ctx.node()] = node
+        if evolvestate[b'orphanmerge']:
             # processing a merge changeset with both parents obsoleted,
             # stabilized on second parent, insert in front of list to
             # re-process to stabilize on first parent
-            evolvestate['revs'].insert(0, repo[node].rev())
-            evolvestate['orphanmerge'] = False
+            evolvestate[b'revs'].insert(0, repo[node].rev())
+            evolvestate[b'orphanmerge'] = False
 
 def _completerelocation(ui, repo, evolvestate):
     """function to complete the interrupted relocation of a commit
     return the new node formed
     """
 
-    orig = repo[evolvestate['current']]
+    orig = repo[evolvestate[b'current']]
     ctx = orig
-    source = ctx.extra().get('source')
+    source = ctx.extra().get(b'source')
     extra = {}
     if source:
-        extra['source'] = source
-        extra['intermediate-source'] = ctx.hex()
+        extra[b'source'] = source
+        extra[b'intermediate-source'] = ctx.hex()
     else:
-        extra['source'] = ctx.hex()
+        extra[b'source'] = ctx.hex()
     user = ctx.user()
     date = ctx.date()
     message = ctx.description()
-    ui.status(_('evolving %d:%s "%s"\n') % (ctx.rev(), ctx,
-                                            message.split('\n', 1)[0]))
+    ui.status(_(b'evolving %d:%s "%s"\n') % (ctx.rev(), ctx,
+                                             message.split(b'\n', 1)[0]))
     targetphase = max(ctx.phase(), phases.draft)
-    overrides = {('phases', 'new-commit'): targetphase}
+    overrides = {(b'phases', b'new-commit'): targetphase}
 
     ctxparents = orig.parents()
     if len(ctxparents) == 2:
@@ -2112,7 +2112,7 @@
         else:
             # both the parents were obsoleted, if orphanmerge is set, we
             # are processing the second parent first (to keep parent order)
-            if evolvestate.get('orphanmerge'):
+            if evolvestate.get(b'orphanmerge'):
                 with repo.dirstate.parentchange():
                     repo.dirstate.setparents(ctxparents[0].node(),
                                              currentp1)
@@ -2121,7 +2121,7 @@
         with repo.dirstate.parentchange():
             repo.dirstate.setparents(repo.dirstate.parents()[0], nodemod.nullid)
 
-    with repo.ui.configoverride(overrides, 'evolve-continue'):
+    with repo.ui.configoverride(overrides, b'evolve-continue'):
         node = repo.commit(text=message, user=user,
                            date=date, extra=extra)
     return node
diff --git a/hgext3rd/evolve/exthelper.py b/hgext3rd/evolve/exthelper.py
--- a/hgext3rd/evolve/exthelper.py
+++ b/hgext3rd/evolve/exthelper.py
@@ -83,12 +83,12 @@
         self._duckpunchers = []
         self.cmdtable = {}
         self.command = registrar.command(self.cmdtable)
-        if '^init' in commands.table:
+        if b'^init' in commands.table:
             olddoregister = self.command._doregister
 
             def _newdoregister(self, name, *args, **kwargs):
-                if kwargs.pop('helpbasic', False):
-                    name = '^' + name
+                if kwargs.pop(b'helpbasic', False):
+                    name = b'^' + name
                 return olddoregister(self, name, *args, **kwargs)
             self.command._doregister = _newdoregister
 
@@ -111,7 +111,7 @@
         self._functionwrappers.extend(other._functionwrappers)
         self._duckpunchers.extend(other._duckpunchers)
         self.cmdtable.update(other.cmdtable)
-        for section, items in other.configtable.iteritems():
+        for section, items in other.configtable.items():
             if section in self.configtable:
                 self.configtable[section].update(items)
             else:
@@ -277,9 +277,9 @@
         else:
             for opt in opts:
                 if not isinstance(opt, tuple):
-                    raise error.ProgrammingError('opts must be list of tuples')
+                    raise error.ProgrammingError(b'opts must be list of tuples')
                 if len(opt) not in (4, 5):
-                    msg = 'each opt tuple must contain 4 or 5 values'
+                    msg = b'each opt tuple must contain 4 or 5 values'
                     raise error.ProgrammingError(msg)
 
         def dec(wrapper):
diff --git a/hgext3rd/evolve/firstmergecache.py b/hgext3rd/evolve/firstmergecache.py
--- a/hgext3rd/evolve/firstmergecache.py
+++ b/hgext3rd/evolve/firstmergecache.py
@@ -41,7 +41,7 @@
 
         @localrepo.unfilteredmethod
         def destroyed(self):
-            if 'firstmergecach' in vars(self):
+            if b'firstmergecach' in vars(self):
                 self.firstmergecache.clear()
             super(firstmergecacherepo, self).destroyed()
 
@@ -56,16 +56,16 @@
 
 class firstmergecache(genericcaches.changelogsourcebase):
 
-    _filepath = 'evoext-firstmerge-00'
-    _cachename = 'evo-ext-firstmerge'
+    _filepath = b'evoext-firstmerge-00'
+    _cachename = b'evo-ext-firstmerge'
 
     def __init__(self):
         super(firstmergecache, self).__init__()
-        self._data = array.array('l')
+        self._data = array.array(b'l')
 
     def get(self, rev):
         if len(self._data) <= rev:
-            raise error.ProgrammingError('firstmergecache must be warmed before use')
+            raise error.ProgrammingError(b'firstmergecache must be warmed before use')
         return self._data[rev]
 
     def _updatefrom(self, repo, data):
@@ -75,15 +75,15 @@
         total = len(data)
 
         def progress(pos, rev):
-            compat.progress(repo.ui, 'updating firstmerge cache',
-                            pos, 'rev %s' % rev, unit='revision', total=total)
-        progress(0, '')
+            compat.progress(repo.ui, b'updating firstmerge cache',
+                            pos, b'rev %s' % rev, unit=b'revision', total=total)
+        progress(0, b'')
         for idx, rev in enumerate(data, 1):
             assert rev == len(self._data), (rev, len(self._data))
             self._data.append(self._firstmerge(cl, rev))
             if not (idx % 10000): # progress as a too high performance impact
                 progress(idx, rev)
-        progress(None, '')
+        progress(None, b'')
 
     def _firstmerge(self, changelog, rev):
         cl = changelog
@@ -107,7 +107,7 @@
         Subclasses MUST overide this method to actually affect the cache data.
         """
         super(firstmergecache, self).clear()
-        self._data = array.array('l')
+        self._data = array.array(b'l')
 
     # crude version of a cache, to show the kind of information we have to store
 
@@ -116,7 +116,7 @@
         assert repo.filtername is None
 
         data = repo.cachevfs.tryread(self._filepath)
-        self._data = array.array('l')
+        self._data = array.array(b'l')
         if not data:
             self._cachekey = self.emptykey
         else:
@@ -135,12 +135,12 @@
             return
 
         try:
-            cachefile = repo.cachevfs(self._filepath, 'w', atomictemp=True)
+            cachefile = repo.cachevfs(self._filepath, b'w', atomictemp=True)
             headerdata = self._serializecachekey()
             cachefile.write(headerdata)
             cachefile.write(self._data.tostring())
             cachefile.close()
             self._ondiskkey = self._cachekey
         except (IOError, OSError) as exc:
-            repo.ui.log('firstmergecache', 'could not write update %s\n' % exc)
-            repo.ui.debug('firstmergecache: could not write update %s\n' % exc)
+            repo.ui.log(b'firstmergecache', b'could not write update %s\n' % exc)
+            repo.ui.debug(b'firstmergecache: could not write update %s\n' % exc)
diff --git a/hgext3rd/evolve/genericcaches.py b/hgext3rd/evolve/genericcaches.py
--- a/hgext3rd/evolve/genericcaches.py
+++ b/hgext3rd/evolve/genericcaches.py
@@ -31,7 +31,7 @@
     # default key used for an empty cache
     emptykey = ()
 
-    _cachekeyspec = '' # used for serialization
+    _cachekeyspec = b'' # used for serialization
     _cachename = None # used for debug message
 
     @abc.abstractmethod
@@ -42,7 +42,7 @@
     @util.propertycache
     def _cachekeystruct(self):
         # dynamic property to help subclass to change it
-        return struct.Struct('>' + self._cachekeyspec)
+        return struct.Struct(b'>' + self._cachekeyspec)
 
     @util.propertycache
     def _cachekeysize(self):
@@ -112,7 +112,7 @@
         if newkey == self._cachekey:
             return
         if reset or self._cachekey is None:
-            repo.ui.log('cache', 'strip detected, %s cache reset\n'
+            repo.ui.log(b'cache', b'strip detected, %s cache reset\n'
                         % self._cachename)
             self.clear(reset=True)
 
@@ -120,7 +120,7 @@
         self._updatefrom(repo, data)
         duration = util.timer() - starttime
         summary = self._updatesummary(data)
-        repo.ui.log('cache', 'updated %s in %.4f seconds (%s)\n',
+        repo.ui.log(b'cache', b'updated %s in %.4f seconds (%s)\n',
                     self._cachename, duration, summary)
 
         self._cachekey = newkey
@@ -144,7 +144,7 @@
 
     # default key used for an empty cache
     emptykey = (0, node.nullid)
-    _cachekeyspec = 'i20s'
+    _cachekeyspec = b'i20s'
     _cachename = None # used for debug message
 
     # Useful "public" function (no need to override them)
@@ -172,4 +172,4 @@
         return self._fetchchangelogdata(self._cachekey, repo.changelog)
 
     def _updatesummary(self, data):
-        return '%ir' % len(data)
+        return b'%ir' % len(data)
diff --git a/hgext3rd/evolve/hack/drophack.py b/hgext3rd/evolve/hack/drophack.py
--- a/hgext3rd/evolve/hack/drophack.py
+++ b/hgext3rd/evolve/hack/drophack.py
@@ -34,7 +34,7 @@
     user = ostop[0] - ostart[0]
     sys = ostop[1] - ostart[1]
     comb = user + sys
-    ui.write("%s: wall %f comb %f user %f sys %f\n"
+    ui.write(b"%s: wall %f comb %f user %f sys %f\n"
              % (caption, wall, comb, user, sys))
 
 def obsmarkerchainfrom(obsstore, nodes):
@@ -66,13 +66,13 @@
     repo = repo.unfiltered()
     repo.destroying()
     oldmarkers = list(repo.obsstore._all)
-    util.rename(repo.svfs.join('obsstore'),
-                repo.vfs.join('obsstore.prestrip'))
+    util.rename(repo.svfs.join(b'obsstore'),
+                repo.vfs.join(b'obsstore.prestrip'))
     del repo.obsstore # drop the cache
     newstore = repo.obsstore
     assert not newstore # should be empty after rename
     newmarkers = [m for m in oldmarkers if m not in markers]
-    tr = repo.transaction('drophack')
+    tr = repo.transaction(b'drophack')
     try:
         newstore.add(tr, newmarkers)
         tr.close()
@@ -81,7 +81,7 @@
     repo.destroyed()
 
 
- at command('drop', [('r', 'rev', [], 'revision to update')], _('[-r] revs'))
+ at command(b'drop', [(b'r', b'rev', [], b'revision to update')], _(b'[-r] revs'))
 def cmddrop(ui, repo, *revs, **opts):
     """I'm hacky do not use me!
 
@@ -95,13 +95,13 @@
     This intended for Matt Mackall usage only. do not use me.
     """
     revs = list(revs)
-    revs.extend(opts['rev'])
+    revs.extend(opts[b'rev'])
     if not revs:
-        revs = ['.']
+        revs = [b'.']
     # get the changeset
     revs = scmutil.revrange(repo, revs)
     if not revs:
-        ui.write_err('no revision to drop\n')
+        ui.write_err(b'no revision to drop\n')
         return 1
     # lock from the beginning to prevent race
     wlock = lock = None
@@ -109,49 +109,49 @@
         wlock = repo.wlock()
         lock = repo.lock()
         # check they have no children
-        if repo.revs('%ld and public()', revs):
-            ui.write_err('cannot drop public revision')
+        if repo.revs(b'%ld and public()', revs):
+            ui.write_err(b'cannot drop public revision')
             return 1
-        if repo.revs('children(%ld) - %ld', revs, revs):
-            ui.write_err('cannot drop revision with children')
+        if repo.revs(b'children(%ld) - %ld', revs, revs):
+            ui.write_err(b'cannot drop revision with children')
             return 1
-        if repo.revs('. and %ld', revs):
-            newrevs = repo.revs('max(::. - %ld)', revs)
+        if repo.revs(b'. and %ld', revs):
+            newrevs = repo.revs(b'max(::. - %ld)', revs)
             if newrevs:
                 assert len(newrevs) == 1
                 newrev = newrevs.first()
             else:
                 newrev = -1
             commands.update(ui, repo, newrev)
-            ui.status(_('working directory now at %s\n') % repo[newrev])
+            ui.status(_(b'working directory now at %s\n') % repo[newrev])
         # get all markers and successors up to root
         nodes = [repo[r].node() for r in revs]
-        with timed(ui, 'search obsmarker'):
+        with timed(ui, b'search obsmarker'):
             markers = set(obsmarkerchainfrom(repo.obsstore, nodes))
-        ui.write('%i obsmarkers found\n' % len(markers))
+        ui.write(b'%i obsmarkers found\n' % len(markers))
         cl = repo.unfiltered().changelog
-        with timed(ui, 'search nodes'):
+        with timed(ui, b'search nodes'):
             allnodes = set(nodes)
             allnodes.update(m[0] for m in markers if cl.hasnode(m[0]))
-        ui.write('%i nodes found\n' % len(allnodes))
+        ui.write(b'%i nodes found\n' % len(allnodes))
         cl = repo.changelog
         visiblenodes = set(n for n in allnodes if cl.hasnode(n))
         # check constraint again
-        if repo.revs('%ln and public()', visiblenodes):
-            ui.write_err('cannot drop public revision')
+        if repo.revs(b'%ln and public()', visiblenodes):
+            ui.write_err(b'cannot drop public revision')
             return 1
-        if repo.revs('children(%ln) - %ln', visiblenodes, visiblenodes):
-            ui.write_err('cannot drop revision with children')
+        if repo.revs(b'children(%ln) - %ln', visiblenodes, visiblenodes):
+            ui.write_err(b'cannot drop revision with children')
             return 1
 
         if markers:
             # strip them
-            with timed(ui, 'strip obsmarker'):
+            with timed(ui, b'strip obsmarker'):
                 stripmarker(ui, repo, markers)
         # strip the changeset
-        with timed(ui, 'strip nodes'):
-            repair.strip(ui, repo, list(allnodes), backup="all",
-                         topic='drophack')
+        with timed(ui, b'strip nodes'):
+            repair.strip(ui, repo, list(allnodes), backup=b"all",
+                         topic=b'drophack')
 
     finally:
         lockmod.release(lock, wlock)
diff --git a/hgext3rd/evolve/legacy.py b/hgext3rd/evolve/legacy.py
--- a/hgext3rd/evolve/legacy.py
+++ b/hgext3rd/evolve/legacy.py
@@ -45,20 +45,20 @@
     """
     if not repo.local():
         return
-    evolveopts = ui.configlist('experimental', 'evolution')
+    evolveopts = ui.configlist(b'experimental', b'evolution')
     if not evolveopts:
-        evolveopts = 'all'
-        ui.setconfig('experimental', 'evolution', evolveopts)
+        evolveopts = b'all'
+        ui.setconfig(b'experimental', b'evolution', evolveopts)
     for arg in sys.argv:
-        if 'debugc' in arg:
+        if b'debugc' in arg:
             break
     else:
-        data = repo.vfs.tryread('obsolete-relations')
+        data = repo.vfs.tryread(b'obsolete-relations')
         if not data:
-            data = repo.svfs.tryread('obsoletemarkers')
+            data = repo.svfs.tryread(b'obsoletemarkers')
         if data:
-            raise error.Abort('old format of obsolete marker detected!\n'
-                              'run `hg debugconvertobsolete` once.')
+            raise error.Abort(b'old format of obsolete marker detected!\n'
+                              b'run `hg debugconvertobsolete` once.')
 
 def _obsdeserialize(flike):
     """read a file like object serialized with _obsserialize
@@ -77,7 +77,7 @@
 
 cmdtable = {}
 command = commandfunc(cmdtable)
- at command('debugconvertobsolete', [], '')
+ at command(b'debugconvertobsolete', [], b'')
 def cmddebugconvertobsolete(ui, repo):
     """import markers from an .hg/obsolete-relations file"""
     cnt = 0
@@ -86,13 +86,13 @@
     some = False
     try:
         unlink = []
-        tr = repo.transaction('convert-obsolete')
+        tr = repo.transaction(b'convert-obsolete')
         try:
             repo._importoldobsolete = True
             store = repo.obsstore
             ### very first format
             try:
-                f = repo.vfs('obsolete-relations')
+                f = repo.vfs(b'obsolete-relations')
                 try:
                     some = True
                     for line in f:
@@ -101,30 +101,30 @@
                         prec = bin(objhex)
                         sucs = (suc == nullid) and [] or [suc]
                         meta = {
-                            'date': '%i %i' % makedate(),
-                            'user': ui.username(),
+                            b'date': b'%i %i' % makedate(),
+                            b'user': ui.username(),
                             }
                         try:
                             store.create(tr, prec, sucs, 0, metadata=meta)
                             cnt += 1
                         except ValueError:
-                            repo.ui.write_err("invalid old marker line: %s"
+                            repo.ui.write_err(b"invalid old marker line: %s"
                                               % (line))
                             err += 1
                 finally:
                     f.close()
-                unlink.append(repo.vfs.join('obsolete-relations'))
+                unlink.append(repo.vfs.join(b'obsolete-relations'))
             except IOError:
                 pass
             ### second (json) format
-            data = repo.svfs.tryread('obsoletemarkers')
+            data = repo.svfs.tryread(b'obsoletemarkers')
             if data:
                 some = True
                 for oldmark in json.loads(data):
-                    del oldmark['id']  # dropped for now
-                    del oldmark['reason']  # unused until then
-                    oldobject = str(oldmark.pop('object'))
-                    oldsubjects = [str(s) for s in oldmark.pop('subjects', [])]
+                    del oldmark[b'id']  # dropped for now
+                    del oldmark[b'reason']  # unused until then
+                    oldobject = str(oldmark.pop(b'object'))
+                    oldsubjects = [str(s) for s in oldmark.pop(b'subjects', [])]
                     lookup_errors = (error.RepoLookupError, error.LookupError)
                     if len(oldobject) != 40:
                         try:
@@ -137,9 +137,9 @@
                         except lookup_errors:
                             pass
 
-                    oldmark['date'] = '%i %i' % tuple(oldmark['date'])
+                    oldmark[b'date'] = b'%i %i' % tuple(oldmark[b'date'])
                     meta = dict((k.encode('utf-8'), v.encode('utf-8'))
-                                for k, v in oldmark.iteritems())
+                                for k, v in oldmark.items())
                     try:
                         succs = [bin(n) for n in oldsubjects]
                         succs = [n for n in succs if n != nullid]
@@ -147,11 +147,11 @@
                                      0, metadata=meta)
                         cnt += 1
                     except ValueError:
-                        msg = "invalid marker %s -> %s\n"
+                        msg = b"invalid marker %s -> %s\n"
                         msg %= (oldobject, oldsubjects)
                         repo.ui.write_err(msg)
                         err += 1
-                unlink.append(repo.svfs.join('obsoletemarkers'))
+                unlink.append(repo.svfs.join(b'obsoletemarkers'))
             tr.close()
             for path in unlink:
                 util.unlink(path)
@@ -161,12 +161,12 @@
         del repo._importoldobsolete
         lock.release()
     if not some:
-        ui.warn(_('nothing to do\n'))
-    ui.status('%i obsolete marker converted\n' % cnt)
+        ui.warn(_(b'nothing to do\n'))
+    ui.status(b'%i obsolete marker converted\n' % cnt)
     if err:
-        ui.write_err('%i conversion failed. check you graph!\n' % err)
+        ui.write_err(b'%i conversion failed. check you graph!\n' % err)
 
- at command('debugrecordpruneparents', [], '')
+ at command(b'debugrecordpruneparents', [], b'')
 def cmddebugrecordpruneparents(ui, repo):
     """add parent data to prune markers when possible
 
@@ -174,14 +174,14 @@
     If the pruned node is locally known, it creates a new marker with parent
     data.
     """
-    pgop = 'reading markers'
+    pgop = b'reading markers'
 
     # lock from the beginning to prevent race
     wlock = lock = tr = None
     try:
         wlock = repo.wlock()
         lock = repo.lock()
-        tr = repo.transaction('recordpruneparents')
+        tr = repo.transaction(b'recordpruneparents')
         unfi = repo.unfiltered()
         nm = unfi.changelog.nodemap
         store = repo.obsstore
@@ -196,7 +196,7 @@
                     store.create(tr, prec=mark[0], succs=mark[1], flag=mark[2],
                                  metadata=dict(mark[3]), parents=parents)
                     if len(store._all) - before:
-                        ui.write(_('created new markers for %i\n') % rev)
+                        ui.write(_(b'created new markers for %i\n') % rev)
             ui.progress(pgop, idx, total=pgtotal)
         tr.close()
         ui.progress(pgop, None)
diff --git a/hgext3rd/evolve/metadata.py b/hgext3rd/evolve/metadata.py
--- a/hgext3rd/evolve/metadata.py
+++ b/hgext3rd/evolve/metadata.py
@@ -5,7 +5,7 @@
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
-__version__ = '9.0.0'
-testedwith = '4.5.2 4.6.2 4.7 4.8 4.9 5.0'
-minimumhgversion = '4.5'
-buglink = 'https://bz.mercurial-scm.org/'
+__version__ = b'9.0.0'
+testedwith = b'4.5.2 4.6.2 4.7 4.8 4.9 5.0'
+minimumhgversion = b'4.5'
+buglink = b'https://bz.mercurial-scm.org/'
diff --git a/hgext3rd/evolve/obscache.py b/hgext3rd/evolve/obscache.py
--- a/hgext3rd/evolve/obscache.py
+++ b/hgext3rd/evolve/obscache.py
@@ -28,7 +28,7 @@
 obsstorefilecache = localrepo.localrepository.obsstore
 
 # obsstore is a filecache so we have do to some spacial dancing
- at eh.wrapfunction(obsstorefilecache, 'func')
+ at eh.wrapfunction(obsstorefilecache, b'func')
 def obsstorewithcache(orig, repo):
     obsstore = orig(repo)
     obsstore.obscache = obscache(repo.unfiltered())
@@ -50,10 +50,10 @@
             length, cachekey will be set to None."""
             # default value
             obsstoresize = 0
-            keydata = ''
+            keydata = b''
             # try to get actual data from the obsstore
             try:
-                with self.svfs('obsstore') as obsfile:
+                with self.svfs(b'obsstore') as obsfile:
                     obsfile.seek(0, 2)
                     obsstoresize = obsfile.tell()
                     if index is None:
@@ -82,11 +82,11 @@
 def markersfrom(obsstore, byteoffset, firstmarker):
     if not firstmarker:
         return list(obsstore)
-    elif '_all' in vars(obsstore):
+    elif b'_all' in vars(obsstore):
         # if the data are in memory, just use that
         return obsstore._all[firstmarker:]
     else:
-        obsdata = obsstore.svfs.tryread('obsstore')
+        obsdata = obsstore.svfs.tryread(b'obsstore')
         return obsolete._readmarkers(obsdata, byteoffset)[1]
 
 
@@ -178,7 +178,7 @@
 
         reset, revs, obsmarkers, obskeypair = upgrade
         if reset or self._cachekey is None:
-            repo.ui.log('evoext-cache', 'strip detected, %s cache reset\n' % self._cachename)
+            repo.ui.log(b'evoext-cache', b'strip detected, %s cache reset\n' % self._cachename)
             self.clear(reset=True)
 
         starttime = util.timer()
@@ -186,7 +186,7 @@
         obsmarkers = list(obsmarkers)
         self._updatefrom(repo, revs, obsmarkers)
         duration = util.timer() - starttime
-        repo.ui.log('evoext-cache', 'updated %s in %.4f seconds (%sr, %so)\n',
+        repo.ui.log(b'evoext-cache', b'updated %s in %.4f seconds (%sr, %so)\n',
                     self._cachename, duration, len(revs), len(obsmarkers))
 
         # update the key from the new data
@@ -314,10 +314,10 @@
         zero. That would be especially useful for the '.pending' overlay.
     """
 
-    _filepath = 'evoext-obscache-00'
-    _headerformat = '>q20sQQ20s'
+    _filepath = b'evoext-obscache-00'
+    _headerformat = b'>q20sQQ20s'
 
-    _cachename = 'evo-ext-obscache' # used for error message
+    _cachename = b'evo-ext-obscache' # used for error message
 
     def __init__(self, repo):
         super(obscache, self).__init__()
@@ -339,7 +339,7 @@
     def _setdata(self, data):
         """set a new bytearray data, invalidating the 'get' shortcut if needed"""
         self._data = data
-        if 'get' in vars(self):
+        if b'get' in vars(self):
             del self.get
 
     def clear(self, reset=False):
@@ -403,15 +403,15 @@
             return
 
         try:
-            cachefile = repo.cachevfs(self._filepath, 'w', atomictemp=True)
+            cachefile = repo.cachevfs(self._filepath, b'w', atomictemp=True)
             headerdata = struct.pack(self._headerformat, *self._cachekey)
             cachefile.write(headerdata)
             cachefile.write(self._data)
             cachefile.close()
             self._ondiskkey = self._cachekey
         except (IOError, OSError) as exc:
-            repo.ui.log('obscache', 'could not write update %s\n' % exc)
-            repo.ui.debug('obscache: could not write update %s\n' % exc)
+            repo.ui.log(b'obscache', b'could not write update %s\n' % exc)
+            repo.ui.debug(b'obscache: could not write update %s\n' % exc)
 
     def load(self, repo):
         """load data from disk"""
@@ -447,10 +447,10 @@
         # will be about as fast...
         if not obscache.uptodate(repo):
             if repo.currenttransaction() is None:
-                repo.ui.log('evoext-cache',
-                            'obscache is out of date, '
-                            'falling back to slower obsstore version\n')
-                repo.ui.debug('obscache is out of date\n')
+                repo.ui.log(b'evoext-cache',
+                            b'obscache is out of date, '
+                            b'falling back to slower obsstore version\n')
+                repo.ui.debug(b'obscache is out of date\n')
                 return orig(repo)
             else:
                 # If a transaction is open, it is worthwhile to update and use
@@ -465,9 +465,9 @@
 
 @eh.uisetup
 def cachefuncs(ui):
-    orig = obsolete.cachefuncs['obsolete']
+    orig = obsolete.cachefuncs[b'obsolete']
     wrapped = lambda repo: _computeobsoleteset(orig, repo)
-    obsolete.cachefuncs['obsolete'] = wrapped
+    obsolete.cachefuncs[b'obsolete'] = wrapped
 
 @eh.reposetup
 def setupcache(ui, repo):
@@ -476,7 +476,7 @@
 
         @localrepo.unfilteredmethod
         def destroyed(self):
-            if 'obsstore' in vars(self):
+            if b'obsstore' in vars(self):
                 self.obsstore.obscache.clear()
             super(obscacherepo, self).destroyed()
 
diff --git a/hgext3rd/evolve/obsdiscovery.py b/hgext3rd/evolve/obsdiscovery.py
--- a/hgext3rd/evolve/obsdiscovery.py
+++ b/hgext3rd/evolve/obsdiscovery.py
@@ -59,11 +59,11 @@
 obsexcmsg = utility.obsexcmsg
 
 # Config
-eh.configitem('experimental', 'evolution.obsdiscovery', True)
-eh.configitem('experimental', 'obshashrange', True)
-eh.configitem('experimental', 'obshashrange.warm-cache', 'auto')
-eh.configitem('experimental', 'obshashrange.max-revs', None)
-eh.configitem('experimental', 'obshashrange.lru-size', 2000)
+eh.configitem(b'experimental', b'evolution.obsdiscovery', True)
+eh.configitem(b'experimental', b'obshashrange', True)
+eh.configitem(b'experimental', b'obshashrange.warm-cache', b'auto')
+eh.configitem(b'experimental', b'obshashrange.max-revs', None)
+eh.configitem(b'experimental', b'obshashrange.lru-size', 2000)
 
 ##################################
 ###  Code performing discovery ###
@@ -75,7 +75,7 @@
     missing = set()
     starttime = util.timer()
 
-    heads = local.revs('heads(%ld)', probeset)
+    heads = local.revs(b'heads(%ld)', probeset)
     local.stablerange.warmup(local)
 
     rangelength = local.stablerange.rangelength
@@ -103,8 +103,8 @@
 
     local.obsstore.rangeobshashcache.update(local)
     querycount = 0
-    compat.progress(ui, _("comparing obsmarker with other"), querycount,
-                    unit=_("queries"))
+    compat.progress(ui, _(b"comparing obsmarker with other"), querycount,
+                    unit=_(b"queries"))
     overflow = []
     while sample or overflow:
         if overflow:
@@ -116,7 +116,7 @@
             overflow = sample[samplesize:]
             sample = sample[:samplesize]
         elif len(sample) < samplesize:
-            ui.debug("query %i; add more sample (target %i, current %i)\n"
+            ui.debug(b"query %i; add more sample (target %i, current %i)\n"
                      % (querycount, samplesize, len(sample)))
             # we need more sample !
             needed = samplesize - len(sample)
@@ -142,7 +142,7 @@
 
         nbsample = len(sample)
         maxsize = max([rangelength(local, r) for r in sample])
-        ui.debug("query %i; sample size is %i, largest range %i\n"
+        ui.debug(b"query %i; sample size is %i, largest range %i\n"
                  % (querycount, nbsample, maxsize))
         nbreplies = 0
         replies = list(_queryrange(ui, local, remote, sample))
@@ -159,15 +159,15 @@
                     addentry(new)
         assert nbsample == nbreplies
         querycount += 1
-        compat.progress(ui, _("comparing obsmarker with other"), querycount,
-                        unit=_("queries"))
-    compat.progress(ui, _("comparing obsmarker with other"), None)
+        compat.progress(ui, _(b"comparing obsmarker with other"), querycount,
+                        unit=_(b"queries"))
+    compat.progress(ui, _(b"comparing obsmarker with other"), None)
     local.obsstore.rangeobshashcache.save(local)
     duration = util.timer() - starttime
-    logmsg = ('obsdiscovery, %d/%d mismatch'
-              ' - %d obshashrange queries in %.4f seconds\n')
+    logmsg = (b'obsdiscovery, %d/%d mismatch'
+              b' - %d obshashrange queries in %.4f seconds\n')
     logmsg %= (len(missing), len(probeset), querycount, duration)
-    ui.log('evoext-obsdiscovery', logmsg)
+    ui.log(b'evoext-obsdiscovery', logmsg)
     ui.debug(logmsg)
     return sorted(missing)
 
@@ -186,30 +186,30 @@
 ##############################
 
 @eh.command(
-    'debugobshashrange',
+    b'debugobshashrange',
     [
-        ('', 'rev', [], 'display obshash for all (rev, 0) range in REVS'),
-        ('', 'subranges', False, 'display all subranges'),
-    ],
-    _(''))
+        (b'', b'rev', [], b'display obshash for all (rev, 0) range in REVS'),
+        (b'', b'subranges', False, b'display all subranges'),
+     ],
+    _(b''))
 def debugobshashrange(ui, repo, **opts):
     """display the ::REVS set topologically sorted in a stable way
     """
     s = node.short
-    revs = scmutil.revrange(repo, opts['rev'])
+    revs = scmutil.revrange(repo, opts[b'rev'])
     # prewarm depth cache
     if revs:
         repo.stablerange.warmup(repo, max(revs))
     cl = repo.changelog
     rangelength = repo.stablerange.rangelength
     depthrev = repo.stablerange.depthrev
-    if opts['subranges']:
+    if opts[b'subranges']:
         ranges = stablerange.subrangesclosure(repo, repo.stablerange, revs)
     else:
         ranges = [(r, 0) for r in revs]
-    headers = ('rev', 'node', 'index', 'size', 'depth', 'obshash')
-    linetemplate = '%12d %12s %12d %12d %12d %12s\n'
-    headertemplate = linetemplate.replace('d', 's')
+    headers = (b'rev', b'node', b'index', b'size', b'depth', b'obshash')
+    linetemplate = b'%12d %12s %12d %12d %12d %12s\n'
+    headertemplate = linetemplate.replace(b'd', b's')
     ui.status(headertemplate % headers)
     repo.obsstore.rangeobshashcache.update(repo)
     for r in ranges:
@@ -265,7 +265,7 @@
                                  idx     INTEGER NOT NULL,
                                  obshash BLOB    NOT NULL,
                                  PRIMARY KEY(rev, idx));""",
-    "CREATE INDEX range_index ON obshashrange(rev, idx);",
+    b"CREATE INDEX range_index ON obshashrange(rev, idx);",
     """CREATE TABLE meta(schemaversion INTEGER NOT NULL,
                          tiprev        INTEGER NOT NULL,
                          tipnode       BLOB    NOT NULL,
@@ -274,17 +274,17 @@
                          obskey        BLOB    NOT NULL
                         );""",
 ]
-_queryexist = "SELECT name FROM sqlite_master WHERE type='table' AND name='meta';"
+_queryexist = b"SELECT name FROM sqlite_master WHERE type='table' AND name='meta';"
 _clearmeta = """DELETE FROM meta;"""
 _newmeta = """INSERT INTO meta (schemaversion, tiprev, tipnode, nbobsmarker, obssize, obskey)
             VALUES (?,?,?,?,?,?);"""
-_updateobshash = "INSERT INTO obshashrange(rev, idx, obshash) VALUES (?,?,?);"
-_querymeta = "SELECT schemaversion, tiprev, tipnode, nbobsmarker, obssize, obskey FROM meta;"
-_queryobshash = "SELECT obshash FROM obshashrange WHERE (rev = ? AND idx = ?);"
-_query_max_stored = "SELECT MAX(rev) FROM obshashrange"
+_updateobshash = b"INSERT INTO obshashrange(rev, idx, obshash) VALUES (?,?,?);"
+_querymeta = b"SELECT schemaversion, tiprev, tipnode, nbobsmarker, obssize, obskey FROM meta;"
+_queryobshash = b"SELECT obshash FROM obshashrange WHERE (rev = ? AND idx = ?);"
+_query_max_stored = b"SELECT MAX(rev) FROM obshashrange"
 
-_reset = "DELETE FROM obshashrange;"
-_delete = "DELETE FROM obshashrange WHERE (rev = ? AND idx = ?);"
+_reset = b"DELETE FROM obshashrange;"
+_delete = b"DELETE FROM obshashrange WHERE (rev = ? AND idx = ?);"
 
 def _affectedby(repo, markers):
     """return all nodes whose relevant set is affected by this changeset
@@ -332,8 +332,8 @@
 
     _schemaversion = 3
 
-    _cachename = 'evo-ext-obshashrange' # used for error message
-    _filename = 'evoext_obshashrange_v2.sqlite'
+    _cachename = b'evo-ext-obshashrange' # used for error message
+    _filename = b'evoext_obshashrange_v2.sqlite'
 
     def __init__(self, repo):
         super(_obshashcache, self).__init__()
@@ -352,7 +352,7 @@
         self._new.clear()
         if reset:
             self._valid = False
-        if '_con' in vars(self):
+        if b'_con' in vars(self):
             del self._con
 
     def get(self, rangeid):
@@ -361,7 +361,7 @@
         # XXX there are issue with cache warming, we hack around it for now
         if not getattr(self, '_updating', False):
             if self._cachekey[0] < rangeid[0]:
-                msg = ('using unwarmed obshashrangecache (%s %s)'
+                msg = (b'using unwarmed obshashrangecache (%s %s)'
                        % (rangeid[0], self._cachekey[0]))
                 raise error.ProgrammingError(msg)
 
@@ -376,7 +376,7 @@
             except (sqlite3.DatabaseError, sqlite3.OperationalError):
                 # something is wrong with the sqlite db
                 # Since this is a cache, we ignore it.
-                if '_con' in vars(self):
+                if b'_con' in vars(self):
                     del self._con
                 self._new.clear()
         return value
@@ -405,8 +405,8 @@
             affected = []
             if RESET_ABOVE < len(obsmarkers):
                 # lots of new obsmarkers, probably smarter to reset the cache
-                repo.ui.log('evoext-cache', 'obshashcache reset - '
-                            'many new markers (%d)\n'
+                repo.ui.log(b'evoext-cache', b'obshashcache reset - '
+                            b'many new markers (%d)\n'
                             % len(obsmarkers))
                 reset = True
             elif obsmarkers:
@@ -419,23 +419,23 @@
                             if r is not None and r <= max_stored]
 
             if RESET_ABOVE < len(affected):
-                repo.ui.log('evoext-cache', 'obshashcache reset - '
-                            'new markers affect many changeset (%d)\n'
+                repo.ui.log(b'evoext-cache', b'obshashcache reset - '
+                            b'new markers affect many changeset (%d)\n'
                             % len(affected))
                 reset = True
 
             if affected or reset:
                 if not reset:
-                    repo.ui.log('evoext-cache', 'obshashcache clean - '
-                                'new markers affect %d changeset and cached ranges\n'
+                    repo.ui.log(b'evoext-cache', b'obshashcache clean - '
+                                b'new markers affect %d changeset and cached ranges\n'
                                 % len(affected))
                 if con is not None:
                     # always reset for now, the code detecting affect is buggy
                     # so we need to reset more broadly than we would like.
                     try:
                         if repo.stablerange._con is None:
-                            repo.ui.log('evoext-cache', 'obshashcache reset - '
-                                        'underlying stablerange cache unavailable\n')
+                            repo.ui.log(b'evoext-cache', b'obshashcache reset - '
+                                        b'underlying stablerange cache unavailable\n')
                             reset = True
                         if reset:
                             con.execute(_reset)
@@ -446,7 +446,7 @@
                             for r in ranges:
                                 self._data.pop(r, None)
                     except (sqlite3.DatabaseError, sqlite3.OperationalError) as exc:
-                        repo.ui.log('evoext-cache', 'error while updating obshashrange cache: %s' % exc)
+                        repo.ui.log(b'evoext-cache', b'error while updating obshashrange cache: %s' % exc)
                         del self._updating
                         return
 
@@ -456,7 +456,7 @@
                 # single revision is quite costly)
                 newrevs = []
                 stop = self._cachekey[0] # tiprev
-                for h in repo.filtered('immutable').changelog.headrevs():
+                for h in repo.filtered(b'immutable').changelog.headrevs():
                     if h <= stop and h in affected:
                         newrevs.append(h)
                 newrevs.extend(revs)
@@ -466,14 +466,14 @@
         total = len(revs)
 
         def progress(pos, rev):
-            compat.progress(repo.ui, 'updating obshashrange cache',
-                            pos, 'rev %s' % rev, unit='revision', total=total)
+            compat.progress(repo.ui, b'updating obshashrange cache',
+                            pos, b'rev %s' % rev, unit=b'revision', total=total)
         # warm the cache for the new revs
-        progress(0, '')
+        progress(0, b'')
         for idx, r in enumerate(revs):
             _obshashrange(repo, (r, 0))
             progress(idx, r)
-        progress(None, '')
+        progress(None, b'')
 
         del self._updating
 
@@ -492,7 +492,7 @@
             util.makedirs(self._vfs.dirname(self._path))
         except OSError:
             return None
-        con = sqlite3.connect(self._path, timeout=30, isolation_level="IMMEDIATE")
+        con = sqlite3.connect(self._path, timeout=30, isolation_level=b"IMMEDIATE")
         con.text_factory = str
         return con
 
@@ -525,14 +525,14 @@
         repo = repo.unfiltered()
         try:
             with repo.lock():
-                if 'stablerange' in vars(repo):
+                if b'stablerange' in vars(repo):
                     repo.stablerange.save(repo)
                 self._save(repo)
         except error.LockError:
             # Exceptionnally we are noisy about it since performance impact
             # is large We should address that before using this more
             # widely.
-            msg = _('obshashrange cache: skipping save unable to lock repo\n')
+            msg = _(b'obshashrange cache: skipping save unable to lock repo\n')
             repo.ui.warn(msg)
 
     def _save(self, repo):
@@ -545,22 +545,22 @@
             #
             # operational error catch read-only and locked database
             # IntegrityError catch Unique constraint error that may arise
-            if '_con' in vars(self):
+            if b'_con' in vars(self):
                 del self._con
             self._new.clear()
-            repo.ui.log('evoext-cache', 'error while saving new data: %s' % exc)
-            repo.ui.debug('evoext-cache: error while saving new data: %s' % exc)
+            repo.ui.log(b'evoext-cache', b'error while saving new data: %s' % exc)
+            repo.ui.debug(b'evoext-cache: error while saving new data: %s' % exc)
 
     def _trysave(self, repo):
         if self._con is None:
             util.unlinkpath(self._path, ignoremissing=True)
-            if '_con' in vars(self):
+            if b'_con' in vars(self):
                 del self._con
 
             con = self._db()
             if con is None:
-                repo.ui.log('evoext-cache', 'unable to write obshashrange cache'
-                            ' - cannot create database')
+                repo.ui.log(b'evoext-cache', b'unable to write obshashrange cache'
+                            b' - cannot create database')
                 return
             with con:
                 for req in _sqliteschema:
@@ -577,12 +577,12 @@
                 # drifting is currently an issue because this means another
                 # process might have already added the cache line we are about
                 # to add. This will confuse sqlite
-                msg = _('obshashrange cache: skipping write, '
-                        'database drifted under my feet\n')
+                msg = _(b'obshashrange cache: skipping write, '
+                        b'database drifted under my feet\n')
                 repo.ui.warn(msg)
                 self._new.clear()
                 self._valid = False
-                if '_con' in vars(self):
+                if b'_con' in vars(self):
                     del self._con
                 self._valid = False
                 return
@@ -594,7 +594,7 @@
             self._new.clear()
             self._valid = True
             self._ondiskcachekey = self._cachekey
- at eh.wrapfunction(obsolete.obsstore, '_addmarkers')
+ at eh.wrapfunction(obsolete.obsstore, b'_addmarkers')
 def _addmarkers(orig, obsstore, *args, **kwargs):
     obsstore.rangeobshashcache.clear()
     return orig(obsstore, *args, **kwargs)
@@ -603,7 +603,7 @@
 
 
 # obsstore is a filecache so we have do to some spacial dancing
- at eh.wrapfunction(obsstorefilecache, 'func')
+ at eh.wrapfunction(obsstorefilecache, b'func')
 def obsstorewithcache(orig, repo):
     obsstore = orig(repo)
     obsstore.rangeobshashcache = _obshashcache(repo.unfiltered())
@@ -615,9 +615,9 @@
     class obshashrepo(repo.__class__):
         @localrepo.unfilteredmethod
         def destroyed(self):
-            if 'obsstore' in vars(self):
+            if b'obsstore' in vars(self):
                 self.obsstore.rangeobshashcache.clear()
-            toplevel = not util.safehasattr(self, '_destroying')
+            toplevel = not util.safehasattr(self, b'_destroying')
             if toplevel:
                 self._destroying = True
             try:
@@ -664,7 +664,7 @@
     return _obshashrange_v0(peer._repo, ranges)
 
 
-_indexformat = '>I'
+_indexformat = b'>I'
 _indexsize = _calcsize(_indexformat)
 def _encrange(node_rangeid):
     """encode a (node) range"""
@@ -682,13 +682,13 @@
 def peer_obshashrange_v0(self, ranges):
     binranges = [_encrange(r) for r in ranges]
     encranges = encodelist(binranges)
-    d = self._call("evoext_obshashrange_v1", ranges=encranges)
+    d = self._call(b"evoext_obshashrange_v1", ranges=encranges)
     try:
         return decodelist(d)
     except ValueError:
-        self._abort(error.ResponseError(_("unexpected response:"), d))
+        self._abort(error.ResponseError(_(b"unexpected response:"), d))
 
- at compat.wireprotocommand(eh, 'evoext_obshashrange_v1', 'ranges')
+ at compat.wireprotocommand(eh, b'evoext_obshashrange_v1', b'ranges')
 def srv_obshashrange_v1(repo, proto, ranges):
     ranges = decodelist(ranges)
     ranges = [_decrange(r) for r in ranges]
@@ -696,16 +696,16 @@
     return encodelist(hashes)
 
 def _useobshashrange(repo):
-    base = repo.ui.configbool('experimental', 'obshashrange')
+    base = repo.ui.configbool(b'experimental', b'obshashrange')
     if base:
-        maxrevs = repo.ui.configint('experimental', 'obshashrange.max-revs')
+        maxrevs = repo.ui.configint(b'experimental', b'obshashrange.max-revs')
         if maxrevs is not None and maxrevs < len(repo.unfiltered()):
             base = False
     return base
 
 def _canobshashrange(local, remote):
     return (_useobshashrange(local)
-            and remote.capable('_evoext_obshashrange_v1'))
+            and remote.capable(b'_evoext_obshashrange_v1'))
 
 def _obshashrange_capabilities(orig, repo, proto):
     """wrapper to advertise new capability"""
@@ -715,7 +715,7 @@
 
         # Compat hg 4.6+ (2f7290555c96)
         bytesresponse = False
-        if util.safehasattr(caps, 'data'):
+        if util.safehasattr(caps, b'data'):
             bytesresponse = True
             caps = caps.data
 
@@ -732,14 +732,14 @@
 @eh.extsetup
 def obshashrange_extsetup(ui):
     ###
-    extensions.wrapfunction(wireprotov1server, 'capabilities',
+    extensions.wrapfunction(wireprotov1server, b'capabilities',
                             _obshashrange_capabilities)
     # wrap command content
-    oldcap, args = wireprotov1server.commands['capabilities']
+    oldcap, args = wireprotov1server.commands[b'capabilities']
 
     def newcap(repo, proto):
         return _obshashrange_capabilities(oldcap, repo, proto)
-    wireprotov1server.commands['capabilities'] = (newcap, args)
+    wireprotov1server.commands[b'capabilities'] = (newcap, args)
 
 ##########################################
 ###  trigger discovery during exchange ###
@@ -751,7 +751,7 @@
             # exchange of obsmarkers is enabled locally
             and obsolete.isenabled(pushop.repo, obsolete.exchangeopt)
             # remote server accept markers
-            and 'obsolete' in pushop.remote.listkeys('namespaces'))
+            and b'obsolete' in pushop.remote.listkeys(b'namespaces'))
 
 def _pushobshashrange(pushop, commonrevs):
     repo = pushop.repo.unfiltered()
@@ -772,15 +772,15 @@
 """
 
 def usediscovery(repo):
-    return repo.ui.configbool('experimental', 'evolution.obsdiscovery')
+    return repo.ui.configbool(b'experimental', b'evolution.obsdiscovery')
 
- at eh.wrapfunction(exchange, '_pushdiscoveryobsmarkers')
+ at eh.wrapfunction(exchange, b'_pushdiscoveryobsmarkers')
 def _pushdiscoveryobsmarkers(orig, pushop):
     if _dopushmarkers(pushop):
         repo = pushop.repo
         remote = pushop.remote
-        obsexcmsg(repo.ui, "computing relevant nodes\n")
-        revs = list(repo.revs('::%ln', pushop.futureheads))
+        obsexcmsg(repo.ui, b"computing relevant nodes\n")
+        revs = list(repo.revs(b'::%ln', pushop.futureheads))
         unfi = repo.unfiltered()
 
         if not usediscovery(repo):
@@ -800,27 +800,27 @@
             # obs markers.
             return orig(pushop)
 
-        obsexcmsg(repo.ui, "looking for common markers in %i nodes\n"
+        obsexcmsg(repo.ui, b"looking for common markers in %i nodes\n"
                            % len(revs))
-        commonrevs = list(unfi.revs('::%ln', pushop.outgoing.commonheads))
+        commonrevs = list(unfi.revs(b'::%ln', pushop.outgoing.commonheads))
         # find the nodes where the relevant obsmarkers mismatches
         nodes = discovery(pushop, commonrevs)
 
         if nodes:
-            obsexcmsg(repo.ui, "computing markers relevant to %i nodes\n"
+            obsexcmsg(repo.ui, b"computing markers relevant to %i nodes\n"
                                % len(nodes))
             pushop.outobsmarkers = repo.obsstore.relevantmarkers(nodes)
         else:
-            obsexcmsg(repo.ui, "markers already in sync\n")
+            obsexcmsg(repo.ui, b"markers already in sync\n")
             pushop.outobsmarkers = []
 
 @eh.extsetup
 def _installobsmarkersdiscovery(ui):
-    olddisco = exchange.pushdiscoverymapping['obsmarker']
+    olddisco = exchange.pushdiscoverymapping[b'obsmarker']
 
     def newdisco(pushop):
         _pushdiscoveryobsmarkers(olddisco, pushop)
-    exchange.pushdiscoverymapping['obsmarker'] = newdisco
+    exchange.pushdiscoverymapping[b'obsmarker'] = newdisco
 
 def buildpullobsmarkersboundaries(pullop, bundle2=True):
     """small function returning the argument for pull markers call
@@ -830,25 +830,25 @@
     repo = pullop.repo
     remote = pullop.remote
     unfi = repo.unfiltered()
-    revs = unfi.revs('::(%ln - null)', pullop.common)
-    boundaries = {'heads': pullop.pulledsubset}
+    revs = unfi.revs(b'::(%ln - null)', pullop.common)
+    boundaries = {b'heads': pullop.pulledsubset}
     if not revs: # nothing common
-        boundaries['common'] = [node.nullid]
+        boundaries[b'common'] = [node.nullid]
         return boundaries
 
     if not usediscovery(repo):
         # discovery disabled by users.
         repo.ui.status(obsdiscovery_skip_message)
-        boundaries['common'] = [node.nullid]
+        boundaries[b'common'] = [node.nullid]
         return boundaries
 
     if bundle2 and _canobshashrange(repo, remote):
-        obsexcmsg(repo.ui, "looking for common markers in %i nodes\n"
+        obsexcmsg(repo.ui, b"looking for common markers in %i nodes\n"
                   % len(revs))
-        boundaries['missing'] = findmissingrange(repo.ui, unfi, pullop.remote,
-                                                 revs)
+        boundaries[b'missing'] = findmissingrange(repo.ui, unfi, pullop.remote,
+                                                  revs)
     else:
-        boundaries['common'] = [node.nullid]
+        boundaries[b'common'] = [node.nullid]
     return boundaries
 
 # merge later for outer layer wrapping
diff --git a/hgext3rd/evolve/obsexchange.py b/hgext3rd/evolve/obsexchange.py
--- a/hgext3rd/evolve/obsexchange.py
+++ b/hgext3rd/evolve/obsexchange.py
@@ -37,7 +37,7 @@
 obsexcmsg = utility.obsexcmsg
 obsexcprg = utility.obsexcprg
 
-eh.configitem('experimental', 'verbose-obsolescence-exchange', False)
+eh.configitem(b'experimental', b'verbose-obsolescence-exchange', False)
 
 _bestformat = max(obsolete.formats.keys())
 
@@ -58,49 +58,49 @@
         # <= hg 4.5
         from mercurial import wireproto
         gboptsmap = wireproto.gboptsmap
-    gboptsmap['evo_obscommon'] = 'nodes'
-    gboptsmap['evo_missing_nodes'] = 'nodes'
+    gboptsmap[b'evo_obscommon'] = b'nodes'
+    gboptsmap[b'evo_missing_nodes'] = b'nodes'
 
- at eh.wrapfunction(exchange, '_pullbundle2extraprepare')
+ at eh.wrapfunction(exchange, b'_pullbundle2extraprepare')
 def _addobscommontob2pull(orig, pullop, kwargs):
     ret = orig(pullop, kwargs)
     ui = pullop.repo.ui
-    if ('obsmarkers' in kwargs
-        and pullop.remote.capable('_evoext_getbundle_obscommon')):
+    if (b'obsmarkers' in kwargs
+        and pullop.remote.capable(b'_evoext_getbundle_obscommon')):
         boundaries = obsdiscovery.buildpullobsmarkersboundaries(pullop)
-        if 'common' in boundaries:
-            common = boundaries['common']
+        if b'common' in boundaries:
+            common = boundaries[b'common']
             if common != pullop.common:
-                obsexcmsg(ui, 'request obsmarkers for some common nodes\n')
+                obsexcmsg(ui, b'request obsmarkers for some common nodes\n')
             if common != [node.nullid]:
-                kwargs['evo_obscommon'] = common
-        elif 'missing' in boundaries:
-            missing = boundaries['missing']
+                kwargs[b'evo_obscommon'] = common
+        elif b'missing' in boundaries:
+            missing = boundaries[b'missing']
             if missing:
-                obsexcmsg(ui, 'request obsmarkers for %d common nodes\n'
+                obsexcmsg(ui, b'request obsmarkers for %d common nodes\n'
                           % len(missing))
-            kwargs['evo_missing_nodes'] = missing
+            kwargs[b'evo_missing_nodes'] = missing
     return ret
 
 def _getbundleobsmarkerpart(orig, bundler, repo, source, **kwargs):
-    if not (set(['evo_obscommon', 'evo_missing_nodes']) & set(kwargs)):
+    if not (set([b'evo_obscommon', b'evo_missing_nodes']) & set(kwargs)):
         return orig(bundler, repo, source, **kwargs)
 
-    if kwargs.get('obsmarkers', False):
-        heads = kwargs.get('heads')
-        if 'evo_obscommon' in kwargs:
+    if kwargs.get(b'obsmarkers', False):
+        heads = kwargs.get(b'heads')
+        if b'evo_obscommon' in kwargs:
             if heads is None:
                 heads = repo.heads()
-            obscommon = kwargs.get('evo_obscommon', ())
+            obscommon = kwargs.get(b'evo_obscommon', ())
             assert obscommon
-            obsset = repo.unfiltered().set('::%ln - ::%ln', heads, obscommon)
+            obsset = repo.unfiltered().set(b'::%ln - ::%ln', heads, obscommon)
             subset = [c.node() for c in obsset]
         else:
-            common = kwargs.get('common')
-            subset = [c.node() for c in repo.unfiltered().set('only(%ln, %ln)', heads, common)]
-            subset += kwargs['evo_missing_nodes']
+            common = kwargs.get(b'common')
+            subset = [c.node() for c in repo.unfiltered().set(b'only(%ln, %ln)', heads, common)]
+            subset += kwargs[b'evo_missing_nodes']
         markers = repo.obsstore.relevantmarkers(subset)
-        if util.safehasattr(bundle2, 'buildobsmarkerspart'):
+        if util.safehasattr(bundle2, b'buildobsmarkerspart'):
             bundle2.buildobsmarkerspart(bundler, markers)
         else:
             exchange.buildobsmarkerspart(bundler, markers)
@@ -113,7 +113,7 @@
 
         # Compat hg 4.6+ (2f7290555c96)
         bytesresponse = False
-        if util.safehasattr(caps, 'data'):
+        if util.safehasattr(caps, b'data'):
             bytesresponse = True
             caps = caps.data
 
@@ -138,36 +138,36 @@
         from mercurial import wireproto
         gboptsmap = wireproto.gboptsmap
         wireprotov1server = wireproto
-    gboptsmap['evo_obscommon'] = 'nodes'
+    gboptsmap[b'evo_obscommon'] = b'nodes'
 
     # wrap module content
-    origfunc = exchange.getbundle2partsmapping['obsmarkers']
+    origfunc = exchange.getbundle2partsmapping[b'obsmarkers']
 
     def newfunc(*args, **kwargs):
         return _getbundleobsmarkerpart(origfunc, *args, **kwargs)
-    exchange.getbundle2partsmapping['obsmarkers'] = newfunc
+    exchange.getbundle2partsmapping[b'obsmarkers'] = newfunc
 
-    extensions.wrapfunction(wireprotov1server, 'capabilities',
+    extensions.wrapfunction(wireprotov1server, b'capabilities',
                             _obscommon_capabilities)
     # wrap command content
-    oldcap, args = wireprotov1server.commands['capabilities']
+    oldcap, args = wireprotov1server.commands[b'capabilities']
 
     def newcap(repo, proto):
         return _obscommon_capabilities(oldcap, repo, proto)
-    wireprotov1server.commands['capabilities'] = (newcap, args)
+    wireprotov1server.commands[b'capabilities'] = (newcap, args)
 
 def _pushobsmarkers(repo, data):
     tr = lock = None
     try:
         lock = repo.lock()
-        tr = repo.transaction('pushkey: obsolete markers')
+        tr = repo.transaction(b'pushkey: obsolete markers')
         new = repo.obsstore.mergemarkers(tr, data)
         if new is not None:
-            obsexcmsg(repo.ui, "%i obsolescence markers added\n" % new, True)
+            obsexcmsg(repo.ui, b"%i obsolescence markers added\n" % new, True)
         tr.close()
     finally:
         lockmod.release(tr, lock)
-    repo.hook('evolve_pushobsmarkers')
+    repo.hook(b'evolve_pushobsmarkers')
 
 def srv_pushobsmarkers(repo, proto):
     """wireprotocol command"""
@@ -187,18 +187,18 @@
 def _getobsmarkersstream(repo, heads=None, common=None):
     """Get a binary stream for all markers relevant to `::<heads> - ::<common>`
     """
-    revset = ''
+    revset = b''
     args = []
     repo = repo.unfiltered()
     if heads is None:
-        revset = 'all()'
+        revset = b'all()'
     elif heads:
-        revset += "(::%ln)"
+        revset += b"(::%ln)"
         args.append(heads)
     else:
-        assert False, 'pulling no heads?'
+        assert False, b'pulling no heads?'
     if common:
-        revset += ' - (::%ln)'
+        revset += b' - (::%ln)'
         args.append(common)
     nodes = [c.node() for c in repo.set(revset, *args)]
     markers = repo.obsstore.relevantmarkers(nodes)
@@ -220,20 +220,20 @@
     except (ImportError, AttributeError):
         from mercurial import wireproto as wireprototypes
         wireprotov1server = wireprototypes
-    opts = wireprotov1server.options('', ['heads', 'common'], others)
-    for k, v in opts.iteritems():
-        if k in ('heads', 'common'):
+    opts = wireprotov1server.options(b'', [b'heads', b'common'], others)
+    for k, v in opts.items():
+        if k in (b'heads', b'common'):
             opts[k] = wireprototypes.decodelist(v)
     obsdata = _getobsmarkersstream(repo, **opts)
     finaldata = StringIO()
     obsdata = obsdata.getvalue()
-    finaldata.write('%20i' % len(obsdata))
+    finaldata.write(b'%20i' % len(obsdata))
     finaldata.write(obsdata)
     finaldata.seek(0)
     return wireprototypes.streamres(reader=finaldata, v1compressible=True)
 
-abortmsg = "won't exchange obsmarkers through pushkey"
-hint = "upgrade your client or server to use the bundle2 protocol"
+abortmsg = b"won't exchange obsmarkers through pushkey"
+hint = b"upgrade your client or server to use the bundle2 protocol"
 
 class HTTPCompatibleAbort(hgwebcommon.ErrorResponse, error.Abort):
     def __init__(self, message, code, hint=None):
@@ -256,4 +256,4 @@
 
 @eh.uisetup
 def setuppushkeyforbidding(ui):
-    pushkey._namespaces['obsolete'] = (forbidpushkey, forbidlistkey)
+    pushkey._namespaces[b'obsolete'] = (forbidpushkey, forbidlistkey)
diff --git a/hgext3rd/evolve/obshashtree.py b/hgext3rd/evolve/obshashtree.py
--- a/hgext3rd/evolve/obshashtree.py
+++ b/hgext3rd/evolve/obshashtree.py
@@ -28,9 +28,9 @@
 # the obshash of its parents.  This is similar to what happend for changeset
 # node where the parent is used in the computation
 @eh.command(
-    'debugobsrelsethashtree',
-    [('', 'v0', None, 'hash on marker format "0"'),
-     ('', 'v1', None, 'hash on marker format "1" (default)')], _(''))
+    b'debugobsrelsethashtree',
+    [(b'', b'v0', None, b'hash on marker format "0"'),
+     (b'', b'v1', None, b'hash on marker format "1" (default)')], _(b''))
 def debugobsrelsethashtree(ui, repo, v0=False, v1=False):
     """display Obsolete markers, Relevant Set, Hash Tree
     changeset-node obsrelsethashtree-node
@@ -42,14 +42,14 @@
     debug command stayed as an inspection tool. It does not seem supseful to
     upstream the command with the rest of evolve. We can safely drop it."""
     if v0 and v1:
-        raise error.Abort('cannot only specify one format')
+        raise error.Abort(b'cannot only specify one format')
     elif v0:
         treefunc = _obsrelsethashtreefm0
     else:
         treefunc = _obsrelsethashtreefm1
 
     for chg, obs in treefunc(repo):
-        ui.status('%s %s\n' % (node.hex(chg), node.hex(obs)))
+        ui.status(b'%s %s\n' % (node.hex(chg), node.hex(obs)))
 
 def _obsrelsethashtreefm0(repo):
     return _obsrelsethashtree(repo, obsolete._fm0encodeonemarker)
@@ -61,8 +61,8 @@
     cache = []
     unfi = repo.unfiltered()
     markercache = {}
-    compat.progress(repo.ui, _("preparing locally"), 0, total=len(unfi),
-                    unit=_("changesets"))
+    compat.progress(repo.ui, _(b"preparing locally"), 0, total=len(unfi),
+                    unit=_(b"changesets"))
     for i in unfi:
         ctx = unfi[i]
         entry = 0
@@ -92,7 +92,7 @@
             cache.append((ctx.node(), sha.digest()))
         else:
             cache.append((ctx.node(), node.nullid))
-        compat.progress(repo.ui, _("preparing locally"), i, total=len(unfi),
-                        unit=_("changesets"))
-    compat.progress(repo.ui, _("preparing locally"), None)
+        compat.progress(repo.ui, _(b"preparing locally"), i, total=len(unfi),
+                        unit=_(b"changesets"))
+    compat.progress(repo.ui, _(b"preparing locally"), None)
     return cache
diff --git a/hgext3rd/evolve/obshistory.py b/hgext3rd/evolve/obshistory.py
--- a/hgext3rd/evolve/obshistory.py
+++ b/hgext3rd/evolve/obshistory.py
@@ -30,26 +30,26 @@
 eh = exthelper.exthelper()
 
 # Config
-efd = {'default': True} # pass a default value unless the config is registered
+efd = {b'default': True} # pass a default value unless the config is registered
 
 @eh.extsetup
 def enableeffectflags(ui):
     item = (getattr(ui, '_knownconfig', {})
-            .get('experimental', {})
-            .get('evolution.effect-flags'))
+            .get(b'experimental', {})
+            .get(b'evolution.effect-flags'))
     if item is not None:
         item.default = True
         efd.clear()
 
 @eh.command(
-    'obslog|olog',
-    [('G', 'graph', True, _("show the revision DAG")),
-     ('r', 'rev', [], _('show the specified revision or revset'), _('REV')),
-     ('a', 'all', False, _('show all related changesets, not only precursors')),
-     ('p', 'patch', False, _('show the patch between two obs versions')),
-     ('f', 'filternonlocal', False, _('filter out non local commits')),
-    ] + commands.formatteropts,
-    _('hg olog [OPTION]... [REV]'))
+    b'obslog|olog',
+    [(b'G', b'graph', True, _(b"show the revision DAG")),
+     (b'r', b'rev', [], _(b'show the specified revision or revset'), _(b'REV')),
+     (b'a', b'all', False, _(b'show all related changesets, not only precursors')),
+     (b'p', b'patch', False, _(b'show the patch between two obs versions')),
+     (b'f', b'filternonlocal', False, _(b'filter out non local commits')),
+     ] + commands.formatteropts,
+    _(b'hg olog [OPTION]... [REV]'))
 def cmdobshistory(ui, repo, *revs, **opts):
     """show the obsolescence history of the specified revisions
 
@@ -78,13 +78,13 @@
 
     Returns 0 on success.
     """
-    ui.pager('obslog')
-    revs = list(revs) + opts['rev']
+    ui.pager(b'obslog')
+    revs = list(revs) + opts[b'rev']
     if not revs:
-        revs = ['.']
+        revs = [b'.']
     revs = scmutil.revrange(repo, revs)
 
-    if opts['graph']:
+    if opts[b'graph']:
         return _debugobshistorygraph(ui, repo, revs, opts)
 
     revs.reverse()
@@ -130,7 +130,7 @@
 
     values = []
     for sset in fullsuccessorsets:
-        values.append({'successors': sset, 'markers': sset.markers})
+        values.append({b'successors': sset, b'markers': sset.markers})
 
     return values
 
@@ -142,21 +142,21 @@
 
     def __init__(self, ui, repo, *args, **kwargs):
 
-        if kwargs.pop('obspatch', False):
+        if kwargs.pop(b'obspatch', False):
             if compat.changesetdiffer is None:
-                kwargs['matchfn'] = scmutil.matchall(repo)
+                kwargs[b'matchfn'] = scmutil.matchall(repo)
             else:
-                kwargs['differ'] = scmutil.matchall(repo)
+                kwargs[b'differ'] = scmutil.matchall(repo)
 
         super(obsmarker_printer, self).__init__(ui, repo, *args, **kwargs)
-        diffopts = kwargs.get('diffopts', {})
+        diffopts = kwargs.get(b'diffopts', {})
 
         # Compat 4.6
-        if not util.safehasattr(self, "_includediff"):
-            self._includediff = diffopts and diffopts.get('patch')
+        if not util.safehasattr(self, b"_includediff"):
+            self._includediff = diffopts and diffopts.get(b'patch')
 
-        self.template = diffopts and diffopts.get('template')
-        self.filter = diffopts and diffopts.get('filternonlocal')
+        self.template = diffopts and diffopts.get(b'template')
+        self.filter = diffopts and diffopts.get(b'filternonlocal')
 
     def show(self, ctx, copies=None, matchfn=None, **props):
         if self.buffered:
@@ -164,12 +164,12 @@
 
             changenode = ctx.node()
 
-            _props = {"template": self.template}
-            fm = self.ui.formatter('debugobshistory', _props)
+            _props = {b"template": self.template}
+            fm = self.ui.formatter(b'debugobshistory', _props)
 
             _debugobshistorydisplaynode(fm, self.repo, changenode)
 
-            markerfm = fm.nested("markers")
+            markerfm = fm.nested(b"markers")
 
             # Succs markers
             if self.filter is False:
@@ -185,21 +185,21 @@
                 r = _successorsandmarkers(self.repo, ctx)
 
                 for succset in sorted(r):
-                    markers = succset["markers"]
+                    markers = succset[b"markers"]
                     if not markers:
                         continue
-                    successors = succset["successors"]
+                    successors = succset[b"successors"]
                     _debugobshistorydisplaysuccsandmarkers(markerfm, successors, markers, ctx.node(), self.repo, self._includediff)
 
             markerfm.end()
 
-            markerfm.plain('\n')
+            markerfm.plain(b'\n')
             fm.end()
 
             self.hunk[ctx.node()] = self.ui.popbuffer()
         else:
             ### graph output is buffered only
-            msg = 'cannot be used outside of the graphlog (yet)'
+            msg = b'cannot be used outside of the graphlog (yet)'
             raise error.ProgrammingError(msg)
 
     def flush(self, ctx):
@@ -210,43 +210,43 @@
 
 def patchavailable(node, repo, successors):
     if node not in repo:
-        return False, "context is not local"
+        return False, b"context is not local"
 
     if len(successors) == 0:
-        return False, "no successors"
+        return False, b"no successors"
     elif len(successors) > 1:
-        return False, "too many successors (%d)" % len(successors)
+        return False, b"too many successors (%d)" % len(successors)
 
     succ = successors[0]
 
     if succ not in repo:
-        return False, "successor is unknown locally"
+        return False, b"successor is unknown locally"
 
     # Check that both node and succ have the same parents
     nodep1, nodep2 = repo[node].p1(), repo[node].p2()
     succp1, succp2 = repo[succ].p1(), repo[succ].p2()
 
     if nodep1 != succp1 or nodep2 != succp2:
-        return False, "changesets rebased"
+        return False, b"changesets rebased"
 
     return True, succ
 
 def getmarkerdescriptionpatch(repo, basedesc, succdesc):
     # description are stored without final new line,
     # add one to avoid ugly diff
-    basedesc += '\n'
-    succdesc += '\n'
+    basedesc += b'\n'
+    succdesc += b'\n'
 
     # fake file name
-    basename = "changeset-description"
-    succname = "changeset-description"
+    basename = b"changeset-description"
+    succname = b"changeset-description"
 
     d = compat.strdiff(basedesc, succdesc, basename, succname)
     uheaders, hunks = d
 
     # Copied from patch.diff
-    text = ''.join(sum((list(hlines) for hrange, hlines in hunks), []))
-    patch = "\n".join(uheaders + [text])
+    text = b''.join(sum((list(hlines) for hrange, hlines in hunks), []))
+    patch = b"\n".join(uheaders + [text])
 
     return patch
 
@@ -332,7 +332,7 @@
             # Then choose a random node from the cycle
             breaknode = sorted(cycle)[0]
             # And display it by force
-            repo.ui.debug('obs-cycle detected, forcing display of %s\n'
+            repo.ui.debug(b'obs-cycle detected, forcing display of %s\n'
                           % nodemod.short(breaknode))
             validcandidates = [breaknode]
 
@@ -425,13 +425,13 @@
 
     displayer = obsmarker_printer(ui, repo.unfiltered(), obspatch=True, diffopts=opts, buffered=True)
     edges = graphmod.asciiedges
-    walker = _obshistorywalker(repo.unfiltered(), revs, opts.get('all', False), opts.get('filternonlocal', False))
+    walker = _obshistorywalker(repo.unfiltered(), revs, opts.get(b'all', False), opts.get(b'filternonlocal', False))
     compat.displaygraph(ui, repo, walker, displayer, edges)
 
 def _debugobshistoryrevs(ui, repo, revs, opts):
     """ Display the obsolescence history for revset
     """
-    fm = ui.formatter('debugobshistory', opts)
+    fm = ui.formatter(b'debugobshistory', opts)
     precursors = repo.obsstore.predecessors
     successors = repo.obsstore.successors
     nodec = repo.changelog.node
@@ -447,9 +447,9 @@
 
         succs = successors.get(ctxnode, ())
 
-        markerfm = fm.nested("markers")
+        markerfm = fm.nested(b"markers")
         for successor in sorted(succs):
-            includediff = opts and opts.get("patch")
+            includediff = opts and opts.get(b"patch")
             _debugobshistorydisplaymarker(markerfm, successor, ctxnode, unfi, includediff)
         markerfm.end()
 
@@ -473,24 +473,24 @@
         shortdescription = shortdescription.splitlines()[0]
 
     fm.startitem()
-    fm.write('node', '%s', str(ctx),
-             label="evolve.node")
-    fm.plain(' ')
+    fm.write(b'node', b'%s', str(ctx),
+             label=b"evolve.node")
+    fm.plain(b' ')
 
-    fm.write('rev', '(%d)', ctx.rev(),
-             label="evolve.rev")
-    fm.plain(' ')
+    fm.write(b'rev', b'(%d)', ctx.rev(),
+             label=b"evolve.rev")
+    fm.plain(b' ')
 
-    fm.write('shortdescription', '%s', shortdescription,
-             label="evolve.short_description")
-    fm.plain('\n')
+    fm.write(b'shortdescription', b'%s', shortdescription,
+             label=b"evolve.short_description")
+    fm.plain(b'\n')
 
 def _debugobshistorydisplaymissingctx(fm, nodewithoutctx):
     hexnode = nodemod.short(nodewithoutctx)
     fm.startitem()
-    fm.write('node', '%s', hexnode,
-             label="evolve.node evolve.missing_change_ctx")
-    fm.plain('\n')
+    fm.write(b'node', b'%s', hexnode,
+             label=b"evolve.node evolve.missing_change_ctx")
+    fm.plain(b'\n')
 
 def _debugobshistorydisplaymarker(fm, marker, node, repo, includediff=False):
     succnodes = marker[1]
@@ -498,18 +498,18 @@
     metadata = dict(marker[3])
 
     fm.startitem()
-    fm.plain('  ')
+    fm.plain(b'  ')
 
     # Detect pruned revisions
     if len(succnodes) == 0:
-        verb = 'pruned'
+        verb = b'pruned'
     else:
-        verb = 'rewritten'
+        verb = b'rewritten'
 
-    fm.write('verb', '%s', verb,
-             label="evolve.verb")
+    fm.write(b'verb', b'%s', verb,
+             label=b"evolve.verb")
 
-    effectflag = metadata.get('ef1')
+    effectflag = metadata.get(b'ef1')
     if effectflag is not None:
         try:
             effectflag = int(effectflag)
@@ -520,50 +520,50 @@
 
         # XXX should be a dict
         if effectflag & DESCCHANGED:
-            effect.append('description')
+            effect.append(b'description')
         if effectflag & METACHANGED:
-            effect.append('meta')
+            effect.append(b'meta')
         if effectflag & USERCHANGED:
-            effect.append('user')
+            effect.append(b'user')
         if effectflag & DATECHANGED:
-            effect.append('date')
+            effect.append(b'date')
         if effectflag & BRANCHCHANGED:
-            effect.append('branch')
+            effect.append(b'branch')
         if effectflag & PARENTCHANGED:
-            effect.append('parent')
+            effect.append(b'parent')
         if effectflag & DIFFCHANGED:
-            effect.append('content')
+            effect.append(b'content')
 
         if effect:
-            fmteffect = fm.formatlist(effect, 'effect', sep=', ')
-            fm.write('effect', '(%s)', fmteffect)
+            fmteffect = fm.formatlist(effect, b'effect', sep=b', ')
+            fm.write(b'effect', b'(%s)', fmteffect)
 
     if len(succnodes) > 0:
-        fm.plain(' as ')
+        fm.plain(b' as ')
 
         shortsnodes = (nodemod.short(succnode) for succnode in sorted(succnodes))
-        nodes = fm.formatlist(shortsnodes, 'succnodes', sep=', ')
-        fm.write('succnodes', '%s', nodes,
-                 label="evolve.node")
+        nodes = fm.formatlist(shortsnodes, b'succnodes', sep=b', ')
+        fm.write(b'succnodes', b'%s', nodes,
+                 label=b"evolve.node")
 
-    operation = metadata.get('operation')
+    operation = metadata.get(b'operation')
     if operation:
-        fm.plain(' using ')
-        fm.write('operation', '%s', operation, label="evolve.operation")
+        fm.plain(b' using ')
+        fm.write(b'operation', b'%s', operation, label=b"evolve.operation")
 
-    fm.plain(' by ')
+    fm.plain(b' by ')
 
-    fm.write('user', '%s', metadata['user'],
-             label="evolve.user")
-    fm.plain(' ')
+    fm.write(b'user', b'%s', metadata[b'user'],
+             label=b"evolve.user")
+    fm.plain(b' ')
 
-    fm.write('date', '(%s)', fm.formatdate(date),
-             label="evolve.date")
+    fm.write(b'date', b'(%s)', fm.formatdate(date),
+             label=b"evolve.date")
 
     # initial support for showing note
-    if metadata.get('note'):
-        fm.plain('\n    note: ')
-        fm.write('note', "%s", metadata['note'], label="evolve.note")
+    if metadata.get(b'note'):
+        fm.plain(b'\n    note: ')
+        fm.write(b'note', b"%s", metadata[b'note'], label=b"evolve.note")
 
     # Patch display
     if includediff is True:
@@ -581,20 +581,20 @@
 
             if descriptionpatch:
                 # add the diffheader
-                diffheader = "diff -r %s -r %s changeset-description\n" % \
+                diffheader = b"diff -r %s -r %s changeset-description\n" %\
                              (basectx, succctx)
                 descriptionpatch = diffheader + descriptionpatch
 
                 def tolist(text):
                     return [text]
 
-                fm.plain("\n")
+                fm.plain(b"\n")
 
                 for chunk, label in patch.difflabel(tolist, descriptionpatch):
-                    chunk = chunk.strip('\t')
-                    if chunk and chunk != '\n':
-                        fm.plain('    ')
-                    fm.write('desc-diff', '%s', chunk, label=label)
+                    chunk = chunk.strip(b'\t')
+                    if chunk and chunk != b'\n':
+                        fm.plain(b'    ')
+                    fm.write(b'desc-diff', b'%s', chunk, label=label)
 
             # Content patch
             diffopts = patch.diffallopts(repo.ui, {})
@@ -603,18 +603,18 @@
             for chunk, label in patch.diffui(repo, node, succ, matchfn,
                                              opts=diffopts):
                 if firstline:
-                    fm.plain('\n')
+                    fm.plain(b'\n')
                     firstline = False
-                if chunk and chunk != '\n':
-                    fm.plain('    ')
-                fm.write('patch', '%s', chunk, label=label)
+                if chunk and chunk != b'\n':
+                    fm.plain(b'    ')
+                fm.write(b'patch', b'%s', chunk, label=label)
         else:
-            nopatch = "    (No patch available, %s)" % _patchavailable[1]
-            fm.plain("\n")
+            nopatch = b"    (No patch available, %s)" % _patchavailable[1]
+            fm.plain(b"\n")
             # TODO: should be in json too
             fm.plain(nopatch)
 
-    fm.plain("\n")
+    fm.plain(b"\n")
 
 def _debugobshistorydisplaysuccsandmarkers(fm, succnodes, markers, node, repo, includediff=False):
     """
@@ -622,17 +622,17 @@
     to accept multiple markers as input.
     """
     fm.startitem()
-    fm.plain('  ')
+    fm.plain(b'  ')
 
     # Detect pruned revisions
-    verb = _successorsetverb(succnodes, markers)["verb"]
+    verb = _successorsetverb(succnodes, markers)[b"verb"]
 
-    fm.write('verb', '%s', verb,
-             label="evolve.verb")
+    fm.write(b'verb', b'%s', verb,
+             label=b"evolve.verb")
 
     # Effect flag
     metadata = [dict(marker[3]) for marker in markers]
-    ef1 = [data.get('ef1') for data in metadata]
+    ef1 = [data.get(b'ef1') for data in metadata]
 
     effectflag = 0
     for ef in ef1:
@@ -644,45 +644,45 @@
 
         # XXX should be a dict
         if effectflag & DESCCHANGED:
-            effect.append('description')
+            effect.append(b'description')
         if effectflag & METACHANGED:
-            effect.append('meta')
+            effect.append(b'meta')
         if effectflag & USERCHANGED:
-            effect.append('user')
+            effect.append(b'user')
         if effectflag & DATECHANGED:
-            effect.append('date')
+            effect.append(b'date')
         if effectflag & BRANCHCHANGED:
-            effect.append('branch')
+            effect.append(b'branch')
         if effectflag & PARENTCHANGED:
-            effect.append('parent')
+            effect.append(b'parent')
         if effectflag & DIFFCHANGED:
-            effect.append('content')
+            effect.append(b'content')
 
         if effect:
-            fmteffect = fm.formatlist(effect, 'effect', sep=', ')
-            fm.write('effect', '(%s)', fmteffect)
+            fmteffect = fm.formatlist(effect, b'effect', sep=b', ')
+            fm.write(b'effect', b'(%s)', fmteffect)
 
     if len(succnodes) > 0:
-        fm.plain(' as ')
+        fm.plain(b' as ')
 
         shortsnodes = (nodemod.short(succnode) for succnode in sorted(succnodes))
-        nodes = fm.formatlist(shortsnodes, 'succnodes', sep=', ')
-        fm.write('succnodes', '%s', nodes,
-                 label="evolve.node")
+        nodes = fm.formatlist(shortsnodes, b'succnodes', sep=b', ')
+        fm.write(b'succnodes', b'%s', nodes,
+                 label=b"evolve.node")
 
     # Operations
     operations = compat.markersoperations(markers)
     if operations:
-        fm.plain(' using ')
-        fm.write('operation', '%s', ", ".join(operations), label="evolve.operation")
+        fm.plain(b' using ')
+        fm.write(b'operation', b'%s', b", ".join(operations), label=b"evolve.operation")
 
-    fm.plain(' by ')
+    fm.plain(b' by ')
 
     # Users
     users = compat.markersusers(markers)
-    fm.write('user', '%s', ", ".join(users),
-             label="evolve.user")
-    fm.plain(' ')
+    fm.write(b'user', b'%s', b", ".join(users),
+             label=b"evolve.user")
+    fm.plain(b' ')
 
     # Dates
     dates = compat.markersdates(markers)
@@ -691,10 +691,10 @@
         max_date = max(dates)
 
         if min_date == max_date:
-            fm.write("date", "(at %s)", fm.formatdate(min_date), label="evolve.date")
+            fm.write(b"date", b"(at %s)", fm.formatdate(min_date), label=b"evolve.date")
         else:
-            fm.write("date", "(between %s and %s)", fm.formatdate(min_date),
-                     fm.formatdate(max_date), label="evolve.date")
+            fm.write(b"date", b"(between %s and %s)", fm.formatdate(min_date),
+                     fm.formatdate(max_date), label=b"evolve.date")
 
     # initial support for showing note
     # if metadata.get('note'):
@@ -717,20 +717,20 @@
 
             if descriptionpatch:
                 # add the diffheader
-                diffheader = "diff -r %s -r %s changeset-description\n" % \
+                diffheader = b"diff -r %s -r %s changeset-description\n" %\
                              (basectx, succctx)
                 descriptionpatch = diffheader + descriptionpatch
 
                 def tolist(text):
                     return [text]
 
-                fm.plain("\n")
+                fm.plain(b"\n")
 
                 for chunk, label in patch.difflabel(tolist, descriptionpatch):
-                    chunk = chunk.strip('\t')
-                    if chunk and chunk != '\n':
-                        fm.plain('    ')
-                    fm.write('desc-diff', '%s', chunk, label=label)
+                    chunk = chunk.strip(b'\t')
+                    if chunk and chunk != b'\n':
+                        fm.plain(b'    ')
+                    fm.write(b'desc-diff', b'%s', chunk, label=label)
 
             # Content patch
             diffopts = patch.diffallopts(repo.ui, {})
@@ -739,18 +739,18 @@
             for chunk, label in patch.diffui(repo, node, succ, matchfn,
                                              opts=diffopts):
                 if firstline:
-                    fm.plain('\n')
+                    fm.plain(b'\n')
                     firstline = False
-                if chunk and chunk != '\n':
-                    fm.plain('    ')
-                fm.write('patch', '%s', chunk, label=label)
+                if chunk and chunk != b'\n':
+                    fm.plain(b'    ')
+                fm.write(b'patch', b'%s', chunk, label=label)
         else:
-            nopatch = "    (No patch available, %s)" % _patchavailable[1]
-            fm.plain("\n")
+            nopatch = b"    (No patch available, %s)" % _patchavailable[1]
+            fm.plain(b"\n")
             # TODO: should be in json too
             fm.plain(nopatch)
 
-    fm.plain("\n")
+    fm.plain(b"\n")
 
 # logic around storing and using effect flags
 DESCCHANGED = 1 << 0 # action changed the description
@@ -762,11 +762,11 @@
 BRANCHCHANGED = 1 << 6 # the branch changed
 
 METABLACKLIST = [
-    re.compile('^__touch-noise__$'),
-    re.compile('^branch$'),
-    re.compile('^.*-source$'),
-    re.compile('^.*_source$'),
-    re.compile('^source$'),
+    re.compile(b'^__touch-noise__$'),
+    re.compile(b'^branch$'),
+    re.compile(b'^.*-source$'),
+    re.compile(b'^.*_source$'),
+    re.compile(b'^source$'),
 ]
 
 def ismetablacklisted(metaitem):
@@ -810,17 +810,17 @@
 
     if len(successorssets) == 0:
         # The commit has been pruned
-        return 'pruned'
+        return b'pruned'
     elif len(successorssets) > 1:
-        return 'diverged'
+        return b'diverged'
     else:
         # No divergence, only one set of successors
         successors = successorssets[0]
 
         if len(successors) == 1:
-            return 'superseed'
+            return b'superseed'
         else:
-            return 'superseed_split'
+            return b'superseed_split'
 
 def _getobsfateandsuccs(repo, revnode, successorssets=None):
     """ Return a tuple containing:
@@ -853,8 +853,8 @@
     dates = [m[4] for m in markers]
 
     return {
-        'min_date': min(dates),
-        'max_date': max(dates)
+        b'min_date': min(dates),
+        b'max_date': max(dates)
     }
 
 def _successorsetusers(successorset, markers):
@@ -865,18 +865,18 @@
 
     # Check that user is present in meta
     markersmeta = [dict(m[3]) for m in markers]
-    users = set(meta.get('user') for meta in markersmeta if meta.get('user'))
+    users = set(meta.get(b'user') for meta in markersmeta if meta.get(b'user'))
 
-    return {'users': sorted(users)}
+    return {b'users': sorted(users)}
 
 VERBMAPPING = {
-    DESCCHANGED: "reworded",
-    METACHANGED: "meta-changed",
-    USERCHANGED: "reauthored",
-    DATECHANGED: "date-changed",
-    BRANCHCHANGED: "branch-changed",
-    PARENTCHANGED: "rebased",
-    DIFFCHANGED: "amended"
+    DESCCHANGED: b"reworded",
+    METACHANGED: b"meta-changed",
+    USERCHANGED: b"reauthored",
+    DATECHANGED: b"date-changed",
+    BRANCHCHANGED: b"branch-changed",
+    PARENTCHANGED: b"rebased",
+    DIFFCHANGED: b"amended"
 }
 
 def _successorsetverb(successorset, markers):
@@ -884,12 +884,12 @@
     """
     verb = None
     if not successorset:
-        verb = 'pruned'
+        verb = b'pruned'
     elif len(successorset) == 1:
         # Check for effect flag
 
         metadata = [dict(marker[3]) for marker in markers]
-        ef1 = [data.get('ef1') for data in metadata]
+        ef1 = [data.get(b'ef1') for data in metadata]
 
         if all(ef1):
             combined = 0
@@ -901,28 +901,28 @@
                 verb = VERBMAPPING[combined]
 
         if verb is None:
-            verb = 'rewritten'
+            verb = b'rewritten'
     else:
-        verb = 'split'
-    return {'verb': verb}
+        verb = b'split'
+    return {b'verb': verb}
 
 # Use a more advanced version of obsfateverb that uses effect-flag
-if util.safehasattr(obsutil, 'obsfateverb'):
+if util.safehasattr(obsutil, b'obsfateverb'):
 
-    @eh.wrapfunction(obsutil, 'obsfateverb')
+    @eh.wrapfunction(obsutil, b'obsfateverb')
     def obsfateverb(orig, *args, **kwargs):
-        return _successorsetverb(*args, **kwargs)['verb']
+        return _successorsetverb(*args, **kwargs)[b'verb']
 
 # Hijack callers of successorsetverb
-elif util.safehasattr(obsutil, 'obsfateprinter'):
+elif util.safehasattr(obsutil, b'obsfateprinter'):
 
-    @eh.wrapfunction(obsutil, 'obsfateprinter')
+    @eh.wrapfunction(obsutil, b'obsfateprinter')
     def obsfateprinter(orig, successors, markers, ui):
 
         def closure(successors):
-            return _successorsetverb(successors, markers)['verb']
+            return _successorsetverb(successors, markers)[b'verb']
 
-        if not util.safehasattr(obsutil, 'successorsetverb'):
+        if not util.safehasattr(obsutil, b'successorsetverb'):
             return orig(successors, markers, ui)
 
         # Save the old value
@@ -996,8 +996,8 @@
 
     # Format basic data
     data = {
-        "successors": sorted(successorset),
-        "markers": sorted(markers)
+        b"successors": sorted(successorset),
+        b"markers": sorted(markers)
     }
 
     # Call an extensible list of functions to override or add new data
diff --git a/hgext3rd/evolve/rewind.py b/hgext3rd/evolve/rewind.py
--- a/hgext3rd/evolve/rewind.py
+++ b/hgext3rd/evolve/rewind.py
@@ -26,14 +26,14 @@
 identicalflag = 4
 
 @eh.command(
-    'rewind|undo',
-    [('', 'to', [], _("rewind to these revisions"), _('REV')),
-     ('', 'as-divergence', None, _("preserve current latest successors")),
-     ('', 'exact', None, _("only rewind explicitly selected revisions")),
-     ('', 'from', [],
-      _("rewind these revisions to their predecessors"), _('REV')),
-    ],
-    _(''),
+    b'rewind|undo',
+    [(b'', b'to', [], _(b"rewind to these revisions"), _(b'REV')),
+     (b'', b'as-divergence', None, _(b"preserve current latest successors")),
+     (b'', b'exact', None, _(b"only rewind explicitly selected revisions")),
+     (b'', b'from', [],
+      _(b"rewind these revisions to their predecessors"), _(b'REV')),
+     ],
+    _(b''),
     helpbasic=True)
 def rewind(ui, repo, **opts):
     """rewind a stack of changesets to a previous state
@@ -85,20 +85,20 @@
 
         rewinded = _select_rewinded(repo, opts)
 
-        if not opts['as_divergence']:
+        if not opts[b'as_divergence']:
             for rev in rewinded:
                 ctx = unfi[rev]
                 ssets = obsutil.successorssets(repo, ctx.node(), sscache)
                 if 1 < len(ssets):
-                    msg = _('rewind confused by divergence on %s') % ctx
-                    hint = _('solve divergence first or use "--as-divergence"')
+                    msg = _(b'rewind confused by divergence on %s') % ctx
+                    hint = _(b'solve divergence first or use "--as-divergence"')
                     raise error.Abort(msg, hint=hint)
                 if ssets and ssets[0]:
                     for succ in ssets[0]:
                         successorsmap[succ].add(ctx.node())
 
         # Check that we can rewind these changesets
-        with repo.transaction('rewind'):
+        with repo.transaction(b'rewind'):
             for rev in sorted(rewinded):
                 ctx = unfi[rev]
                 rewindmap[ctx.node()] = _revive_revision(unfi, rev, rewindmap)
@@ -113,36 +113,36 @@
                 relationships.append(rel)
                 if wctxp.node() == source:
                     update_target = newdest[-1]
-            obsolete.createmarkers(unfi, relationships, operation='rewind')
+            obsolete.createmarkers(unfi, relationships, operation=b'rewind')
             if update_target is not None:
                 hg.updaterepo(repo, update_target, False)
 
-    repo.ui.status(_('rewinded to %d changesets\n') % len(rewinded))
+    repo.ui.status(_(b'rewinded to %d changesets\n') % len(rewinded))
     if relationships:
-        repo.ui.status(_('(%d changesets obsoleted)\n') % len(relationships))
+        repo.ui.status(_(b'(%d changesets obsoleted)\n') % len(relationships))
     if update_target is not None:
-        ui.status(_('working directory is now at %s\n') % repo['.'])
+        ui.status(_(b'working directory is now at %s\n') % repo[b'.'])
 
 def _select_rewinded(repo, opts):
     """select the revision we shoudl rewind to
     """
     unfi = repo.unfiltered()
     rewinded = set()
-    revsto = opts.get('to')
-    revsfrom = opts.get('from')
+    revsto = opts.get(b'to')
+    revsfrom = opts.get(b'from')
     if not (revsto or revsfrom):
-        revsfrom.append('.')
+        revsfrom.append(b'.')
     if revsto:
         rewinded.update(scmutil.revrange(repo, revsto))
     if revsfrom:
         succs = scmutil.revrange(repo, revsfrom)
-        rewinded.update(unfi.revs('predecessors(%ld)', succs))
+        rewinded.update(unfi.revs(b'predecessors(%ld)', succs))
 
     if not rewinded:
-        raise error.Abort('no revision to rewind to')
+        raise error.Abort(b'no revision to rewind to')
 
-    if not opts['exact']:
-        rewinded = unfi.revs('obsolete() and ::%ld', rewinded)
+    if not opts[b'exact']:
+        rewinded = unfi.revs(b'obsolete() and ::%ld', rewinded)
 
     return sorted(rewinded)
 
@@ -152,27 +152,27 @@
     ctx = unfi[rev]
     extra = ctx.extra().copy()
     # rewind hash should be unique over multiple rewind.
-    user = unfi.ui.config('devel', 'user.obsmarker')
+    user = unfi.ui.config(b'devel', b'user.obsmarker')
     if not user:
         user = unfi.ui.username()
-    date = unfi.ui.configdate('devel', 'default-date')
+    date = unfi.ui.configdate(b'devel', b'default-date')
     if date is None:
         date = compat.makedate()
-    noise = "%s\0%s\0%d\0%d" % (ctx.node(), user, date[0], date[1])
-    extra['__rewind-hash__'] = hashlib.sha256(noise).hexdigest()
+    noise = b"%s\0%s\0%d\0%d" % (ctx.node(), user, date[0], date[1])
+    extra[b'__rewind-hash__'] = hashlib.sha256(noise).hexdigest()
 
     p1 = ctx.p1().node()
     p1 = rewindmap.get(p1, p1)
     p2 = ctx.p2().node()
     p2 = rewindmap.get(p2, p2)
 
-    extradict = {'extra': extra}
+    extradict = {b'extra': extra}
 
     new, unusedvariable = rewriteutil.rewrite(unfi, ctx, [], ctx,
                                               [p1, p2],
                                               commitopts=extradict)
 
     obsolete.createmarkers(unfi, [(ctx, (unfi[new],))],
-                           flag=identicalflag, operation='rewind')
+                           flag=identicalflag, operation=b'rewind')
 
     return new
diff --git a/hgext3rd/evolve/rewriteutil.py b/hgext3rd/evolve/rewriteutil.py
--- a/hgext3rd/evolve/rewriteutil.py
+++ b/hgext3rd/evolve/rewriteutil.py
@@ -44,37 +44,37 @@
     numrevs = len(revs)
     if numrevs < maxrevs:
         shorts = [node.short(tonode(r)) for r in revs]
-        summary = ', '.join(shorts)
+        summary = b', '.join(shorts)
     else:
         first = revs.first()
-        summary = _('%s and %d others')
+        summary = _(b'%s and %d others')
         summary %= (node.short(tonode(first)), numrevs - 1)
     return summary
 
-def precheck(repo, revs, action='rewrite'):
+def precheck(repo, revs, action=b'rewrite'):
     """check if <revs> can be rewritten
 
     <action> can be used to control the commit message.
     """
     if node.nullrev in revs:
-        msg = _("cannot %s the null revision") % (action)
-        hint = _("no changeset checked out")
+        msg = _(b"cannot %s the null revision") % (action)
+        hint = _(b"no changeset checked out")
         raise error.Abort(msg, hint=hint)
-    if any(util.safehasattr(r, 'rev') for r in revs):
-        msg = "rewriteutil.precheck called with ctx not revs"
+    if any(util.safehasattr(r, b'rev') for r in revs):
+        msg = b"rewriteutil.precheck called with ctx not revs"
         repo.ui.develwarn(msg)
         revs = (r.rev() for r in revs)
-    publicrevs = repo.revs('%ld and public()', revs)
+    publicrevs = repo.revs(b'%ld and public()', revs)
     if publicrevs:
         summary = _formatrevs(repo, publicrevs)
-        msg = _("cannot %s public changesets: %s") % (action, summary)
-        hint = _("see 'hg help phases' for details")
+        msg = _(b"cannot %s public changesets: %s") % (action, summary)
+        hint = _(b"see 'hg help phases' for details")
         raise error.Abort(msg, hint=hint)
     newunstable = disallowednewunstable(repo, revs)
     if newunstable:
-        msg = _("%s will orphan %i descendants")
+        msg = _(b"%s will orphan %i descendants")
         msg %= (action, len(newunstable))
-        hint = _("see 'hg help evolution.instability'")
+        hint = _(b"see 'hg help evolution.instability'")
         raise error.Abort(msg, hint=hint)
 
 def bookmarksupdater(repo, oldid, tr):
@@ -96,22 +96,22 @@
     allowunstable = obsolete.isenabled(repo, obsolete.allowunstableopt)
     if allowunstable:
         return revset.baseset()
-    return repo.revs("(%ld::) - %ld", revs, revs)
+    return repo.revs(b"(%ld::) - %ld", revs, revs)
 
 def foldcheck(repo, revs):
     """check that <revs> can be folded"""
-    precheck(repo, revs, action='fold')
-    roots = repo.revs('roots(%ld)', revs)
+    precheck(repo, revs, action=b'fold')
+    roots = repo.revs(b'roots(%ld)', revs)
     if len(roots) > 1:
-        raise error.Abort(_("cannot fold non-linear revisions "
-                            "(multiple roots given)"))
+        raise error.Abort(_(b"cannot fold non-linear revisions "
+                            b"(multiple roots given)"))
     root = repo[roots.first()]
     if root.phase() <= phases.public:
-        raise error.Abort(_("cannot fold public revisions"))
-    heads = repo.revs('heads(%ld)', revs)
+        raise error.Abort(_(b"cannot fold public revisions"))
+    heads = repo.revs(b'heads(%ld)', revs)
     if len(heads) > 1:
-        raise error.Abort(_("cannot fold non-linear revisions "
-                            "(multiple heads given)"))
+        raise error.Abort(_(b"cannot fold non-linear revisions "
+                            b"(multiple heads given)"))
     head = repo[heads.first()]
     return root, head
 
@@ -120,14 +120,14 @@
     try:
         wlock = repo.wlock()
         lock = repo.lock()
-        tr = repo.transaction('prune')
+        tr = repo.transaction(b'prune')
         bmchanges = []
         for bookmark in bookmarks:
             bmchanges.append((bookmark, None))
         repo._bookmarks.applychanges(repo, tr, bmchanges)
         tr.close()
         for bookmark in sorted(bookmarks):
-            repo.ui.write(_("bookmark '%s' deleted\n") % bookmark)
+            repo.ui.write(_(b"bookmark '%s' deleted\n") % bookmark)
     finally:
         lockmod.release(tr, lock, wlock)
 
@@ -143,14 +143,14 @@
     """
     repomarks = repo._bookmarks
     if not bookmarks.issubset(repomarks):
-        raise error.Abort(_("bookmark '%s' not found") %
-                          ','.join(sorted(bookmarks - set(repomarks.keys()))))
+        raise error.Abort(_(b"bookmark '%s' not found") %
+                          b','.join(sorted(bookmarks - set(repomarks.keys()))))
 
     # If the requested bookmark is not the only one pointing to a
     # a revision we have to only delete the bookmark and not strip
     # anything. revsets cannot detect that case.
     nodetobookmarks = {}
-    for mark, bnode in repomarks.iteritems():
+    for mark, bnode in repomarks.items():
         nodetobookmarks.setdefault(bnode, []).append(mark)
     for marks in nodetobookmarks.values():
         if bookmarks.issuperset(marks):
@@ -170,9 +170,9 @@
     try:
         wlock = repo.wlock()
         lock = repo.lock()
-        tr = repo.transaction('rewrite')
+        tr = repo.transaction(b'rewrite')
         if len(old.parents()) > 1: # XXX remove this unnecessary limitation.
-            raise error.Abort(_('cannot amend merge changesets'))
+            raise error.Abort(_(b'cannot amend merge changesets'))
         base = old.p1()
         updatebookmarks = bookmarksupdater(repo, old.node(), tr)
 
@@ -213,13 +213,13 @@
         if not message:
             message = old.description()
 
-        user = commitopts.get('user') or old.user()
+        user = commitopts.get(b'user') or old.user()
         # TODO: In case not date is given, we should take the old commit date
         # if we are working one one changeset or mimic the fold behavior about
         # date
-        date = commitopts.get('date') or None
-        extra = dict(commitopts.get('extra', old.extra()))
-        extra['branch'] = head.branch()
+        date = commitopts.get(b'date') or None
+        extra = dict(commitopts.get(b'extra', old.extra()))
+        extra[b'branch'] = head.branch()
 
         new = context.memctx(repo,
                              parents=newbases,
@@ -230,7 +230,7 @@
                              date=date,
                              extra=extra)
 
-        if commitopts.get('edit'):
+        if commitopts.get(b'edit'):
             new._text = cmdutil.commitforceeditor(repo, new, [])
         revcount = len(repo)
         newid = repo.commitctx(new)
diff --git a/hgext3rd/evolve/safeguard.py b/hgext3rd/evolve/safeguard.py
--- a/hgext3rd/evolve/safeguard.py
+++ b/hgext3rd/evolve/safeguard.py
@@ -20,9 +20,9 @@
 eh = exthelper.exthelper()
 
 # hg <= 4.8
-if 'auto-publish' not in configitems.coreitems.get('experimental', {}):
+if b'auto-publish' not in configitems.coreitems.get(b'experimental', {}):
 
-    eh.configitem('experimental', 'auto-publish', 'publish')
+    eh.configitem(b'experimental', b'auto-publish', b'publish')
 
     @eh.reposetup
     def setuppublishprevention(ui, repo):
@@ -31,25 +31,25 @@
 
             def checkpush(self, pushop):
                 super(noautopublishrepo, self).checkpush(pushop)
-                behavior = self.ui.config('experimental', 'auto-publish')
-                nocheck = behavior not in ('warn', 'abort')
+                behavior = self.ui.config(b'experimental', b'auto-publish')
+                nocheck = behavior not in (b'warn', b'abort')
                 if nocheck or getattr(pushop, 'publish', False):
                     return
-                remotephases = pushop.remote.listkeys('phases')
-                publishing = remotephases.get('publishing', False)
+                remotephases = pushop.remote.listkeys(b'phases')
+                publishing = remotephases.get(b'publishing', False)
                 if publishing:
                     if pushop.revs is None:
-                        published = self.filtered('served').revs("not public()")
+                        published = self.filtered(b'served').revs(b"not public()")
                     else:
-                        published = self.revs("::%ln - public()", pushop.revs)
+                        published = self.revs(b"::%ln - public()", pushop.revs)
                     if published:
-                        if behavior == 'warn':
-                            self.ui.warn(_('%i changesets about to be published\n')
+                        if behavior == b'warn':
+                            self.ui.warn(_(b'%i changesets about to be published\n')
                                          % len(published))
-                        elif behavior == 'abort':
-                            msg = _('push would publish 1 changesets')
-                            hint = _("behavior controlled by "
-                                     "'experimental.auto-publish' config")
+                        elif behavior == b'abort':
+                            msg = _(b'push would publish 1 changesets')
+                            hint = _(b"behavior controlled by "
+                                     b"'experimental.auto-publish' config")
                             raise error.Abort(msg, hint=hint)
 
         repo.__class__ = noautopublishrepo
diff --git a/hgext3rd/evolve/serveronly.py b/hgext3rd/evolve/serveronly.py
--- a/hgext3rd/evolve/serveronly.py
+++ b/hgext3rd/evolve/serveronly.py
@@ -24,7 +24,7 @@
         obsexchange,
     )
 except ValueError as exc:
-    if str(exc) != 'Attempted relative import in non-package':
+    if str(exc) != b'Attempted relative import in non-package':
         raise
     # extension imported using direct path
     sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
@@ -53,11 +53,11 @@
 
 @eh.reposetup
 def default2evolution(ui, repo):
-    evolveopts = repo.ui.configlist('experimental', 'evolution')
+    evolveopts = repo.ui.configlist(b'experimental', b'evolution')
     if not evolveopts:
-        evolveopts = 'all'
-        repo.ui.setconfig('experimental', 'evolution', evolveopts)
-    if obsolete.isenabled(repo, 'exchange'):
+        evolveopts = b'all'
+        repo.ui.setconfig(b'experimental', b'evolution', evolveopts)
+    if obsolete.isenabled(repo, b'exchange'):
         # if no config explicitly set, disable bundle1
-        if not isinstance(repo.ui.config('server', 'bundle1'), str):
-            repo.ui.setconfig('server', 'bundle1', False)
+        if not isinstance(repo.ui.config(b'server', b'bundle1'), str):
+            repo.ui.setconfig(b'server', b'bundle1', False)
diff --git a/hgext3rd/evolve/stablerange.py b/hgext3rd/evolve/stablerange.py
--- a/hgext3rd/evolve/stablerange.py
+++ b/hgext3rd/evolve/stablerange.py
@@ -64,23 +64,23 @@
     return ranges
 
 _stablerangemethodmap = {
-    'branchpoint': lambda repo: stablerange(),
-    'default': lambda repo: repo.stablerange,
-    'basic-branchpoint': lambda repo: stablerangebasic(),
-    'basic-mergepoint': lambda repo: stablerangedummy_mergepoint(),
-    'mergepoint': lambda repo: stablerange_mergepoint(),
+    b'branchpoint': lambda repo: stablerange(),
+    b'default': lambda repo: repo.stablerange,
+    b'basic-branchpoint': lambda repo: stablerangebasic(),
+    b'basic-mergepoint': lambda repo: stablerangedummy_mergepoint(),
+    b'mergepoint': lambda repo: stablerange_mergepoint(),
 }
 
 @eh.command(
-    'debugstablerange',
+    b'debugstablerange',
     [
-        ('r', 'rev', [], 'operate on (rev, 0) ranges for rev in REVS'),
-        ('', 'subranges', False, 'recursively display data for subranges too'),
-        ('', 'verify', False, 'checks subranges content (EXPENSIVE)'),
-        ('', 'method', 'branchpoint',
-         'method to use, one of "branchpoint", "mergepoint"')
-    ],
-    _(''))
+        (b'r', b'rev', [], b'operate on (rev, 0) ranges for rev in REVS'),
+        (b'', b'subranges', False, b'recursively display data for subranges too'),
+        (b'', b'verify', False, b'checks subranges content (EXPENSIVE)'),
+        (b'', b'method', b'branchpoint',
+         b'method to use, one of "branchpoint", "mergepoint"')
+     ],
+    _(b''))
 def debugstablerange(ui, repo, **opts):
     """display standard stable subrange for a set of ranges
 
@@ -88,11 +88,11 @@
     --verbose to get the extra details in ().
     """
     short = nodemod.short
-    revs = scmutil.revrange(repo, opts['rev'])
+    revs = scmutil.revrange(repo, opts[b'rev'])
     if not revs:
-        raise error.Abort('no revisions specified')
+        raise error.Abort(b'no revisions specified')
     if ui.verbose:
-        template = '%s-%d (%d, %d, %d)'
+        template = b'%s-%d (%d, %d, %d)'
 
         def _rangestring(repo, rangeid):
             return template % (
@@ -103,7 +103,7 @@
                 length(unfi, rangeid)
             )
     else:
-        template = '%s-%d'
+        template = b'%s-%d'
 
         def _rangestring(repo, rangeid):
             return template % (
@@ -114,10 +114,10 @@
     unfi = repo.unfiltered()
     node = unfi.changelog.node
 
-    method = opts['method']
+    method = opts[b'method']
     getstablerange = _stablerangemethodmap.get(method)
     if getstablerange is None:
-        raise error.Abort('unknown stable sort method: "%s"' % method)
+        raise error.Abort(b'unknown stable sort method: "%s"' % method)
 
     stablerange = getstablerange(unfi)
     depth = stablerange.depthrev
@@ -125,28 +125,28 @@
     subranges = stablerange.subranges
     stablerange.warmup(repo, max(revs))
 
-    if opts['subranges']:
+    if opts[b'subranges']:
         ranges = subrangesclosure(unfi, stablerange, revs)
     else:
         ranges = [(r, 0) for r in revs]
 
     for r in ranges:
         subs = subranges(unfi, r)
-        subsstr = ', '.join(_rangestring(unfi, s) for s in subs)
+        subsstr = b', '.join(_rangestring(unfi, s) for s in subs)
         rstr = _rangestring(unfi, r)
-        if opts['verify']:
-            status = 'leaf'
+        if opts[b'verify']:
+            status = b'leaf'
             if 1 < length(unfi, r):
-                status = 'complete'
+                status = b'complete'
                 revs = set(stablerange.revsfromrange(unfi, r))
                 subrevs = set()
                 for s in subs:
                     subrevs.update(stablerange.revsfromrange(unfi, s))
                 if revs != subrevs:
-                    status = 'missing'
-            ui.status('%s [%s] - %s\n' % (rstr, status, subsstr))
+                    status = b'missing'
+            ui.status(b'%s [%s] - %s\n' % (rstr, status, subsstr))
         else:
-            ui.status('%s - %s\n' % (rstr, subsstr))
+            ui.status(b'%s - %s\n' % (rstr, subsstr))
 
 class abstractstablerange(object):
     """The official API for a stablerange"""
@@ -214,7 +214,7 @@
 
     def depthrev(self, repo, rev):
         """depth a revision"""
-        return len(repo.revs('::%d', rev))
+        return len(repo.revs(b'::%d', rev))
 
     def revsfromrange(self, repo, rangeid):
         """return revision contained in a range
@@ -620,12 +620,12 @@
         rangeheap = []
         for idx, r in enumerate(revs):
             if not idx % 1000:
-                compat.progress(ui, _("filling depth cache"), idx, total=nbrevs,
-                                unit=_("changesets"))
+                compat.progress(ui, _(b"filling depth cache"), idx, total=nbrevs,
+                                unit=_(b"changesets"))
             # warm up depth
             self.depthrev(repo, r)
             rangeheap.append((-r, (r, 0)))
-        compat.progress(ui, _("filling depth cache"), None, total=nbrevs)
+        compat.progress(ui, _(b"filling depth cache"), None, total=nbrevs)
 
         heappop = heapq.heappop
         heappush = heapq.heappush
@@ -646,8 +646,8 @@
                     progress_new = time.time()
                     if (1 < progress_each) and (0.1 < progress_new - progress_last):
                         progress_each /= 10
-                    compat.progress(ui, _("filling stablerange cache"), seen,
-                                    total=nbrevs, unit=_("changesets"))
+                    compat.progress(ui, _(b"filling stablerange cache"), seen,
+                                    total=nbrevs, unit=_(b"changesets"))
                     progress_last = progress_new
                 seen += 1
                 original.remove(value) # might have been added from other source
@@ -656,13 +656,13 @@
                 for sub in self.subranges(repo, rangeid):
                     if self._getsub(sub) is None:
                         heappush(rangeheap, (-sub[0], sub))
-        compat.progress(ui, _("filling stablerange cache"), None, total=nbrevs)
+        compat.progress(ui, _(b"filling stablerange cache"), None, total=nbrevs)
 
         self._tiprev = upto
         self._tipnode = cl.node(upto)
 
         duration = util.timer() - starttime
-        repo.ui.log('evoext-cache', 'updated stablerange cache in %.4f seconds\n',
+        repo.ui.log(b'evoext-cache', b'updated stablerange cache in %.4f seconds\n',
                     duration)
 
     def subranges(self, repo, rangeid):
diff --git a/hgext3rd/evolve/stablerangecache.py b/hgext3rd/evolve/stablerangecache.py
--- a/hgext3rd/evolve/stablerangecache.py
+++ b/hgext3rd/evolve/stablerangecache.py
@@ -98,8 +98,8 @@
                         warned_long = True
                     if (1 < progress_each) and (0.1 < progress_new - progress_last):
                         progress_each /= 10
-                    compat.progress(ui, _("filling stablerange cache"), seen,
-                                    total=total, unit=_("changesets"))
+                    compat.progress(ui, _(b"filling stablerange cache"), seen,
+                                    total=total, unit=_(b"changesets"))
                     progress_last = progress_new
                 seen += 1
                 original.remove(rangeid) # might have been added from other source
@@ -108,7 +108,7 @@
                 for sub in self.subranges(repo, rangeid):
                     if self._getsub(sub) is None:
                         heappush(rangeheap, sub)
-        compat.progress(ui, _("filling stablerange cache"), None, total=total)
+        compat.progress(ui, _(b"filling stablerange cache"), None, total=total)
 
     def clear(self, reset=False):
         super(stablerangeondiskbase, self).clear()
@@ -131,23 +131,23 @@
                               FOREIGN KEY (suprev, supidx) REFERENCES range(rev, idx),
                               FOREIGN KEY (subrev, subidx) REFERENCES range(rev, idx)
     );""",
-    "CREATE INDEX subranges_index ON subranges (suprev, supidx);",
-    "CREATE INDEX superranges_index ON subranges (subrev, subidx);",
-    "CREATE INDEX range_index ON range (rev, idx);",
+    b"CREATE INDEX subranges_index ON subranges (suprev, supidx);",
+    b"CREATE INDEX superranges_index ON subranges (subrev, subidx);",
+    b"CREATE INDEX range_index ON range (rev, idx);",
     """CREATE TABLE meta(schemaversion INTEGER NOT NULL,
                          tiprev        INTEGER NOT NULL,
                          tipnode       BLOB    NOT NULL
                         );""",
 ]
-_newmeta = "INSERT INTO meta (schemaversion, tiprev, tipnode) VALUES (?,?,?);"
-_updatemeta = "UPDATE meta SET tiprev = ?, tipnode = ?;"
-_updaterange = "INSERT INTO range(rev, idx) VALUES (?,?);"
+_newmeta = b"INSERT INTO meta (schemaversion, tiprev, tipnode) VALUES (?,?,?);"
+_updatemeta = b"UPDATE meta SET tiprev = ?, tipnode = ?;"
+_updaterange = b"INSERT INTO range(rev, idx) VALUES (?,?);"
 _updatesubranges = """INSERT
                        INTO subranges(listidx, suprev, supidx, subrev, subidx)
                        VALUES (?,?,?,?,?);"""
-_queryexist = "SELECT name FROM sqlite_master WHERE type='table' AND name='meta';"
-_querymeta = "SELECT schemaversion, tiprev, tipnode FROM meta;"
-_queryrange = "SELECT * FROM range WHERE (rev = ? AND idx = ?);"
+_queryexist = b"SELECT name FROM sqlite_master WHERE type='table' AND name='meta';"
+_querymeta = b"SELECT schemaversion, tiprev, tipnode FROM meta;"
+_queryrange = b"SELECT * FROM range WHERE (rev = ? AND idx = ?);"
 _querysubranges = """SELECT subrev, subidx
                      FROM subranges
                      WHERE (suprev = ? AND supidx = ?)
@@ -157,11 +157,11 @@
                            FROM subranges
                            WHERE %s;"""
 
-_querysuperrangesbody = '(subrev = %d and subidx = %d)'
+_querysuperrangesbody = b'(subrev = %d and subidx = %d)'
 
 def _make_querysuperranges(ranges):
     # building a tree of OR would allow for more ranges
-    body = ' OR '.join(_querysuperrangesbody % r for r in ranges)
+    body = b' OR '.join(_querysuperrangesbody % r for r in ranges)
     return _querysuperrangesmain % body
 
 class stablerangesqlbase(stablerange.stablerangecached):
@@ -218,7 +218,7 @@
             except (sqlite3.DatabaseError, sqlite3.OperationalError):
                 # something is wrong with the sqlite db
                 # Since this is a cache, we ignore it.
-                if '_con' in vars(self):
+                if b'_con' in vars(self):
                     del self._con
                 self._unsavedsubranges.clear()
 
@@ -234,7 +234,7 @@
             util.makedirs(self._vfs.dirname(self._path))
         except OSError:
             return None
-        con = sqlite3.connect(self._path, timeout=30, isolation_level="IMMEDIATE")
+        con = sqlite3.connect(self._path, timeout=30, isolation_level=b"IMMEDIATE")
         con.text_factory = str
         return con
 
@@ -272,11 +272,11 @@
             #
             # operational error catch read-only and locked database
             # IntegrityError catch Unique constraint error that may arise
-            if '_con' in vars(self):
+            if b'_con' in vars(self):
                 del self._con
             self._unsavedsubranges.clear()
-            repo.ui.log('evoext-cache', 'error while saving new data: %s' % exc)
-            repo.ui.debug('evoext-cache: error while saving new data: %s' % exc)
+            repo.ui.log(b'evoext-cache', b'error while saving new data: %s' % exc)
+            repo.ui.debug(b'evoext-cache: error while saving new data: %s' % exc)
 
     def _trysave(self, repo):
         repo = repo.unfiltered()
@@ -288,7 +288,7 @@
 
         if self._con is None:
             util.unlinkpath(self._path, ignoremissing=True)
-            if '_con' in vars(self):
+            if b'_con' in vars(self):
                 del self._con
 
             con = self._db()
@@ -313,9 +313,9 @@
                 # drifting is currently an issue because this means another
                 # process might have already added the cache line we are about
                 # to add. This will confuse sqlite
-                msg = _('stable-range cache: skipping write, '
-                        'database drifted under my feet\n')
-                hint = _('(disk: %s-%s vs mem: %s-%s)\n')
+                msg = _(b'stable-range cache: skipping write, '
+                        b'database drifted under my feet\n')
+                hint = _(b'(disk: %s-%s vs mem: %s-%s)\n')
                 data = (nodemod.hex(meta[2]), meta[1],
                         nodemod.hex(self._ondisktipnode), self._ondisktiprev)
                 repo.ui.warn(msg)
@@ -369,7 +369,7 @@
 
     def clear(self, reset=False):
         super(stablerangesql, self).clear(reset=reset)
-        if '_con' in vars(self):
+        if b'_con' in vars(self):
             del self._con
         self._subrangescache.clear()
 
@@ -390,13 +390,13 @@
 class mergepointsql(stablerangesql, stablerange.stablerange_mergepoint):
 
     _schemaversion = 3
-    _cachefile = 'evoext_stablerange_v2.sqlite'
-    _cachename = 'evo-ext-stablerange-mergepoint'
+    _cachefile = b'evoext_stablerange_v2.sqlite'
+    _cachename = b'evo-ext-stablerange-mergepoint'
 
 class sqlstablerange(stablerangesqlbase, stablerange.stablerange):
 
     _schemaversion = 1
-    _cachefile = 'evoext_stablerange_v1.sqlite'
+    _cachefile = b'evoext_stablerange_v1.sqlite'
 
     def warmup(self, repo, upto=None):
         self._con # make sure the data base is loaded
@@ -413,8 +413,8 @@
         except error.LockError:
             # Exceptionnally we are noisy about it since performance impact is
             # large We should address that before using this more widely.
-            repo.ui.warn('stable-range cache: unable to lock repo while warming\n')
-            repo.ui.warn('(cache will not be saved)\n')
+            repo.ui.warn(b'stable-range cache: unable to lock repo while warming\n')
+            repo.ui.warn(b'(cache will not be saved)\n')
             super(sqlstablerange, self).warmup(repo, upto)
 
 @eh.reposetup
@@ -430,7 +430,7 @@
 
         @localrepo.unfilteredmethod
         def destroyed(self):
-            if 'stablerange' in vars(self):
+            if b'stablerange' in vars(self):
                 self.stablerange.clear()
                 del self.stablerange
             super(stablerangerepo, self).destroyed()
diff --git a/hgext3rd/evolve/stablesort.py b/hgext3rd/evolve/stablesort.py
--- a/hgext3rd/evolve/stablesort.py
+++ b/hgext3rd/evolve/stablesort.py
@@ -52,30 +52,30 @@
     return key
 
 @eh.command(
-    'debugstablesort',
+    b'debugstablesort',
     [
-        ('r', 'rev', [], 'heads to start from'),
-        ('', 'method', 'branchpoint', "method used for sorting, one of: "
-         "branchpoint, basic-mergepoint and basic-headstart"),
-        ('l', 'limit', '', 'number of revision display (default to all)')
-    ] + commands.formatteropts,
-    _(''))
+        (b'r', b'rev', [], b'heads to start from'),
+        (b'', b'method', b'branchpoint', b"method used for sorting, one of: "
+         b"branchpoint, basic-mergepoint and basic-headstart"),
+        (b'l', b'limit', b'', b'number of revision display (default to all)')
+     ] + commands.formatteropts,
+    _(b''))
 def debugstablesort(ui, repo, **opts):
     """display the ::REVS set topologically sorted in a stable way
     """
-    revs = scmutil.revrange(repo, opts['rev'])
+    revs = scmutil.revrange(repo, opts[b'rev'])
 
-    method = opts['method']
+    method = opts[b'method']
     sorting = _methodmap.get(method)
     if sorting is None:
-        valid_method = ', '.join(sorted(_methodmap))
-        raise error.Abort('unknown sorting method: "%s"' % method,
-                          hint='pick one of: %s' % valid_method)
+        valid_method = b', '.join(sorted(_methodmap))
+        raise error.Abort(b'unknown sorting method: "%s"' % method,
+                          hint=b'pick one of: %s' % valid_method)
 
     displayer = compat.changesetdisplayer(ui, repo, opts, buffered=True)
     kwargs = {}
-    if opts['limit']:
-        kwargs['limit'] = int(opts['limit'])
+    if opts[b'limit']:
+        kwargs[b'limit'] = int(opts[b'limit'])
     for r in sorting(repo, revs, **kwargs):
         ctx = repo[r]
         displayer.show(ctx)
@@ -178,7 +178,7 @@
         heads = list(sorted(revs))
     else:
         # keeps heads only
-        heads = sorted(repo.revs('sort(heads(%ld::%ld))', revs, revs), key=tiebreaker)
+        heads = sorted(repo.revs(b'sort(heads(%ld::%ld))', revs, revs), key=tiebreaker)
 
     results = []
     while heads:
@@ -244,24 +244,24 @@
     return result
 
 def stablesort_mergepoint_head_basic(repo, revs, limit=None):
-    heads = repo.revs('sort(heads(%ld))', revs)
+    heads = repo.revs(b'sort(heads(%ld))', revs)
     if not heads:
         return []
     elif 2 < len(heads):
-        raise error.Abort('cannot use head based merging, %d heads found'
+        raise error.Abort(b'cannot use head based merging, %d heads found'
                           % len(heads))
     head = heads.first()
-    revs = stablesort_mergepoint_bounded(repo, head, repo.revs('::%d', head))
+    revs = stablesort_mergepoint_bounded(repo, head, repo.revs(b'::%d', head))
     if limit is None:
         return revs
     return revs[-limit:]
 
 def stablesort_mergepoint_head_debug(repo, revs, limit=None):
-    heads = repo.revs('sort(heads(%ld))', revs)
+    heads = repo.revs(b'sort(heads(%ld))', revs)
     if not heads:
         return []
     elif 2 < len(heads):
-        raise error.Abort('cannot use head based merging, %d heads found'
+        raise error.Abort(b'cannot use head based merging, %d heads found'
                           % len(heads))
     head = heads.first()
     revs = stablesort_mergepoint_head(repo, head)
@@ -292,7 +292,7 @@
         ps = sorted(ps, key=tiebreaker)
 
         # get the part from the highest parent. This is the part that changes
-        mid_revs = repo.revs('only(%d, %d)', ps[1], ps[0])
+        mid_revs = repo.revs(b'only(%d, %d)', ps[1], ps[0])
         if mid_revs:
             mid = stablesort_mergepoint_bounded(repo, ps[1], mid_revs)
 
@@ -302,20 +302,20 @@
     return bottom + mid + top
 
 def stablesort_mergepoint_head_cached(repo, revs, limit=None):
-    heads = repo.revs('sort(heads(%ld))', revs)
+    heads = repo.revs(b'sort(heads(%ld))', revs)
     if not heads:
         return []
     elif 2 < len(heads):
-        raise error.Abort('cannot use head based merging, %d heads found'
+        raise error.Abort(b'cannot use head based merging, %d heads found'
                           % len(heads))
     head = heads.first()
     cache = stablesortcache()
     first = list(cache.get(repo, head, limit=limit))
     second = list(cache.get(repo, head, limit=limit))
     if first != second:
-        repo.ui.warn('stablesort-cache: initial run different from re-run:\n'
-                     '    %s\n'
-                     '    %s\n' % (first, second))
+        repo.ui.warn(b'stablesort-cache: initial run different from re-run:\n'
+                     b'    %s\n'
+                     b'    %s\n' % (first, second))
     return second
 
 class stablesortcache(object):
@@ -502,11 +502,11 @@
             recordjump(previous, lower, size)
 
 def stablesort_mergepoint_head_ondisk(repo, revs, limit=None):
-    heads = repo.revs('sort(heads(%ld))', revs)
+    heads = repo.revs(b'sort(heads(%ld))', revs)
     if not heads:
         return []
     elif 2 < len(heads):
-        raise error.Abort('cannot use head based merging, %d heads found'
+        raise error.Abort(b'cannot use head based merging, %d heads found'
                           % len(heads))
     head = heads.first()
     unfi = repo.unfiltered()
@@ -514,22 +514,22 @@
     cache.save(unfi)
     return cache.get(repo, head, limit=limit)
 
-S_INDEXSIZE = struct.Struct('>I')
+S_INDEXSIZE = struct.Struct(b'>I')
 
 class ondiskstablesortcache(stablesortcache, genericcaches.changelogsourcebase):
 
-    _filepath = 'evoext-stablesortcache-00'
-    _cachename = 'evo-ext-stablesort'
+    _filepath = b'evoext-stablesortcache-00'
+    _cachename = b'evo-ext-stablesort'
 
     def __init__(self):
         super(ondiskstablesortcache, self).__init__()
-        self._index = array.array('l')
-        self._data = array.array('l')
+        self._index = array.array(b'l')
+        self._data = array.array(b'l')
         del self._jumps
 
     def getjumps(self, repo, rev):
         if len(self._index) < rev:
-            msg = 'stablesortcache must be warmed before use (%d < %d)'
+            msg = b'stablesortcache must be warmed before use (%d < %d)'
             msg %= (len(self._index), rev)
             raise error.ProgrammingError(msg)
         return self._getjumps(rev)
@@ -577,10 +577,10 @@
         total = len(data)
 
         def progress(pos, rev):
-            compat.progress(repo.ui, 'updating stablesort cache',
-                            pos, 'rev %s' % rev, unit='revision', total=total)
+            compat.progress(repo.ui, b'updating stablesort cache',
+                            pos, b'rev %s' % rev, unit=b'revision', total=total)
 
-        progress(0, '')
+        progress(0, b'')
         for idx, rev in enumerate(data):
             parents = filterparents(repo.changelog.parentrevs(rev))
             if len(parents) <= 1:
@@ -594,12 +594,12 @@
                         break
             if not (idx % 1000): # progress as a too high performance impact
                 progress(idx, rev)
-        progress(None, '')
+        progress(None, b'')
 
     def clear(self, reset=False):
         super(ondiskstablesortcache, self).clear()
-        self._index = array.array('l')
-        self._data = array.array('l')
+        self._index = array.array(b'l')
+        self._data = array.array(b'l')
 
     def load(self, repo):
         """load data from disk
@@ -609,8 +609,8 @@
         assert repo.filtername is None
 
         data = repo.cachevfs.tryread(self._filepath)
-        self._index = array.array('l')
-        self._data = array.array('l')
+        self._index = array.array(b'l')
+        self._data = array.array(b'l')
         if not data:
             self._cachekey = self.emptykey
         else:
@@ -634,7 +634,7 @@
         if self._cachekey is None or self._cachekey == self._ondiskkey:
             return
         try:
-            cachefile = repo.cachevfs(self._filepath, 'w', atomictemp=True)
+            cachefile = repo.cachevfs(self._filepath, b'w', atomictemp=True)
 
             # data to write
             headerdata = self._serializecachekey()
@@ -650,8 +650,8 @@
             cachefile.close()
             self._ondiskkey = self._cachekey
         except (IOError, OSError) as exc:
-            repo.ui.log('stablesortcache', 'could not write update %s\n' % exc)
-            repo.ui.debug('stablesortcache: could not write update %s\n' % exc)
+            repo.ui.log(b'stablesortcache', b'could not write update %s\n' % exc)
+            repo.ui.debug(b'stablesortcache: could not write update %s\n' % exc)
 
 @eh.reposetup
 def setupcache(ui, repo):
@@ -666,7 +666,7 @@
 
         @localrepo.unfilteredmethod
         def destroyed(self):
-            if 'stablesort' in vars(self):
+            if b'stablesort' in vars(self):
                 self.stablesort.clear()
             super(stablesortrepo, self).destroyed()
 
@@ -680,12 +680,12 @@
     repo.__class__ = stablesortrepo
 
 _methodmap = {
-    'branchpoint': stablesort_branchpoint,
-    'basic-mergepoint': stablesort_mergepoint_multirevs,
-    'basic-headstart': stablesort_mergepoint_head_basic,
-    'headstart': stablesort_mergepoint_head_debug,
-    'headcached': stablesort_mergepoint_head_cached,
-    'headondisk': stablesort_mergepoint_head_ondisk,
+    b'branchpoint': stablesort_branchpoint,
+    b'basic-mergepoint': stablesort_mergepoint_multirevs,
+    b'basic-headstart': stablesort_mergepoint_head_basic,
+    b'headstart': stablesort_mergepoint_head_debug,
+    b'headcached': stablesort_mergepoint_head_cached,
+    b'headondisk': stablesort_mergepoint_head_ondisk,
 }
 
 # merge last so that repo setup wrap after that one.
diff --git a/hgext3rd/evolve/state.py b/hgext3rd/evolve/state.py
--- a/hgext3rd/evolve/state.py
+++ b/hgext3rd/evolve/state.py
@@ -37,7 +37,7 @@
     can populate the object data reading that file
     """
 
-    def __init__(self, repo, path='evolvestate', opts={}):
+    def __init__(self, repo, path=b'evolvestate', opts={}):
         self._repo = repo
         self.path = path
         self.opts = opts
@@ -63,7 +63,7 @@
         op = self._read()
         if isinstance(op, dict):
             self.opts.update(op)
-        elif self.path == 'evolvestate':
+        elif self.path == b'evolvestate':
             # it is the old evolvestate file
             oldop = _oldevolvestateread(self._repo)
             self.opts.update(oldop)
@@ -77,13 +77,13 @@
 
         we use third-party library cbor to serialize data to write in the file.
         """
-        with self._repo.vfs(self.path, 'wb', atomictemp=True) as fp:
+        with self._repo.vfs(self.path, b'wb', atomictemp=True) as fp:
             cbor.dump(self.opts, fp)
 
     def _read(self):
         """reads the evolvestate file and returns a dictionary which contain
         data in the same format as it was before storing"""
-        with self._repo.vfs(self.path, 'rb') as fp:
+        with self._repo.vfs(self.path, b'rb') as fp:
             return cbor.load(fp)
 
     def delete(self):
@@ -99,20 +99,20 @@
 
     This exists for BC reasons."""
     try:
-        f = repo.vfs('evolvestate')
+        f = repo.vfs(b'evolvestate')
     except IOError as err:
         if err.errno != errno.ENOENT:
             raise
     try:
         versionblob = f.read(4)
         if len(versionblob) < 4:
-            repo.ui.debug('ignoring corrupted evolvestate (file contains %i bits)'
+            repo.ui.debug(b'ignoring corrupted evolvestate (file contains %i bits)'
                           % len(versionblob))
             return None
-        version = struct._unpack('>I', versionblob)[0]
+        version = struct._unpack(b'>I', versionblob)[0]
         if version != 0:
-            msg = _('unknown evolvestate version %i') % version
-            raise error.Abort(msg, hint=_('upgrade your evolve'))
+            msg = _(b'unknown evolvestate version %i') % version
+            raise error.Abort(msg, hint=_(b'upgrade your evolve'))
         records = []
         data = f.read()
         off = 0
@@ -120,22 +120,22 @@
         while off < end:
             rtype = data[off]
             off += 1
-            length = struct._unpack('>I', data[off:(off + 4)])[0]
+            length = struct._unpack(b'>I', data[off:(off + 4)])[0]
             off += 4
             record = data[off:(off + length)]
             off += length
-            if rtype == 't':
+            if rtype == b't':
                 rtype, record = record[0], record[1:]
             records.append((rtype, record))
         state = {}
         for rtype, rdata in records:
-            if rtype == 'C':
-                state['current'] = rdata
+            if rtype == b'C':
+                state[b'current'] = rdata
             elif rtype.lower():
-                repo.ui.debug('ignore evolve state record type %s' % rtype)
+                repo.ui.debug(b'ignore evolve state record type %s' % rtype)
             else:
-                raise error.Abort(_('unknown evolvestate field type %r')
-                                  % rtype, hint=_('upgrade your evolve'))
+                raise error.Abort(_(b'unknown evolvestate field type %r')
+                                  % rtype, hint=_(b'upgrade your evolve'))
         return state
     finally:
         f.close()
diff --git a/hgext3rd/evolve/templatekw.py b/hgext3rd/evolve/templatekw.py
--- a/hgext3rd/evolve/templatekw.py
+++ b/hgext3rd/evolve/templatekw.py
@@ -23,46 +23,48 @@
 
 ### template keywords
 
-if util.safehasattr(templatekw, 'compatlist'):
-    @eh.templatekeyword('instabilities', requires=set(['ctx', 'templ']))
+if util.safehasattr(templatekw, b'compatlist'):
+    @eh.templatekeyword(b'instabilities', requires=set([b'ctx', b'templ']))
     def showinstabilities(context, mapping):
         """List of strings. Evolution instabilities affecting the changeset
         (zero or more of "orphan", "content-divergent" or "phase-divergent")."""
-        ctx = context.resource(mapping, 'ctx')
-        return templatekw.compatlist(context, mapping, 'instability',
+        ctx = context.resource(mapping, b'ctx')
+        return templatekw.compatlist(context, mapping, b'instability',
                                      ctx.instabilities(),
-                                     plural='instabilities')
+                                     plural=b'instabilities')
 
-    @eh.templatekeyword('troubles', requires=set(['ctx', 'templ']))
+    @eh.templatekeyword(b'troubles', requires=set([b'ctx', b'templ']))
     def showtroubles(context, mapping):   # legacy name for instabilities
-        ctx = context.resource(mapping, 'ctx')
-        return templatekw.compatlist(context, mapping, 'trouble',
-                                     ctx.instabilities(), plural='troubles')
+        ctx = context.resource(mapping, b'ctx')
+        return templatekw.compatlist(context, mapping, b'trouble',
+                                     ctx.instabilities(), plural=b'troubles')
 else:
     # older template API in hg < 4.6
-    @eh.templatekeyword('instabilities')
+    @eh.templatekeyword(b'instabilities')
     def showinstabilities(**args):
         """List of strings. Evolution instabilities affecting the changeset
         (zero or more of "orphan", "content-divergent" or "phase-divergent")."""
-        ctx = args['ctx']
-        return templatekw.showlist('instability', ctx.instabilities(), args,
-                                   plural='instabilities')
+        ctx = args[b'ctx']
+        return templatekw.showlist(b'instability', ctx.instabilities(), args,
+                                   plural=b'instabilities')
 
-    @eh.templatekeyword('troubles')
+    @eh.templatekeyword(b'troubles')
     def showtroubles(**args):
-        ctx = args['ctx']
-        return templatekw.showlist('trouble', ctx.instabilities(), args,
-                                   plural='troubles')
+        ctx = args[b'ctx']
+        return templatekw.showlist(b'trouble', ctx.instabilities(), args,
+                                   plural=b'troubles')
 
 _sp = templatekw.showpredecessors
-if util.safehasattr(_sp, '_requires'):
+if util.safehasattr(_sp, b'_requires'):
     def showprecursors(context, mapping):
         return _sp(context, mapping)
     showprecursors.__doc__ = _sp._origdoc
-    _tk = templatekw.templatekeyword("precursors", requires=_sp._requires)
+    if isinstance(showprecursors.__doc__, bytes):
+        showprecursors.__doc__ = _sp._origdoc.decode(u"utf-8")
+    _tk = templatekw.templatekeyword(b"precursors", requires=_sp._requires)
     _tk(showprecursors)
 else:
-    templatekw.keywords["precursors"] = _sp
+    templatekw.keywords[b"precursors"] = _sp
 
 
 def closestsuccessors(repo, nodeid):
@@ -71,14 +73,16 @@
     return directsuccessorssets(repo, nodeid)
 
 _ss = templatekw.showsuccessorssets
-if util.safehasattr(_ss, '_requires'):
+if util.safehasattr(_ss, b'_requires'):
     def showsuccessors(context, mapping):
         return _ss(context, mapping)
     showsuccessors.__doc__ = _ss._origdoc
-    _tk = templatekw.templatekeyword("successors", requires=_ss._requires)
+    if isinstance(showsuccessors.__doc__, bytes):
+        showsuccessors.__doc__ = _ss._origdoc.decode(u"utf-8")
+    _tk = templatekw.templatekeyword(b"successors", requires=_ss._requires)
     _tk(showsuccessors)
 else:
-    templatekw.keywords["successors"] = _ss
+    templatekw.keywords[b"successors"] = _ss
 
 def _getusername(ui):
     """the default username in the config or None"""
@@ -91,24 +95,24 @@
     """ Returns a dict with the default templates for obs fate
     """
     # Prepare templates
-    verbtempl = '{verb}'
-    usertempl = '{if(users, " by {join(users, ", ")}")}'
-    succtempl = '{if(successors, " as ")}{successors}' # Bypass if limitation
-    datetempleq = ' (at {min_date|isodate})'
-    datetemplnoteq = ' (between {min_date|isodate} and {max_date|isodate})'
-    datetempl = '{if(max_date, "{ifeq(min_date, max_date, "%s", "%s")}")}' % (datetempleq, datetemplnoteq)
+    verbtempl = b'{verb}'
+    usertempl = b'{if(users, " by {join(users, ", ")}")}'
+    succtempl = b'{if(successors, " as ")}{successors}' # Bypass if limitation
+    datetempleq = b' (at {min_date|isodate})'
+    datetemplnoteq = b' (between {min_date|isodate} and {max_date|isodate})'
+    datetempl = b'{if(max_date, "{ifeq(min_date, max_date, "%s", "%s")}")}' % (datetempleq, datetemplnoteq)
 
     optionalusertempl = usertempl
     username = _getusername(ui)
     if username is not None:
-        optionalusertempl = ('{ifeq(join(users, "\0"), "%s", "", "%s")}'
+        optionalusertempl = (b'{ifeq(join(users, "\0"), "%s", "", "%s")}'
                              % (username, usertempl))
 
     # Assemble them
     return {
-        'obsfate_quiet': verbtempl + succtempl,
-        'obsfate': verbtempl + succtempl + optionalusertempl,
-        'obsfate_verbose': verbtempl + succtempl + usertempl + datetempl,
+        b'obsfate_quiet': verbtempl + succtempl,
+        b'obsfate': verbtempl + succtempl + optionalusertempl,
+        b'obsfate_verbose': verbtempl + succtempl + usertempl + datetempl,
     }
 
 def obsfatedata(repo, ctx):
@@ -158,18 +162,18 @@
     line = []
 
     # Verb
-    line.append(obsfateline['verb'])
+    line.append(obsfateline[b'verb'])
 
     # Successors
-    successors = obsfateline["successors"]
+    successors = obsfateline[b"successors"]
 
     if successors:
         fmtsuccessors = map(lambda s: s[:12], successors)
-        line.append(" as %s" % ", ".join(fmtsuccessors))
+        line.append(b" as %s" % b", ".join(fmtsuccessors))
 
     # Users
-    if (verbose or normal) and 'users' in obsfateline:
-        users = obsfateline['users']
+    if (verbose or normal) and b'users' in obsfateline:
+        users = obsfateline[b'users']
 
         if not verbose:
             # If current user is the only user, do not show anything if not in
@@ -179,24 +183,24 @@
                 users = None
 
         if users:
-            line.append(" by %s" % ", ".join(users))
+            line.append(b" by %s" % b", ".join(users))
 
     # Date
     if verbose:
-        min_date = obsfateline['min_date']
-        max_date = obsfateline['max_date']
+        min_date = obsfateline[b'min_date']
+        max_date = obsfateline[b'max_date']
 
         if min_date == max_date:
-            fmtmin_date = util.datestr(min_date, '%Y-%m-%d %H:%M %1%2')
-            line.append(" (at %s)" % fmtmin_date)
+            fmtmin_date = util.datestr(min_date, b'%Y-%m-%d %H:%M %1%2')
+            line.append(b" (at %s)" % fmtmin_date)
         else:
-            fmtmin_date = util.datestr(min_date, '%Y-%m-%d %H:%M %1%2')
-            fmtmax_date = util.datestr(max_date, '%Y-%m-%d %H:%M %1%2')
-            line.append(" (between %s and %s)" % (fmtmin_date, fmtmax_date))
+            fmtmin_date = util.datestr(min_date, b'%Y-%m-%d %H:%M %1%2')
+            fmtmax_date = util.datestr(max_date, b'%Y-%m-%d %H:%M %1%2')
+            line.append(b" (between %s and %s)" % (fmtmin_date, fmtmax_date))
 
-    return "".join(line)
+    return b"".join(line)
 
-def obsfateprinter(obsfate, ui, prefix=""):
+def obsfateprinter(obsfate, ui, prefix=b""):
     lines = []
     for raw in obsfate:
         lines.append(obsfatelineprinter(raw, ui))
@@ -204,16 +208,16 @@
     if prefix:
         lines = [prefix + line for line in lines]
 
-    return "\n".join(lines)
+    return b"\n".join(lines)
 
-if not util.safehasattr(templatekw, 'obsfateverb'): # <= hg-4.5
-    @eh.templatekeyword("obsfatedata")
+if not util.safehasattr(templatekw, b'obsfateverb'): # <= hg-4.5
+    @eh.templatekeyword(b"obsfatedata")
     def showobsfatedata(repo, ctx, **args):
         # Get the needed obsfate data
         values = obsfatedata(repo, ctx)
 
         if values is None:
-            return templatekw.showlist("obsfatedata", [], args)
+            return templatekw.showlist(b"obsfatedata", [], args)
 
         return _showobsfatedata(repo, ctx, values, **args)
 
@@ -224,36 +228,36 @@
         # As we can't do something like
         # "{join(map(nodeshort, successors), ', '}" in template, manually
         # create a correct textual representation
-        gen = ', '.join(n[:12] for n in raw['successors'])
+        gen = b', '.join(n[:12] for n in raw[b'successors'])
 
-        makemap = lambda x: {'successor': x}
-        joinfmt = lambda d: "%s" % d['successor']
-        raw['successors'] = templatekw._hybrid(gen, raw['successors'], makemap,
-                                               joinfmt)
+        makemap = lambda x: {b'successor': x}
+        joinfmt = lambda d: b"%s" % d[b'successor']
+        raw[b'successors'] = templatekw._hybrid(gen, raw[b'successors'], makemap,
+                                                joinfmt)
 
     # And then format them
     # Insert default obsfate templates
-    args['templ'].cache.update(obsfatedefaulttempl(repo.ui))
+    args[b'templ'].cache.update(obsfatedefaulttempl(repo.ui))
 
     if repo.ui.quiet:
-        name = "obsfate_quiet"
+        name = b"obsfate_quiet"
     elif repo.ui.verbose:
-        name = "obsfate_verbose"
+        name = b"obsfate_verbose"
     elif repo.ui.debugflag:
-        name = "obsfate_debug"
+        name = b"obsfate_debug"
     else:
-        name = "obsfate"
+        name = b"obsfate"
 
     # Format a single value
     def fmt(d):
         nargs = args.copy()
         nargs.update(d[name])
-        templ = args['templ']
+        templ = args[b'templ']
         # HG 4.6
         if hasattr(templ, "generate"):
             return templ.generate(name, nargs)
         else:
-            return args['templ'](name, **nargs)
+            return args[b'templ'](name, **nargs)
 
     # Generate a good enough string representation using templater
     gen = []
@@ -268,8 +272,8 @@
         except StopIteration:
             pass
 
-        gen.append("".join(chunkstr))
-    gen = "; ".join(gen)
+        gen.append(b"".join(chunkstr))
+    gen = b"; ".join(gen)
 
     return templatekw._hybrid(gen, values, lambda x: {name: x}, fmt)
 
diff --git a/hgext3rd/evolve/thirdparty/cbor.py b/hgext3rd/evolve/thirdparty/cbor.py
--- a/hgext3rd/evolve/thirdparty/cbor.py
+++ b/hgext3rd/evolve/thirdparty/cbor.py
@@ -79,23 +79,23 @@
 CBOR_TAG_MIME = 36 # following text is MIME message, headers, separators and all
 CBOR_TAG_CBOR_FILEHEADER = 55799 # can open a file with 0xd9d9f7
 
-_CBOR_TAG_BIGNUM_BYTES = struct.pack('B', CBOR_TAG | CBOR_TAG_BIGNUM)
+_CBOR_TAG_BIGNUM_BYTES = struct.pack(b'B', CBOR_TAG | CBOR_TAG_BIGNUM)
 
 
 def dumps_int(val):
-    "return bytes representing int val in CBOR"
+    b"return bytes representing int val in CBOR"
     if val >= 0:
         # CBOR_UINT is 0, so I'm lazy/efficient about not OR-ing it in.
         if val <= 23:
-            return struct.pack('B', val)
+            return struct.pack(b'B', val)
         if val <= 0x0ff:
-            return struct.pack('BB', CBOR_UINT8_FOLLOWS, val)
+            return struct.pack(b'BB', CBOR_UINT8_FOLLOWS, val)
         if val <= 0x0ffff:
-            return struct.pack('!BH', CBOR_UINT16_FOLLOWS, val)
+            return struct.pack(b'!BH', CBOR_UINT16_FOLLOWS, val)
         if val <= 0x0ffffffff:
-            return struct.pack('!BI', CBOR_UINT32_FOLLOWS, val)
+            return struct.pack(b'!BI', CBOR_UINT32_FOLLOWS, val)
         if val <= 0x0ffffffffffffffff:
-            return struct.pack('!BQ', CBOR_UINT64_FOLLOWS, val)
+            return struct.pack(b'!BQ', CBOR_UINT64_FOLLOWS, val)
         outb = _dumps_bignum_to_bytearray(val)
         return _CBOR_TAG_BIGNUM_BYTES + _encode_type_num(CBOR_BYTES, len(outb)) + outb
     val = -1 - val
@@ -119,28 +119,28 @@
 
 
 def dumps_float(val):
-    return struct.pack("!Bd", CBOR_FLOAT64, val)
+    return struct.pack(b"!Bd", CBOR_FLOAT64, val)
 
 
-_CBOR_TAG_NEGBIGNUM_BYTES = struct.pack('B', CBOR_TAG | CBOR_TAG_NEGBIGNUM)
+_CBOR_TAG_NEGBIGNUM_BYTES = struct.pack(b'B', CBOR_TAG | CBOR_TAG_NEGBIGNUM)
 
 
 def _encode_type_num(cbor_type, val):
     """For some CBOR primary type [0..7] and an auxiliary unsigned number, return CBOR encoded bytes"""
     assert val >= 0
     if val <= 23:
-        return struct.pack('B', cbor_type | val)
+        return struct.pack(b'B', cbor_type | val)
     if val <= 0x0ff:
-        return struct.pack('BB', cbor_type | CBOR_UINT8_FOLLOWS, val)
+        return struct.pack(b'BB', cbor_type | CBOR_UINT8_FOLLOWS, val)
     if val <= 0x0ffff:
-        return struct.pack('!BH', cbor_type | CBOR_UINT16_FOLLOWS, val)
+        return struct.pack(b'!BH', cbor_type | CBOR_UINT16_FOLLOWS, val)
     if val <= 0x0ffffffff:
-        return struct.pack('!BI', cbor_type | CBOR_UINT32_FOLLOWS, val)
+        return struct.pack(b'!BI', cbor_type | CBOR_UINT32_FOLLOWS, val)
     if (((cbor_type == CBOR_NEGINT) and (val <= 0x07fffffffffffffff)) or
         ((cbor_type != CBOR_NEGINT) and (val <= 0x0ffffffffffffffff))):
-        return struct.pack('!BQ', cbor_type | CBOR_UINT64_FOLLOWS, val)
+        return struct.pack(b'!BQ', cbor_type | CBOR_UINT64_FOLLOWS, val)
     if cbor_type != CBOR_NEGINT:
-        raise Exception("value too big for CBOR unsigned number: {0!r}".format(val))
+        raise Exception(b"value too big for CBOR unsigned number: {0!r}".format(val))
     outb = _dumps_bignum_to_bytearray(val)
     return _CBOR_TAG_NEGBIGNUM_BYTES + _encode_type_num(CBOR_BYTES, len(outb)) + outb
 
@@ -193,7 +193,7 @@
                 parts.append(dumps(k, sort_keys=sort_keys))
                 parts.append(dumps(v, sort_keys=sort_keys))
         else:
-            for k,v in d.iteritems():
+            for k,v in d.items():
                 parts.append(dumps(k, sort_keys=sort_keys))
                 parts.append(dumps(v, sort_keys=sort_keys))
         return b''.join(parts)
@@ -201,8 +201,8 @@
 
 def dumps_bool(b):
     if b:
-        return struct.pack('B', CBOR_TRUE)
-    return struct.pack('B', CBOR_FALSE)
+        return struct.pack(b'B', CBOR_TRUE)
+    return struct.pack(b'B', CBOR_FALSE)
 
 
 def dumps_tag(t, sort_keys=False):
@@ -223,7 +223,7 @@
 
 def dumps(ob, sort_keys=False):
     if ob is None:
-        return struct.pack('B', CBOR_NULL)
+        return struct.pack(b'B', CBOR_NULL)
     if isinstance(ob, bool):
         return dumps_bool(ob)
     if _is_stringish(ob):
@@ -239,7 +239,7 @@
         return dumps_int(ob)
     if isinstance(ob, Tag):
         return dumps_tag(ob, sort_keys=sort_keys)
-    raise Exception("don't know how to cbor serialize object of type %s", type(ob))
+    raise Exception(b"don't know how to cbor serialize object of type %s", type(ob))
 
 
 # same basic signature as json.dump, but with no options (yet)
@@ -260,7 +260,7 @@
         self.value = value
 
     def __repr__(self):
-        return "Tag({0!r}, {1!r})".format(self.tag, self.value)
+        return b"Tag({0!r}, {1!r})".format(self.tag, self.value)
 
     def __eq__(self, other):
         if not isinstance(other, Tag):
@@ -273,7 +273,7 @@
     Parse CBOR bytes and return Python objects.
     """
     if data is None:
-        raise ValueError("got None for buffer to decode in loads")
+        raise ValueError(b"got None for buffer to decode in loads")
     fp = StringIO(data)
     return _loads(fp)[0]
 
@@ -296,22 +296,22 @@
         aux = tag_aux
     elif tag_aux == CBOR_UINT8_FOLLOWS:
         data = fp.read(1)
-        aux = struct.unpack_from("!B", data, 0)[0]
+        aux = struct.unpack_from(b"!B", data, 0)[0]
         bytes_read += 1
     elif tag_aux == CBOR_UINT16_FOLLOWS:
         data = fp.read(2)
-        aux = struct.unpack_from("!H", data, 0)[0]
+        aux = struct.unpack_from(b"!H", data, 0)[0]
         bytes_read += 2
     elif tag_aux == CBOR_UINT32_FOLLOWS:
         data = fp.read(4)
-        aux = struct.unpack_from("!I", data, 0)[0]
+        aux = struct.unpack_from(b"!I", data, 0)[0]
         bytes_read += 4
     elif tag_aux == CBOR_UINT64_FOLLOWS:
         data = fp.read(8)
-        aux = struct.unpack_from("!Q", data, 0)[0]
+        aux = struct.unpack_from(b"!Q", data, 0)[0]
         bytes_read += 8
     else:
-        assert tag_aux == CBOR_VAR_FOLLOWS, "bogus tag {0:02x}".format(tb)
+        assert tag_aux == CBOR_VAR_FOLLOWS, b"bogus tag {0:02x}".format(tb)
         aux = None
 
     return tag, tag_aux, aux, bytes_read
@@ -385,9 +385,9 @@
         return ob, bytes_read
 
 def _loads(fp, limit=None, depth=0, returntags=False):
-    "return (object, bytes read)"
+    b"return (object, bytes read)"
     if depth > _MAX_DEPTH:
-        raise Exception("hit CBOR loads recursion depth limit")
+        raise Exception(b"hit CBOR loads recursion depth limit")
 
     tb = _read_byte(fp)
 
@@ -397,16 +397,16 @@
     # Some special cases of CBOR_7 best handled by special struct.unpack logic here
     if tb == CBOR_FLOAT16:
         data = fp.read(2)
-        hibyte, lowbyte = struct.unpack_from("BB", data, 0)
+        hibyte, lowbyte = struct.unpack_from(b"BB", data, 0)
         exp = (hibyte >> 2) & 0x1F
         mant = ((hibyte & 0x03) << 8) | lowbyte
         if exp == 0:
             val = mant * (2.0 ** -24)
         elif exp == 31:
             if mant == 0:
-                val = float('Inf')
+                val = float(b'Inf')
             else:
-                val = float('NaN')
+                val = float(b'NaN')
         else:
             val = (mant + 1024.0) * (2 ** (exp - 25))
         if hibyte & 0x80:
@@ -414,11 +414,11 @@
         return (val, 3)
     elif tb == CBOR_FLOAT32:
         data = fp.read(4)
-        pf = struct.unpack_from("!f", data, 0)
+        pf = struct.unpack_from(b"!f", data, 0)
         return (pf[0], 5)
     elif tb == CBOR_FLOAT64:
         data = fp.read(8)
-        pf = struct.unpack_from("!d", data, 0)
+        pf = struct.unpack_from(b"!d", data, 0)
         return (pf[0], 9)
 
     tag, tag_aux, aux, bytes_read = _tag_aux(fp, tb)
@@ -461,7 +461,7 @@
             return (None, bytes_read)
         if tb == CBOR_UNDEFINED:
             return (None, bytes_read)
-        raise ValueError("unknown cbor tag 7 byte: {:02x}".format(tb))
+        raise ValueError(b"unknown cbor tag 7 byte: {:02x}".format(tb))
 
 
 def loads_bytes(fp, aux, btag=CBOR_BYTES):
@@ -481,7 +481,7 @@
             total_bytes_read += 1
             break
         tag, tag_aux, aux, bytes_read = _tag_aux(fp, tb)
-        assert tag == btag, 'variable length value contains unexpected component'
+        assert tag == btag, b'variable length value contains unexpected component'
         ob = fp.read(aux)
         chunklist.append(ob)
         total_bytes_read += bytes_read + aux
diff --git a/hgext3rd/evolve/utility.py b/hgext3rd/evolve/utility.py
--- a/hgext3rd/evolve/utility.py
+++ b/hgext3rd/evolve/utility.py
@@ -17,20 +17,20 @@
     compat,
 )
 
-shorttemplate = "[{label('evolve.rev', rev)}] {desc|firstline}\n"
+shorttemplate = b"[{label('evolve.rev', rev)}] {desc|firstline}\n"
 stacktemplate = """[{label('evolve.rev', if(topicidx, "s{topicidx}", rev))}] {desc|firstline}\n"""
 
 def obsexcmsg(ui, message, important=False):
-    verbose = ui.configbool('experimental', 'verbose-obsolescence-exchange')
+    verbose = ui.configbool(b'experimental', b'verbose-obsolescence-exchange')
     if verbose:
-        message = 'OBSEXC: ' + message
+        message = b'OBSEXC: ' + message
     if important or verbose:
         ui.status(message)
 
 def obsexcprg(ui, *args, **kwargs):
-    topic = 'obsmarkers exchange'
-    if ui.configbool('experimental', 'verbose-obsolescence-exchange'):
-        topic = 'OBSEXC'
+    topic = b'obsmarkers exchange'
+    if ui.configbool(b'experimental', b'verbose-obsolescence-exchange'):
+        topic = b'OBSEXC'
     compat.progress(ui, topic, *args, **kwargs)
 
 def filterparents(parents):
@@ -50,28 +50,28 @@
 def shouldwarmcache(repo, tr):
     configbool = repo.ui.configbool
     config = repo.ui.config
-    desc = getattr(tr, 'desc', '')
+    desc = getattr(tr, 'desc', b'')
 
     autocase = False
     if tr is None and not getattr(repo, '_destroying', False):
         autocase = True
-    elif desc.startswith('serve'):
+    elif desc.startswith(b'serve'):
         autocase = True
-    elif desc.startswith('push') and not desc.startswith('push-response'):
+    elif desc.startswith(b'push') and not desc.startswith(b'push-response'):
         autocase = True
 
-    autocache = config('experimental', 'obshashrange.warm-cache',
-                       'auto') == 'auto'
+    autocache = config(b'experimental', b'obshashrange.warm-cache',
+                       b'auto') == b'auto'
     if autocache:
         warm = autocase
     else:
         # note: we should not get to the default case
-        warm = configbool('experimental', 'obshashrange.warm-cache')
-    if not configbool('experimental', 'obshashrange'):
+        warm = configbool(b'experimental', b'obshashrange.warm-cache')
+    if not configbool(b'experimental', b'obshashrange'):
         return False
     if not warm:
         return False
-    maxrevs = repo.ui.configint('experimental', 'obshashrange.max-revs')
+    maxrevs = repo.ui.configint(b'experimental', b'obshashrange.max-revs')
     if maxrevs is not None and maxrevs < len(repo.unfiltered()):
         return False
     return True
@@ -123,8 +123,8 @@
     newer = obsutil.successorssets(repo, obs.node())
     # search of a parent which is not killed
     while not newer:
-        ui.debug("stabilize target %s is plain dead,"
-                 " trying to stabilize on its parent\n" %
+        ui.debug(b"stabilize target %s is plain dead,"
+                 b" trying to stabilize on its parent\n" %
                  obs)
         obs = obs.parents()[0]
         newer = obsutil.successorssets(repo, obs.node())
@@ -141,7 +141,7 @@
                 for successorsset in exc.successorssets
                 for node in successorsset}
 
-def revselectionprompt(ui, repo, revs, customheader=""):
+def revselectionprompt(ui, repo, revs, customheader=b""):
     """function to prompt user to choose a revision from all the revs and return
     that revision for further tasks
 
@@ -161,29 +161,29 @@
     if not ui.interactive():
         return None
 
-    promptmsg = customheader + "\n"
+    promptmsg = customheader + b"\n"
     for idx, rev in enumerate(revs):
         curctx = repo[rev]
-        revmsg = "%d: [%s] %s\n" % (idx + 1, curctx,
-                                    curctx.description().split("\n")[0])
+        revmsg = b"%d: [%s] %s\n" % (idx + 1, curctx,
+                                     curctx.description().split(b"\n")[0])
         promptmsg += revmsg
 
-    promptmsg += _("q: quit the prompt\n")
-    promptmsg += _("enter the index of the revision you want to select:")
+    promptmsg += _(b"q: quit the prompt\n")
+    promptmsg += _(b"enter the index of the revision you want to select:")
     idxselected = ui.prompt(promptmsg)
 
     intidx = None
     try:
         intidx = int(idxselected)
     except ValueError:
-        if idxselected == 'q':
+        if idxselected == b'q':
             return None
-        ui.write_err(_("invalid value '%s' entered for index\n") % idxselected)
+        ui.write_err(_(b"invalid value '%s' entered for index\n") % idxselected)
         return None
 
     if intidx > len(revs) or intidx <= 0:
         # we can make this error message better
-        ui.write_err(_("invalid value '%d' entered for index\n") % intidx)
+        ui.write_err(_(b"invalid value '%d' entered for index\n") % intidx)
         return None
 
     return revs[intidx - 1]
@@ -206,7 +206,7 @@
             # all three are different, lets concatenate the two authors
             # XXX: should we let the user know about concatenation of authors
             #      by printing some message (or maybe in verbose mode)
-            users = set(divuser.split(', '))
-            users.update(othuser.split(', '))
-            user = ', '.join(sorted(users))
+            users = set(divuser.split(b', '))
+            users.update(othuser.split(b', '))
+            user = b', '.join(sorted(users))
             return user
diff --git a/hgext3rd/pullbundle.py b/hgext3rd/pullbundle.py
--- a/hgext3rd/pullbundle.py
+++ b/hgext3rd/pullbundle.py
@@ -92,10 +92,10 @@
 
 from mercurial.i18n import _
 
-__version__ = '0.1.1'
-testedwith = '4.4 4.5 4.6 4.7.1'
-minimumhgversion = '4.4'
-buglink = 'https://bz.mercurial-scm.org/'
+__version__ = b'0.1.1'
+testedwith = b'4.4 4.5 4.6 4.7.1'
+minimumhgversion = b'4.4'
+buglink = b'https://bz.mercurial-scm.org/'
 
 cmdtable = {}
 command = registrar.command(cmdtable)
@@ -103,14 +103,14 @@
 configtable = {}
 configitem = registrar.configitem(configtable)
 
-configitem('pullbundle', 'cache-directory',
+configitem(b'pullbundle', b'cache-directory',
            default=None,
 )
 
 # generic wrapping
 
 def uisetup(ui):
-    exchange.getbundle2partsmapping['changegroup'] = _getbundlechangegrouppart
+    exchange.getbundle2partsmapping[b'changegroup'] = _getbundlechangegrouppart
 
 def _getbundlechangegrouppart(bundler, repo, source, bundlecaps=None,
                               b2caps=None, heads=None, common=None, **kwargs):
@@ -118,13 +118,13 @@
     if not kwargs.get(r'cg', True):
         return
 
-    version = '01'
-    cgversions = b2caps.get('changegroup')
+    version = b'01'
+    cgversions = b2caps.get(b'changegroup')
     if cgversions:  # 3.1 and 3.2 ship with an empty value
         cgversions = [v for v in cgversions
                       if v in changegroup.supportedoutgoingversions(repo)]
         if not cgversions:
-            raise ValueError(_('no common changegroup version'))
+            raise ValueError(_(b'no common changegroup version'))
         version = max(cgversions)
 
     outgoing = exchange._computeoutgoing(repo, heads, common)
@@ -145,20 +145,20 @@
     # END OF ALTERED PART
 
     if kwargs.get(r'narrow', False) and (include or exclude):
-        narrowspecpart = bundler.newpart('narrow:spec')
+        narrowspecpart = bundler.newpart(b'narrow:spec')
         if include:
             narrowspecpart.addparam(
-                'include', '\n'.join(include), mandatory=True)
+                b'include', b'\n'.join(include), mandatory=True)
         if exclude:
             narrowspecpart.addparam(
-                'exclude', '\n'.join(exclude), mandatory=True)
+                b'exclude', b'\n'.join(exclude), mandatory=True)
 
 def makeallcgpart(newpart, repo, outgoing, version, source,
                   bundlecaps, filematcher, cgversions):
 
     pullbundle = not filematcher
-    if pullbundle and not util.safehasattr(repo, 'stablerange'):
-        repo.ui.warn('pullbundle: required extension "evolve" are missing, skipping pullbundle\n')
+    if pullbundle and not util.safehasattr(repo, b'stablerange'):
+        repo.ui.warn(b'pullbundle: required extension "evolve" are missing, skipping pullbundle\n')
         pullbundle = False
     if filematcher:
         makeonecgpart(newpart, repo, None, outgoing, version, source, bundlecaps,
@@ -167,8 +167,8 @@
         start = util.timer()
         slices = sliceoutgoing(repo, outgoing)
         end = util.timer()
-        msg = _('pullbundle-cache: "missing" set sliced into %d subranges '
-                'in %s seconds\n')
+        msg = _(b'pullbundle-cache: "missing" set sliced into %d subranges '
+                b'in %s seconds\n')
         repo.ui.write(msg % (len(slices), end - start))
         for sliceid, sliceout in slices:
             makeonecgpart(newpart, repo, sliceid, sliceout, version, source, bundlecaps,
@@ -192,7 +192,7 @@
     missingheads = [rev(n) for n in sorted(outgoing.missingheads, reverse=True)]
     for head in missingheads:
         localslices = []
-        localmissing = set(repo.revs('%ld and ::%d', missingrevs, head))
+        localmissing = set(repo.revs(b'%ld and ::%d', missingrevs, head))
         thisrunmissing = localmissing.copy()
         while localmissing:
             slicerevs = []
@@ -207,11 +207,11 @@
             missingrevs.difference_update(slicerevs)
             localmissing.difference_update(slicerevs)
             if localmissing:
-                heads = list(repo.revs('heads(%ld)', localmissing))
+                heads = list(repo.revs(b'heads(%ld)', localmissing))
                 heads.sort(key=node)
                 head = heads.pop()
                 if heads:
-                    thisrunmissing = repo.revs('%ld and only(%d, %ld)',
+                    thisrunmissing = repo.revs(b'%ld and only(%d, %ld)',
                                                localmissing,
                                                head,
                                                heads)
@@ -220,15 +220,15 @@
         if DEBUG:
             for s in reversed(ss):
                 ms -= set(s)
-                missingbase = repo.revs('parents(%ld) and %ld', s, ms)
+                missingbase = repo.revs(b'parents(%ld) and %ld', s, ms)
                 if missingbase:
-                    repo.ui.write_err('!!! rev bundled while parents missing\n')
-                    repo.ui.write_err('    parent: %s\n' % list(missingbase))
-                    pb = repo.revs('%ld and children(%ld)', s, missingbase)
-                    repo.ui.write_err('    children: %s\n' % list(pb))
-                    h = repo.revs('heads(%ld)', s)
-                    repo.ui.write_err('    heads: %s\n' % list(h))
-                    raise error.ProgrammingError('issuing a range before its parents')
+                    repo.ui.write_err(b'!!! rev bundled while parents missing\n')
+                    repo.ui.write_err(b'    parent: %s\n' % list(missingbase))
+                    pb = repo.revs(b'%ld and children(%ld)', s, missingbase)
+                    repo.ui.write_err(b'    children: %s\n' % list(pb))
+                    h = repo.revs(b'heads(%ld)', s)
+                    repo.ui.write_err(b'    heads: %s\n' % list(h))
+                    raise error.ProgrammingError(b'issuing a range before its parents')
 
         for s in reversed(localslices):
             allslices.extend(s)
@@ -381,8 +381,8 @@
 # changegroup part construction
 
 def _changegroupinfo(repo, nodes, source):
-    if repo.ui.verbose or source == 'bundle':
-        repo.ui.status(_("%d changesets found\n") % len(nodes))
+    if repo.ui.verbose or source == b'bundle':
+        repo.ui.status(_(b"%d changesets found\n") % len(nodes))
 
 def _makenewstream(newpart, repo, outgoing, version, source,
                    bundlecaps, filematcher, cgversions):
@@ -408,23 +408,23 @@
 def _makepartfromstream(newpart, repo, cgstream, nbchanges, version):
     # same as upstream code
 
-    part = newpart('changegroup', data=cgstream)
+    part = newpart(b'changegroup', data=cgstream)
     if version:
-        part.addparam('version', version)
+        part.addparam(b'version', version)
 
-    part.addparam('nbchanges', '%d' % nbchanges,
+    part.addparam(b'nbchanges', b'%d' % nbchanges,
                   mandatory=False)
 
-    if 'treemanifest' in repo.requirements:
-        part.addparam('treemanifest', '1')
+    if b'treemanifest' in repo.requirements:
+        part.addparam(b'treemanifest', b'1')
 
 # cache management
 
 def cachedir(repo):
-    cachedir = repo.ui.config('pullbundle', 'cache-directory')
+    cachedir = repo.ui.config(b'pullbundle', b'cache-directory')
     if cachedir is not None:
         return cachedir
-    return repo.cachevfs.join('pullbundles')
+    return repo.cachevfs.join(b'pullbundles')
 
 def getcache(repo, bundlename):
     cdir = cachedir(repo)
@@ -436,7 +436,7 @@
     # opening too many file will not work.
 
     def data():
-        with open(bundlepath, 'rb') as fd:
+        with open(bundlepath, b'rb') as fd:
             for chunk in util.filechunkiter(fd):
                 yield chunk
     return data()
@@ -454,7 +454,7 @@
             cachefile.write(chunk)
             yield chunk
 
-BUNDLEMASK = "%s-%s-%010iskip-%010isize.hg"
+BUNDLEMASK = b"%s-%s-%010iskip-%010isize.hg"
 
 def makeonecgpart(newpart, repo, rangeid, outgoing, version, source,
                   bundlecaps, filematcher, cgversions):
@@ -472,19 +472,19 @@
             cgstream = cachewriter(repo, bundlename, partdata[0])
             partdata = (cgstream,) + partdata[1:]
     else:
-        if repo.ui.verbose or source == 'bundle':
-            repo.ui.status(_("%d changesets found in caches\n") % nbchanges)
+        if repo.ui.verbose or source == b'bundle':
+            repo.ui.status(_(b"%d changesets found in caches\n") % nbchanges)
         pversion = None
         if cgversions:
             pversion = version
         partdata = (cachedata, nbchanges, pversion)
     return _makepartfromstream(newpart, repo, *partdata)
 
- at command('debugpullbundlecacheoverlap',
-         [('', 'count', 100, _('of "client" pulling')),
-          ('', 'min-cache', 1, _('minimum size of cached bundle')),
-         ],
-         _('hg debugpullbundlecacheoverlap [--client 100] REVSET'))
+ at command(b'debugpullbundlecacheoverlap',
+         [(b'', b'count', 100, _(b'of "client" pulling')),
+          (b'', b'min-cache', 1, _(b'minimum size of cached bundle')),
+          ],
+         _(b'hg debugpullbundlecacheoverlap [--client 100] REVSET'))
 def debugpullbundlecacheoverlap(ui, repo, *revs, **opts):
     '''Display statistic on bundle cache hit
 
@@ -494,21 +494,21 @@
     '''
     actionrevs = scmutil.revrange(repo, revs)
     if not revs:
-        raise error.Abort('No revision selected')
-    count = opts['count']
-    min_cache = opts['min_cache']
+        raise error.Abort(b'No revision selected')
+    count = opts[b'count']
+    min_cache = opts[b'min_cache']
 
     bundlehits = collections.defaultdict(lambda: 0)
     pullstats = []
 
     rlen = lambda rangeid: repo.stablerange.rangelength(repo, rangeid)
 
-    repo.ui.write("gathering %d sample pulls within %d revisions\n"
+    repo.ui.write(b"gathering %d sample pulls within %d revisions\n"
                   % (count, len(actionrevs)))
     if 1 < min_cache:
-        repo.ui.write("  not caching ranges smaller than %d changesets\n" % min_cache)
+        repo.ui.write(b"  not caching ranges smaller than %d changesets\n" % min_cache)
     for i in xrange(count):
-        repo.ui.progress('gathering data', i, total=count)
+        repo.ui.progress(b'gathering data', i, total=count)
         outgoing = takeonesample(repo, actionrevs)
         ranges = sliceoutgoing(repo, outgoing)
         hitranges = 0
@@ -532,7 +532,7 @@
                  hitranges,
                  )
         pullstats.append(stats)
-    repo.ui.progress('gathering data', None)
+    repo.ui.progress(b'gathering data', None)
 
     sizes = []
     changesmissing = []
@@ -563,36 +563,36 @@
         cachedhits.append(hits)
 
     sizesdist = distribution(sizes)
-    repo.ui.write(fmtdist('pull size', sizesdist))
+    repo.ui.write(fmtdist(b'pull size', sizesdist))
 
     changesmissingdist = distribution(changesmissing)
-    repo.ui.write(fmtdist('non-cached changesets', changesmissingdist))
+    repo.ui.write(fmtdist(b'non-cached changesets', changesmissingdist))
 
     changesratiodist = distribution(changesratio)
-    repo.ui.write(fmtdist('ratio of cached changesets', changesratiodist))
+    repo.ui.write(fmtdist(b'ratio of cached changesets', changesratiodist))
 
     bundlecountdist = distribution(bundlecount)
-    repo.ui.write(fmtdist('bundle count', bundlecountdist))
+    repo.ui.write(fmtdist(b'bundle count', bundlecountdist))
 
     rangesratiodist = distribution(rangesratio)
-    repo.ui.write(fmtdist('ratio of cached bundles', rangesratiodist))
+    repo.ui.write(fmtdist(b'ratio of cached bundles', rangesratiodist))
 
-    repo.ui.write('changesets served:\n')
-    repo.ui.write('  total:      %7d\n' % totalchanges)
-    repo.ui.write('  from cache: %7d (%2d%%)\n'
+    repo.ui.write(b'changesets served:\n')
+    repo.ui.write(b'  total:      %7d\n' % totalchanges)
+    repo.ui.write(b'  from cache: %7d (%2d%%)\n'
                   % (totalcached, (totalcached * 100 // totalchanges)))
-    repo.ui.write('  bundle:     %7d\n' % sum(bundlecount))
+    repo.ui.write(b'  bundle:     %7d\n' % sum(bundlecount))
 
     cachedsizesdist = distribution(cachedsizes)
-    repo.ui.write(fmtdist('size of cached bundles', cachedsizesdist))
+    repo.ui.write(fmtdist(b'size of cached bundles', cachedsizesdist))
 
     cachedhitsdist = distribution(cachedhits)
-    repo.ui.write(fmtdist('hit on cached bundles', cachedhitsdist))
+    repo.ui.write(fmtdist(b'hit on cached bundles', cachedhitsdist))
 
 def takeonesample(repo, revs):
     node = repo.changelog.node
     pulled = random.sample(revs, max(4, len(revs) // 1000))
-    pulled = repo.revs('%ld::%ld', pulled, pulled)
+    pulled = repo.revs(b'%ld::%ld', pulled, pulled)
     nodes = [node(r) for r in pulled]
     return outgoingfromnodes(repo, nodes)
 
@@ -600,14 +600,14 @@
     data.sort()
     length = len(data)
     return {
-        'min': data[0],
-        '10%': data[length // 10],
-        '25%': data[length // 4],
-        '50%': data[length // 2],
-        '75%': data[(length // 4) * 3],
-        '90%': data[(length // 10) * 9],
-        '95%': data[(length // 20) * 19],
-        'max': data[-1],
+        b'min': data[0],
+        b'10%': data[length // 10],
+        b'25%': data[length // 4],
+        b'50%': data[length // 2],
+        b'75%': data[(length // 4) * 3],
+        b'90%': data[(length // 10) * 9],
+        b'95%': data[(length // 20) * 19],
+        b'max': data[-1],
     }
 
 STATSFORMAT = """{name}:
diff --git a/hgext3rd/serverminitopic.py b/hgext3rd/serverminitopic.py
--- a/hgext3rd/serverminitopic.py
+++ b/hgext3rd/serverminitopic.py
@@ -29,11 +29,11 @@
 except ImportError: # <= hg-4.5
     from mercurial import wireprotov1server as wireproto
 
-if util.safehasattr(registrar, 'configitem'):
+if util.safehasattr(registrar, b'configitem'):
 
     configtable = {}
     configitem = registrar.configitem(configtable)
-    configitem('experimental', 'server-mini-topic',
+    configitem(b'experimental', b'server-mini-topic',
                default=False,
     )
 
@@ -44,7 +44,7 @@
     """
     enabled = getattr(repo, '_hasminitopic', None)
     if enabled is None:
-        enabled = (repo.ui.configbool('experimental', 'server-mini-topic')
+        enabled = (repo.ui.configbool(b'experimental', b'server-mini-topic')
                    and not repo.publishing())
         repo._hasminitopic = enabled
     return enabled
@@ -54,10 +54,10 @@
 def topicbranch(orig, self):
     branch = orig(self)
     if hasminitopic(self._repo) and self.phase():
-        topic = self._changeset.extra.get('topic')
+        topic = self._changeset.extra.get(b'topic')
         if topic is not None:
             topic = encoding.tolocal(topic)
-            branch = '%s:%s' % (branch, topic)
+            branch = b'%s:%s' % (branch, topic)
     return branch
 
 ### avoid caching topic data in rev-branch-cache
@@ -67,7 +67,7 @@
 
     def _init__(self, *args, **kwargs):
         super(revbranchcacheoverlay, self).__init__(*args, **kwargs)
-        if 'branchinfo' in vars(self):
+        if b'branchinfo' in vars(self):
             del self.branchinfo
 
     def branchinfo(self, rev, changelog=None):
@@ -95,7 +95,7 @@
                     class topicawarerbc(revbranchcacheoverlay, cache.__class__):
                         pass
                     cache.__class__ = topicawarerbc
-                    if 'branchinfo' in vars(cache):
+                    if b'branchinfo' in vars(cache):
                         del cache.branchinfo
                     self._revbranchcache = cache
                 return self._revbranchcache
@@ -120,7 +120,7 @@
     if revs:
         s = hashlib.sha1()
         for rev in revs:
-            s.update('%s;' % rev)
+            s.update(b'%s;' % rev)
         key = s.digest()
     return key
 
@@ -138,8 +138,8 @@
         branchmap.branchcache = previous
 
 _publiconly = set([
-    'base',
-    'immutable',
+    b'base',
+    b'immutable',
 ])
 
 def mighttopic(repo):
@@ -159,7 +159,7 @@
 
     def copy(self):
         """return an deep copy of the branchcache object"""
-        if util.safehasattr(self, '_entries'):
+        if util.safehasattr(self, b'_entries'):
             _entries = self._entries
         else:
             # hg <= 4.9 (624d6683c705, b137a6793c51)
@@ -216,7 +216,7 @@
 def wireprotocaps(orig, repo, proto):
     caps = orig(repo, proto)
     if hasminitopic(repo):
-        caps.append('topics')
+        caps.append(b'topics')
     return caps
 
 # wrap the necessary bit
@@ -234,13 +234,13 @@
     assert issubclass(current, new), (current, new, targetclass)
 
 def uisetup(ui):
-    wrapclass(branchmap, 'branchcache', _topiccache)
+    wrapclass(branchmap, b'branchcache', _topiccache)
     try:
         # Mercurial 4.8 and older
-        extensions.wrapfunction(branchmap, 'read', wrapread)
+        extensions.wrapfunction(branchmap, b'read', wrapread)
     except AttributeError:
         # Mercurial 4.9; branchcache.fromfile now takes care of this
         # which is alredy defined on _topiccache
         pass
-    extensions.wrapfunction(wireproto, '_capabilities', wireprotocaps)
-    extensions.wrapfunction(context.changectx, 'branch', topicbranch)
+    extensions.wrapfunction(wireproto, b'_capabilities', wireprotocaps)
+    extensions.wrapfunction(context.changectx, b'branch', topicbranch)
diff --git a/hgext3rd/topic/__init__.py b/hgext3rd/topic/__init__.py
--- a/hgext3rd/topic/__init__.py
+++ b/hgext3rd/topic/__init__.py
@@ -159,65 +159,65 @@
 
 cmdtable = {}
 command = registrar.command(cmdtable)
-colortable = {'topic.active': 'green',
-              'topic.list.unstablecount': 'red',
-              'topic.list.headcount.multiple': 'yellow',
-              'topic.list.behindcount': 'cyan',
-              'topic.list.behinderror': 'red',
-              'stack.index': 'yellow',
-              'stack.index.base': 'none dim',
-              'stack.desc.base': 'none dim',
-              'stack.shortnode.base': 'none dim',
-              'stack.state.base': 'dim',
-              'stack.state.clean': 'green',
-              'stack.index.current': 'cyan',       # random pick
-              'stack.state.current': 'cyan bold',  # random pick
-              'stack.desc.current': 'cyan',        # random pick
-              'stack.shortnode.current': 'cyan',   # random pick
-              'stack.state.orphan': 'red',
-              'stack.state.content-divergent': 'red',
-              'stack.state.phase-divergent': 'red',
-              'stack.summary.behindcount': 'cyan',
-              'stack.summary.behinderror': 'red',
-              'stack.summary.headcount.multiple': 'yellow',
+colortable = {b'topic.active': b'green',
+              b'topic.list.unstablecount': b'red',
+              b'topic.list.headcount.multiple': b'yellow',
+              b'topic.list.behindcount': b'cyan',
+              b'topic.list.behinderror': b'red',
+              b'stack.index': b'yellow',
+              b'stack.index.base': b'none dim',
+              b'stack.desc.base': b'none dim',
+              b'stack.shortnode.base': b'none dim',
+              b'stack.state.base': b'dim',
+              b'stack.state.clean': b'green',
+              b'stack.index.current': b'cyan',       # random pick
+              b'stack.state.current': b'cyan bold',  # random pick
+              b'stack.desc.current': b'cyan',        # random pick
+              b'stack.shortnode.current': b'cyan',   # random pick
+              b'stack.state.orphan': b'red',
+              b'stack.state.content-divergent': b'red',
+              b'stack.state.phase-divergent': b'red',
+              b'stack.summary.behindcount': b'cyan',
+              b'stack.summary.behinderror': b'red',
+              b'stack.summary.headcount.multiple': b'yellow',
               # default color to help log output and thg
               # (first pick I could think off, update as needed
-              'log.topic': 'green_background',
-              'topic.active': 'green',
-             }
+              b'log.topic': b'green_background',
+              b'topic.active': b'green',
+              }
 
-__version__ = '0.15.0'
+__version__ = b'0.15.0'
 
-testedwith = '4.5.2 4.6.2 4.7 4.8 4.9 5.0'
-minimumhgversion = '4.5'
-buglink = 'https://bz.mercurial-scm.org/'
+testedwith = b'4.5.2 4.6.2 4.7 4.8 4.9 5.0'
+minimumhgversion = b'4.5'
+buglink = b'https://bz.mercurial-scm.org/'
 
-if util.safehasattr(registrar, 'configitem'):
+if util.safehasattr(registrar, b'configitem'):
 
     from mercurial import configitems
 
     configtable = {}
     configitem = registrar.configitem(configtable)
 
-    configitem('experimental', 'enforce-topic',
+    configitem(b'experimental', b'enforce-topic',
                default=False,
     )
-    configitem('experimental', 'enforce-single-head',
+    configitem(b'experimental', b'enforce-single-head',
                default=False,
     )
-    configitem('experimental', 'topic-mode',
+    configitem(b'experimental', b'topic-mode',
                default=None,
     )
-    configitem('experimental', 'topic.publish-bare-branch',
+    configitem(b'experimental', b'topic.publish-bare-branch',
                default=False,
     )
-    configitem('experimental', 'topic.allow-publish',
+    configitem(b'experimental', b'topic.allow-publish',
                default=configitems.dynamicdefault,
     )
-    configitem('_internal', 'keep-topic',
+    configitem(b'_internal', b'keep-topic',
                default=False,
     )
-    configitem('experimental', 'topic-mode.server',
+    configitem(b'experimental', b'topic-mode.server',
                default=configitems.dynamicdefault,
     )
 
@@ -228,25 +228,25 @@
         # nobody else did so far.
         from mercurial import configitems
         extraitem = functools.partial(configitems._register, ui._knownconfig)
-        if ('experimental' not in ui._knownconfig
-                or not ui._knownconfig['experimental'].get('thg.displaynames')):
-            extraitem('experimental', 'thg.displaynames',
+        if (b'experimental' not in ui._knownconfig
+                or not ui._knownconfig[b'experimental'].get(b'thg.displaynames')):
+            extraitem(b'experimental', b'thg.displaynames',
                       default=None,
             )
-        if ('devel' not in ui._knownconfig
-                or not ui._knownconfig['devel'].get('random')):
-            extraitem('devel', 'randomseed',
+        if (b'devel' not in ui._knownconfig
+                or not ui._knownconfig[b'devel'].get(b'random')):
+            extraitem(b'devel', b'randomseed',
                       default=None,
             )
 
 # we need to do old style declaration for <= 4.5
 templatekeyword = registrar.templatekeyword()
-post45template = 'requires=' in templatekeyword.__doc__
+post45template = b'requires=' in templatekeyword.__doc__
 
 def _contexttopic(self, force=False):
     if not (force or self.mutable()):
-        return ''
-    return self.extra().get(constants.extrakey, '')
+        return b''
+    return self.extra().get(constants.extrakey, b'')
 context.basectx.topic = _contexttopic
 
 def _contexttopicidx(self):
@@ -274,38 +274,38 @@
         idx = int(name[1:])
         tname = topic = repo.currenttopic
         if topic:
-            ttype = 'topic'
+            ttype = b'topic'
             revs = list(stack.stack(repo, topic=topic))
         else:
-            ttype = 'branch'
+            ttype = b'branch'
             tname = branch = repo[None].branch()
             revs = list(stack.stack(repo, branch=branch))
     elif topicrev.match(name):
         idx = int(name[1:])
-        ttype = 'topic'
+        ttype = b'topic'
         tname = topic = repo.currenttopic
         if not tname:
-            raise error.Abort(_('cannot resolve "%s": no active topic') % name)
+            raise error.Abort(_(b'cannot resolve "%s": no active topic') % name)
         revs = list(stack.stack(repo, topic=topic))
 
     if revs is not None:
         try:
             r = revs[idx]
         except IndexError:
-            if ttype == 'topic':
-                msg = _('cannot resolve "%s": %s "%s" has only %d changesets')
-            elif ttype == 'branch':
-                msg = _('cannot resolve "%s": %s "%s" has only %d non-public changesets')
+            if ttype == b'topic':
+                msg = _(b'cannot resolve "%s": %s "%s" has only %d changesets')
+            elif ttype == b'branch':
+                msg = _(b'cannot resolve "%s": %s "%s" has only %d non-public changesets')
             raise error.Abort(msg % (name, ttype, tname, len(revs) - 1))
         # t0 or s0 can be None
         if r == -1 and idx == 0:
-            msg = _('the %s "%s" has no %s')
+            msg = _(b'the %s "%s" has no %s')
             raise error.Abort(msg % (ttype, tname, name))
         return [repo[r].node()]
     if name not in repo.topics:
         return []
     node = repo.changelog.node
-    return [node(rev) for rev in repo.revs('topic(%s)', name)]
+    return [node(rev) for rev in repo.revs(b'topic(%s)', name)]
 
 def _nodemap(repo, node):
     ctx = repo[node]
@@ -320,47 +320,47 @@
     topicmap.modsetup(ui)
     setupimportexport(ui)
 
-    extensions.afterloaded('rebase', _fixrebase)
+    extensions.afterloaded(b'rebase', _fixrebase)
 
     flow.installpushflag(ui)
 
-    entry = extensions.wrapcommand(commands.table, 'commit', commitwrap)
-    entry[1].append(('t', 'topic', '',
-                     _("use specified topic"), _('TOPIC')))
+    entry = extensions.wrapcommand(commands.table, b'commit', commitwrap)
+    entry[1].append((b't', b'topic', b'',
+                     _(b"use specified topic"), _(b'TOPIC')))
 
-    entry = extensions.wrapcommand(commands.table, 'push', pushoutgoingwrap)
-    entry[1].append(('t', 'topic', '',
-                     _("topic to push"), _('TOPIC')))
+    entry = extensions.wrapcommand(commands.table, b'push', pushoutgoingwrap)
+    entry[1].append((b't', b'topic', b'',
+                     _(b"topic to push"), _(b'TOPIC')))
 
-    entry = extensions.wrapcommand(commands.table, 'outgoing',
+    entry = extensions.wrapcommand(commands.table, b'outgoing',
                                    pushoutgoingwrap)
-    entry[1].append(('t', 'topic', '',
-                     _("topic to push"), _('TOPIC')))
+    entry[1].append((b't', b'topic', b'',
+                     _(b"topic to push"), _(b'TOPIC')))
 
-    extensions.wrapfunction(cmdutil, 'buildcommittext', committextwrap)
-    extensions.wrapfunction(merge, 'update', mergeupdatewrap)
+    extensions.wrapfunction(cmdutil, b'buildcommittext', committextwrap)
+    extensions.wrapfunction(merge, b'update', mergeupdatewrap)
     # We need to check whether t0 or b0 or s0 is passed to override the default update
     # behaviour of changing topic and I can't find a better way
     # to do that as scmutil.revsingle returns the rev number and hence we can't
     # plug into logic for this into mergemod.update().
-    extensions.wrapcommand(commands.table, 'update', checkt0)
+    extensions.wrapcommand(commands.table, b'update', checkt0)
 
     try:
-        evolve = extensions.find('evolve')
-        extensions.wrapfunction(evolve.rewriteutil, "presplitupdate",
+        evolve = extensions.find(b'evolve')
+        extensions.wrapfunction(evolve.rewriteutil, b"presplitupdate",
                                 presplitupdatetopic)
     except (KeyError, AttributeError):
         pass
 
-    cmdutil.summaryhooks.add('topic', summaryhook)
+    cmdutil.summaryhooks.add(b'topic', summaryhook)
 
     if not post45template:
-        templatekw.keywords['topic'] = topickw
-        templatekw.keywords['topicidx'] = topicidxkw
+        templatekw.keywords[b'topic'] = topickw
+        templatekw.keywords[b'topicidx'] = topicidxkw
     # Wrap workingctx extra to return the topic name
-    extensions.wrapfunction(context.workingctx, '__init__', wrapinit)
+    extensions.wrapfunction(context.workingctx, b'__init__', wrapinit)
     # Wrap changelog.add to drop empty topic
-    extensions.wrapfunction(changelog.changelog, 'add', wrapadd)
+    extensions.wrapfunction(changelog.changelog, b'add', wrapadd)
 
 def reposetup(ui, repo):
     if not isinstance(repo, localrepo.localrepository):
@@ -368,9 +368,9 @@
 
     repo = repo.unfiltered()
 
-    if repo.ui.config('experimental', 'thg.displaynames') is None:
-        repo.ui.setconfig('experimental', 'thg.displaynames', 'topics',
-                          source='topic-extension')
+    if repo.ui.config(b'experimental', b'thg.displaynames') is None:
+        repo.ui.setconfig(b'experimental', b'thg.displaynames', b'topics',
+                          source=b'topic-extension')
 
     class topicrepo(repo.__class__):
 
@@ -379,15 +379,15 @@
 
         def _restrictcapabilities(self, caps):
             caps = super(topicrepo, self)._restrictcapabilities(caps)
-            caps.add('topics')
+            caps.add(b'topics')
             return caps
 
         def commit(self, *args, **kwargs):
-            backup = self.ui.backupconfig('ui', 'allowemptycommit')
+            backup = self.ui.backupconfig(b'ui', b'allowemptycommit')
             try:
-                if self.currenttopic != self['.'].topic():
+                if self.currenttopic != self[b'.'].topic():
                     # bypass the core "nothing changed" logic
-                    self.ui.setconfig('ui', 'allowemptycommit', True)
+                    self.ui.setconfig(b'ui', b'allowemptycommit', True)
                 return super(topicrepo, self).commit(*args, **kwargs)
             finally:
                 self.ui.restoreconfig(backup)
@@ -403,7 +403,7 @@
                 if current:
                     ctx.extra()[constants.extrakey] = current
             if (isinstance(ctx, context.memctx)
-                and ctx.extra().get('amend_source')
+                and ctx.extra().get(b'amend_source')
                 and ctx.topic()
                 and not self.currenttopic):
                 # we are amending and need to remove a topic
@@ -414,16 +414,16 @@
         def topics(self):
             if self._topics is not None:
                 return self._topics
-            topics = set(['', self.currenttopic])
-            for c in self.set('not public()'):
+            topics = set([b'', self.currenttopic])
+            for c in self.set(b'not public()'):
                 topics.add(c.topic())
-            topics.remove('')
+            topics.remove(b'')
             self._topics = topics
             return topics
 
         @property
         def currenttopic(self):
-            return self.vfs.tryread('topic')
+            return self.vfs.tryread(b'topic')
 
         # overwritten at the instance level by topicmap.py
         _autobranchmaptopic = True
@@ -454,12 +454,12 @@
         def transaction(self, desc, *a, **k):
             ctr = self.currenttransaction()
             tr = super(topicrepo, self).transaction(desc, *a, **k)
-            if desc in ('strip', 'repair') or ctr is not None:
+            if desc in (b'strip', b'repair') or ctr is not None:
                 return tr
 
             reporef = weakref.ref(self)
-            if self.ui.configbool('experimental', 'enforce-single-head'):
-                if util.safehasattr(tr, 'validator'): # hg <= 4.7
+            if self.ui.configbool(b'experimental', b'enforce-single-head'):
+                if util.safehasattr(tr, b'validator'): # hg <= 4.7
                     origvalidator = tr.validator
                 else:
                     origvalidator = tr._validator
@@ -469,16 +469,16 @@
                     flow.enforcesinglehead(repo, tr2)
                     origvalidator(tr2)
 
-                if util.safehasattr(tr, 'validator'): # hg <= 4.7
+                if util.safehasattr(tr, b'validator'): # hg <= 4.7
                     tr.validator = validator
                 else:
                     tr._validator = validator
 
-            topicmodeserver = self.ui.config('experimental',
-                                             'topic-mode.server', 'ignore')
-            ispush = (desc.startswith('push') or desc.startswith('serve'))
-            if (topicmodeserver != 'ignore' and ispush):
-                if util.safehasattr(tr, 'validator'): # hg <= 4.7
+            topicmodeserver = self.ui.config(b'experimental',
+                                             b'topic-mode.server', b'ignore')
+            ispush = (desc.startswith(b'push') or desc.startswith(b'serve'))
+            if (topicmodeserver != b'ignore' and ispush):
+                if util.safehasattr(tr, b'validator'): # hg <= 4.7
                     origvalidator = tr.validator
                 else:
                     origvalidator = tr._validator
@@ -487,14 +487,14 @@
                     repo = reporef()
                     flow.rejectuntopicedchangeset(repo, tr2)
                     return origvalidator(tr2)
-                if util.safehasattr(tr, 'validator'): # hg <= 4.7
+                if util.safehasattr(tr, b'validator'): # hg <= 4.7
                     tr.validator = validator
                 else:
                     tr._validator = validator
 
-            elif (self.ui.configbool('experimental', 'topic.publish-bare-branch')
-                    and (desc.startswith('push')
-                         or desc.startswith('serve'))
+            elif (self.ui.configbool(b'experimental', b'topic.publish-bare-branch')
+                    and (desc.startswith(b'push')
+                         or desc.startswith(b'serve'))
                     ):
                 origclose = tr.close
                 trref = weakref.ref(tr)
@@ -505,11 +505,11 @@
                     flow.publishbarebranch(repo, tr2)
                     origclose()
                 tr.close = close
-            allow_publish = self.ui.configbool('experimental',
-                                               'topic.allow-publish',
+            allow_publish = self.ui.configbool(b'experimental',
+                                               b'topic.allow-publish',
                                                True)
             if not allow_publish:
-                if util.safehasattr(tr, 'validator'): # hg <= 4.7
+                if util.safehasattr(tr, b'validator'): # hg <= 4.7
                     origvalidator = tr.validator
                 else:
                     origvalidator = tr._validator
@@ -518,7 +518,7 @@
                     repo = reporef()
                     flow.reject_publish(repo, tr2)
                     return origvalidator(tr2)
-                if util.safehasattr(tr, 'validator'): # hg <= 4.7
+                if util.safehasattr(tr, b'validator'): # hg <= 4.7
                     tr.validator = validator
                 else:
                     tr._validator = validator
@@ -537,62 +537,62 @@
                 csetcount = stack.stack(repo, topic=ct).changesetcount
                 empty = csetcount == 0
                 if empty and not ctwasempty:
-                    ui.status('active topic %r is now empty\n' % ct)
+                    ui.status(b'active topic %r is now empty\n' % ct)
                     trnames = getattr(tr, 'names', getattr(tr, '_names', ()))
-                    if ('phase' in trnames
-                            or any(n.startswith('push-response')
+                    if (b'phase' in trnames
+                            or any(n.startswith(b'push-response')
                                    for n in trnames)):
-                        ui.status(_("(use 'hg topic --clear' to clear it if needed)\n"))
-                hint = _("(see 'hg help topics' for more information)\n")
+                        ui.status(_(b"(use 'hg topic --clear' to clear it if needed)\n"))
+                hint = _(b"(see 'hg help topics' for more information)\n")
                 if ctwasempty and not empty:
                     if csetcount == 1:
-                        msg = _('active topic %r grew its first changeset\n%s')
+                        msg = _(b'active topic %r grew its first changeset\n%s')
                         ui.status(msg % (ct, hint))
                     else:
-                        msg = _('active topic %r grew its %s first changesets\n%s')
+                        msg = _(b'active topic %r grew its %s first changesets\n%s')
                         ui.status(msg % (ct, csetcount, hint))
 
-            tr.addpostclose('signalcurrenttopicempty', currenttopicempty)
+            tr.addpostclose(b'signalcurrenttopicempty', currenttopicempty)
             return tr
 
     repo.__class__ = topicrepo
     repo._topics = None
-    if util.safehasattr(repo, 'names'):
+    if util.safehasattr(repo, b'names'):
         repo.names.addnamespace(namespaces.namespace(
-            'topics', 'topic', namemap=_namemap, nodemap=_nodemap,
+            b'topics', b'topic', namemap=_namemap, nodemap=_nodemap,
             listnames=lambda repo: repo.topics))
 
 if post45template:
-    @templatekeyword('topic', requires={'ctx'})
+    @templatekeyword(b'topic', requires={b'ctx'})
     def topickw(context, mapping):
         """:topic: String. The topic of the changeset"""
-        ctx = context.resource(mapping, 'ctx')
+        ctx = context.resource(mapping, b'ctx')
         return ctx.topic()
 
-    @templatekeyword('topicidx', requires={'ctx'})
+    @templatekeyword(b'topicidx', requires={b'ctx'})
     def topicidxkw(context, mapping):
         """:topicidx: Integer. Index of the changeset as a stack alias"""
-        ctx = context.resource(mapping, 'ctx')
+        ctx = context.resource(mapping, b'ctx')
         return ctx.topicidx()
 else:
     def topickw(**args):
         """:topic: String. The topic of the changeset"""
-        return args['ctx'].topic()
+        return args[b'ctx'].topic()
 
     def topicidxkw(**args):
         """:topicidx: Integer. Index of the changeset as a stack alias"""
-        return args['ctx'].topicidx()
+        return args[b'ctx'].topicidx()
 
 def wrapinit(orig, self, repo, *args, **kwargs):
     orig(self, repo, *args, **kwargs)
     if not hastopicext(repo):
         return
     if constants.extrakey not in self._extra:
-        if getattr(repo, 'currenttopic', ''):
+        if getattr(repo, 'currenttopic', b''):
             self._extra[constants.extrakey] = repo.currenttopic
         else:
             # Empty key will be dropped from extra by another hack at the changegroup level
-            self._extra[constants.extrakey] = ''
+            self._extra[constants.extrakey] = b''
 
 def wrapadd(orig, cl, manifest, files, desc, transaction, p1, p2, user,
             date=None, extra=None, p1copies=None, p2copies=None,
@@ -603,28 +603,28 @@
     # hg <= 4.9 (0e41f40b01cc)
     kwargs = {}
     if p1copies is not None:
-        kwargs['p1copies'] = p1copies
+        kwargs[b'p1copies'] = p1copies
     if p2copies is not None:
-        kwargs['p2copies'] = p2copies
+        kwargs[b'p2copies'] = p2copies
     # hg <= 5.0 (f385ba70e4af)
     if filesadded is not None:
-        kwargs['filesadded'] = filesadded
+        kwargs[b'filesadded'] = filesadded
     if filesremoved is not None:
-        kwargs['filesremoved'] = filesremoved
+        kwargs[b'filesremoved'] = filesremoved
     return orig(cl, manifest, files, desc, transaction, p1, p2, user,
                 date=date, extra=extra, **kwargs)
 
 # revset predicates are automatically registered at loading via this symbol
 revsetpredicate = topicrevset.revsetpredicate
 
- at command('topics', [
-        ('', 'clear', False, 'clear active topic if any'),
-        ('r', 'rev', [], 'revset of existing revisions', _('REV')),
-        ('l', 'list', False, 'show the stack of changeset in the topic'),
-        ('', 'age', False, 'show when you last touched the topics'),
-        ('', 'current', None, 'display the current topic only'),
+ at command(b'topics', [
+        (b'', b'clear', False, b'clear active topic if any'),
+        (b'r', b'rev', [], b'revset of existing revisions', _(b'REV')),
+        (b'l', b'list', False, b'show the stack of changeset in the topic'),
+        (b'', b'age', False, b'show when you last touched the topics'),
+        (b'', b'current', None, b'display the current topic only'),
     ] + commands.formatteropts,
-    _('hg topics [TOPIC]'))
+    _(b'hg topics [TOPIC]'))
 def topics(ui, repo, topic=None, **opts):
     """View current topic, set current topic, change topic for a set of revisions, or see all topics.
 
@@ -662,20 +662,20 @@
 
     The --verbose version of this command display various information on the state of each topic."""
 
-    clear = opts.get('clear')
-    list = opts.get('list')
-    rev = opts.get('rev')
-    current = opts.get('current')
-    age = opts.get('age')
+    clear = opts.get(b'clear')
+    list = opts.get(b'list')
+    rev = opts.get(b'rev')
+    current = opts.get(b'current')
+    age = opts.get(b'age')
 
     if current and topic:
-        raise error.Abort(_("cannot use --current when setting a topic"))
+        raise error.Abort(_(b"cannot use --current when setting a topic"))
     if current and clear:
-        raise error.Abort(_("cannot use --current and --clear"))
+        raise error.Abort(_(b"cannot use --current and --clear"))
     if clear and topic:
-        raise error.Abort(_("cannot use --clear when setting a topic"))
+        raise error.Abort(_(b"cannot use --clear when setting a topic"))
     if age and topic:
-        raise error.Abort(_("cannot use --age while setting a topic"))
+        raise error.Abort(_(b"cannot use --age while setting a topic"))
 
     touchedrevs = set()
     if rev:
@@ -684,49 +684,49 @@
     if topic:
         topic = topic.strip()
         if not topic:
-            raise error.Abort(_("topic name cannot consist entirely of whitespaces"))
+            raise error.Abort(_(b"topic name cannot consist entirely of whitespaces"))
         # Have some restrictions on the topic name just like bookmark name
-        scmutil.checknewlabel(repo, topic, 'topic')
+        scmutil.checknewlabel(repo, topic, b'topic')
 
         rmatch = re.match(br'[-_.\w]+', topic)
         if not rmatch or rmatch.group(0) != topic:
-            helptxt = _("topic names can only consist of alphanumeric, '-'"
-                        " '_' and '.' characters")
-            raise error.Abort(_("invalid topic name: '%s'") % topic, hint=helptxt)
+            helptxt = _(b"topic names can only consist of alphanumeric, '-'"
+                        b" '_' and '.' characters")
+            raise error.Abort(_(b"invalid topic name: '%s'") % topic, hint=helptxt)
 
     if list:
-        ui.pager('topics')
+        ui.pager(b'topics')
         if clear or rev:
-            raise error.Abort(_("cannot use --clear or --rev with --list"))
+            raise error.Abort(_(b"cannot use --clear or --rev with --list"))
         if not topic:
             topic = repo.currenttopic
         if not topic:
-            raise error.Abort(_('no active topic to list'))
+            raise error.Abort(_(b'no active topic to list'))
         return stack.showstack(ui, repo, topic=topic, opts=opts)
 
     if touchedrevs:
         if not obsolete.isenabled(repo, obsolete.createmarkersopt):
-            raise error.Abort(_('must have obsolete enabled to change topics'))
+            raise error.Abort(_(b'must have obsolete enabled to change topics'))
         if clear:
             topic = None
-        elif opts.get('current'):
+        elif opts.get(b'current'):
             topic = repo.currenttopic
         elif not topic:
-            raise error.Abort('changing topic requires a topic name or --clear')
-        if repo.revs('%ld and public()', touchedrevs):
-            raise error.Abort("can't change topic of a public change")
+            raise error.Abort(b'changing topic requires a topic name or --clear')
+        if repo.revs(b'%ld and public()', touchedrevs):
+            raise error.Abort(b"can't change topic of a public change")
         wl = lock = txn = None
         try:
             wl = repo.wlock()
             lock = repo.lock()
-            txn = repo.transaction('rewrite-topics')
+            txn = repo.transaction(b'rewrite-topics')
             rewrote = _changetopics(ui, repo, touchedrevs, topic)
             txn.close()
             if topic is None:
-                ui.status('cleared topic on %d changesets\n' % rewrote)
+                ui.status(b'cleared topic on %d changesets\n' % rewrote)
             else:
-                ui.status('changed topic on %d changesets to "%s"\n' % (rewrote,
-                                                                        topic))
+                ui.status(b'changed topic on %d changesets to "%s"\n' % (rewrote,
+                                                                         topic))
         finally:
             lockmod.release(txn, lock, wl)
             repo.invalidate()
@@ -737,37 +737,37 @@
         if ct:
             st = stack.stack(repo, topic=ct)
             if not st:
-                ui.status(_('clearing empty topic "%s"\n') % ct)
+                ui.status(_(b'clearing empty topic "%s"\n') % ct)
         return _changecurrenttopic(repo, None)
 
     if topic:
         if not ct:
-            ui.status(_('marked working directory as topic: %s\n') % topic)
+            ui.status(_(b'marked working directory as topic: %s\n') % topic)
         return _changecurrenttopic(repo, topic)
 
-    ui.pager('topics')
+    ui.pager(b'topics')
     # `hg topic --current`
     ret = 0
     if current and not ct:
-        ui.write_err(_('no active topic\n'))
+        ui.write_err(_(b'no active topic\n'))
         ret = 1
     elif current:
-        fm = ui.formatter('topic', opts)
-        namemask = '%s\n'
-        label = 'topic.active'
+        fm = ui.formatter(b'topic', opts)
+        namemask = b'%s\n'
+        label = b'topic.active'
         fm.startitem()
-        fm.write('topic', namemask, ct, label=label)
+        fm.write(b'topic', namemask, ct, label=label)
         fm.end()
     else:
         _listtopics(ui, repo, opts)
     return ret
 
- at command('stack', [
-        ('c', 'children', None,
-            _('display data about children outside of the stack'))
+ at command(b'stack', [
+        (b'c', b'children', None,
+            _(b'display data about children outside of the stack'))
     ] + commands.formatteropts,
-    _('hg stack [TOPIC]'))
-def cmdstack(ui, repo, topic='', **opts):
+    _(b'hg stack [TOPIC]'))
+def cmdstack(ui, repo, topic=b'', **opts):
     """list all changesets in a topic and other information
 
     List the current topic by default.
@@ -781,30 +781,30 @@
         topic = repo.currenttopic
     if topic is None:
         branch = repo[None].branch()
-    ui.pager('stack')
+    ui.pager(b'stack')
     return stack.showstack(ui, repo, branch=branch, topic=topic, opts=opts)
 
- at command('debugcb|debugconvertbookmark', [
-        ('b', 'bookmark', '', _('bookmark to convert to topic')),
-        ('', 'all', None, _('convert all bookmarks to topics')),
+ at command(b'debugcb|debugconvertbookmark', [
+        (b'b', b'bookmark', b'', _(b'bookmark to convert to topic')),
+        (b'', b'all', None, _(b'convert all bookmarks to topics')),
     ],
-    _('[-b BOOKMARK] [--all]'))
+    _(b'[-b BOOKMARK] [--all]'))
 def debugconvertbookmark(ui, repo, **opts):
     """Converts a bookmark to a topic with the same name.
     """
 
-    bookmark = opts.get('bookmark')
-    convertall = opts.get('all')
+    bookmark = opts.get(b'bookmark')
+    convertall = opts.get(b'all')
 
     if convertall and bookmark:
-        raise error.Abort(_("cannot use '--all' and '-b' together"))
+        raise error.Abort(_(b"cannot use '--all' and '-b' together"))
     if not (convertall or bookmark):
-        raise error.Abort(_("you must specify either '--all' or '-b'"))
+        raise error.Abort(_(b"you must specify either '--all' or '-b'"))
 
     bmstore = repo._bookmarks
 
     nodetobook = {}
-    for book, revnode in bmstore.iteritems():
+    for book, revnode in bmstore.items():
         if nodetobook.get(revnode):
             nodetobook[revnode].append(book)
         else:
@@ -824,28 +824,28 @@
             try:
                 node = bmstore[bookmark]
             except KeyError:
-                raise error.Abort(_("no such bookmark exists: '%s'") % bookmark)
+                raise error.Abort(_(b"no such bookmark exists: '%s'") % bookmark)
 
             revnum = repo[node].rev()
             if len(nodetobook[node]) > 1:
-                ui.status(_("skipping revision '%d' as it has multiple bookmarks "
-                          "on it\n") % revnum)
+                ui.status(_(b"skipping revision '%d' as it has multiple bookmarks "
+                          b"on it\n") % revnum)
                 return
             targetrevs = _findconvertbmarktopic(repo, bookmark)
             if targetrevs:
                 actions[(bookmark, revnum)] = targetrevs
 
         elif convertall:
-            for bmark, revnode in sorted(bmstore.iteritems()):
+            for bmark, revnode in sorted(bmstore.items()):
                 revnum = repo[revnode].rev()
                 if revnum in skipped:
                     continue
                 if len(nodetobook[revnode]) > 1:
-                    ui.status(_("skipping '%d' as it has multiple bookmarks on"
-                              " it\n") % revnum)
+                    ui.status(_(b"skipping '%d' as it has multiple bookmarks on"
+                              b" it\n") % revnum)
                     skipped.append(revnum)
                     continue
-                if bmark == '@':
+                if bmark == b'@':
                     continue
                 targetrevs = _findconvertbmarktopic(repo, bmark)
                 if targetrevs:
@@ -853,8 +853,8 @@
 
         if actions:
             try:
-                tr = repo.transaction('debugconvertbookmark')
-                for ((bmark, revnum), targetrevs) in sorted(actions.iteritems()):
+                tr = repo.transaction(b'debugconvertbookmark')
+                for ((bmark, revnum), targetrevs) in sorted(actions.items()):
                     _applyconvertbmarktopic(ui, repo, targetrevs, revnum, bmark, tr)
                 tr.close()
             finally:
@@ -901,9 +901,9 @@
     # changeset
     if rewrote == 0:
         return
-    ui.status(_('changed topic to "%s" on %d revisions\n') % (bmark,
+    ui.status(_(b'changed topic to "%s" on %d revisions\n') % (bmark,
               rewrote))
-    ui.debug('removing bookmark "%s" from "%d"' % (bmark, old))
+    ui.debug(b'removing bookmark "%s" from "%d"' % (bmark, old))
     bookmarks.delete(repo, tr, [bmark])
 
 def _changecurrenttopic(repo, newtopic):
@@ -911,11 +911,11 @@
 
     if newtopic:
         with repo.wlock():
-            with repo.vfs.open('topic', 'w') as f:
+            with repo.vfs.open(b'topic', b'w') as f:
                 f.write(newtopic)
     else:
-        if repo.vfs.exists('topic'):
-            repo.vfs.unlink('topic')
+        if repo.vfs.exists(b'topic'):
+            repo.vfs.unlink(b'topic')
 
 def _changetopics(ui, repo, revs, newtopic):
     """ Changes topic to newtopic of all the revisions in the revset and return
@@ -934,8 +934,8 @@
             except error.ManifestLookupError:
                 return None
         fixedextra = dict(c.extra())
-        ui.debug('old node id is %s\n' % node.hex(c.node()))
-        ui.debug('origextra: %r\n' % fixedextra)
+        ui.debug(b'old node id is %s\n' % node.hex(c.node()))
+        ui.debug(b'origextra: %r\n' % fixedextra)
         oldtopic = fixedextra.get(constants.extrakey, None)
         if oldtopic == newtopic:
             continue
@@ -944,16 +944,16 @@
         else:
             fixedextra[constants.extrakey] = newtopic
         fixedextra[constants.changekey] = c.hex()
-        if 'amend_source' in fixedextra:
+        if b'amend_source' in fixedextra:
             # TODO: right now the commitctx wrapper in
             # topicrepo overwrites the topic in extra if
             # amend_source is set to support 'hg commit
             # --amend'. Support for amend should be adjusted
             # to not be so invasive.
-            del fixedextra['amend_source']
-        ui.debug('changing topic of %s from %s to %s\n' % (
+            del fixedextra[b'amend_source']
+        ui.debug(b'changing topic of %s from %s to %s\n' % (
             c, oldtopic, newtopic))
-        ui.debug('fixedextra: %r\n' % fixedextra)
+        ui.debug(b'fixedextra: %r\n' % fixedextra)
         # While changing topic of set of linear commits, make sure that
         # we base our commits on new parent rather than old parent which
         # was obsoleted while changing the topic
@@ -974,18 +974,18 @@
 
         # phase handling
         commitphase = c.phase()
-        overrides = {('phases', 'new-commit'): commitphase}
-        with repo.ui.configoverride(overrides, 'changetopic'):
+        overrides = {(b'phases', b'new-commit'): commitphase}
+        with repo.ui.configoverride(overrides, b'changetopic'):
             newnode = repo.commitctx(mc)
 
         successors[c.node()] = (newnode,)
-        ui.debug('new node id is %s\n' % node.hex(newnode))
+        ui.debug(b'new node id is %s\n' % node.hex(newnode))
         rewrote += 1
 
     # create obsmarkers and move bookmarks
     # XXX we should be creating marker as we go instead of only at the end,
     # this makes the operations more modulars
-    scmutil.cleanupnodes(repo, successors, 'changetopics')
+    scmutil.cleanupnodes(repo, successors, b'changetopics')
 
     # move the working copy too
     wctx = repo[None]
@@ -997,13 +997,13 @@
     return rewrote
 
 def _listtopics(ui, repo, opts):
-    fm = ui.formatter('topics', opts)
+    fm = ui.formatter(b'topics', opts)
     activetopic = repo.currenttopic
-    namemask = '%s'
+    namemask = b'%s'
     if repo.topics:
         maxwidth = max(len(t) for t in repo.topics)
-        namemask = '%%-%is' % maxwidth
-    if opts.get('age'):
+        namemask = b'%%-%is' % maxwidth
+    if opts.get(b'age'):
         # here we sort by age and topic name
         topicsdata = sorted(_getlasttouched(repo, repo.topics))
     else:
@@ -1014,70 +1014,70 @@
         )
     for age, topic, date, user in topicsdata:
         fm.startitem()
-        marker = ' '
-        label = 'topic'
+        marker = b' '
+        label = b'topic'
         active = (topic == activetopic)
         if active:
-            marker = '*'
-            label = 'topic.active'
+            marker = b'*'
+            label = b'topic.active'
         if not ui.quiet:
             # registering the active data is made explicitly later
-            fm.plain(' %s ' % marker, label=label)
-        fm.write('topic', namemask, topic, label=label)
+            fm.plain(b' %s ' % marker, label=label)
+        fm.write(b'topic', namemask, topic, label=label)
         fm.data(active=active)
 
         if ui.quiet:
-            fm.plain('\n')
+            fm.plain(b'\n')
             continue
-        fm.plain(' (')
+        fm.plain(b' (')
         if date:
             if age == -1:
-                timestr = 'empty and active'
+                timestr = b'empty and active'
             else:
                 timestr = templatefilters.age(date)
-            fm.write('lasttouched', '%s', timestr, label='topic.list.time')
+            fm.write(b'lasttouched', b'%s', timestr, label=b'topic.list.time')
         if user:
-            fm.write('usertouched', ' by %s', user, label='topic.list.user')
+            fm.write(b'usertouched', b' by %s', user, label=b'topic.list.user')
         if date:
-            fm.plain(', ')
+            fm.plain(b', ')
         data = stack.stack(repo, topic=topic)
         if ui.verbose:
-            fm.write('branches+', 'on branch: %s',
-                     '+'.join(data.branches), # XXX use list directly after 4.0 is released
-                     label='topic.list.branches')
+            fm.write(b'branches+', b'on branch: %s',
+                     b'+'.join(data.branches), # XXX use list directly after 4.0 is released
+                     label=b'topic.list.branches')
 
-            fm.plain(', ')
-        fm.write('changesetcount', '%d changesets', data.changesetcount,
-                 label='topic.list.changesetcount')
+            fm.plain(b', ')
+        fm.write(b'changesetcount', b'%d changesets', data.changesetcount,
+                 label=b'topic.list.changesetcount')
 
         if data.unstablecount:
-            fm.plain(', ')
-            fm.write('unstablecount', '%d unstable',
+            fm.plain(b', ')
+            fm.write(b'unstablecount', b'%d unstable',
                      data.unstablecount,
-                     label='topic.list.unstablecount')
+                     label=b'topic.list.unstablecount')
 
         headcount = len(data.heads)
         if 1 < headcount:
-            fm.plain(', ')
-            fm.write('headcount', '%d heads',
+            fm.plain(b', ')
+            fm.write(b'headcount', b'%d heads',
                      headcount,
-                     label='topic.list.headcount.multiple')
+                     label=b'topic.list.headcount.multiple')
 
         if ui.verbose:
             # XXX we should include the data even when not verbose
 
             behindcount = data.behindcount
             if 0 < behindcount:
-                fm.plain(', ')
-                fm.write('behindcount', '%d behind',
+                fm.plain(b', ')
+                fm.write(b'behindcount', b'%d behind',
                          behindcount,
-                         label='topic.list.behindcount')
+                         label=b'topic.list.behindcount')
             elif -1 == behindcount:
-                fm.plain(', ')
-                fm.write('behinderror', '%s',
-                         _('ambiguous destination: %s') % data.behinderror,
-                         label='topic.list.behinderror')
-        fm.plain(')\n')
+                fm.plain(b', ')
+                fm.write(b'behinderror', b'%s',
+                         _(b'ambiguous destination: %s') % data.behinderror,
+                         label=b'topic.list.behinderror')
+        fm.plain(b')\n')
     fm.end()
 
 def _getlasttouched(repo, topics):
@@ -1090,7 +1090,7 @@
         age = -1
         user = None
         maxtime = (0, 0)
-        trevs = repo.revs("topic(%s)", topic)
+        trevs = repo.revs(b"topic(%s)", topic)
         # Need to check for the time of all changesets in the topic, whether
         # they are obsolete of non-heads
         # XXX: can we just rely on the max rev number for this
@@ -1107,7 +1107,7 @@
             for marker in obsmarkers:
                 rt = marker.date()
                 if rt[0] > maxtime[0]:
-                    user = marker.metadata().get('user', user)
+                    user = marker.metadata().get(b'user', user)
                     maxtime = rt
 
         username = stack.parseusername(user)
@@ -1117,31 +1117,31 @@
         yield (age, topic, maxtime, username)
 
 def summaryhook(ui, repo):
-    t = getattr(repo, 'currenttopic', '')
+    t = getattr(repo, 'currenttopic', b'')
     if not t:
         return
     # i18n: column positioning for "hg summary"
-    ui.write(_("topic:  %s\n") % ui.label(t, 'topic.active'))
+    ui.write(_(b"topic:  %s\n") % ui.label(t, b'topic.active'))
 
 _validmode = [
-    'ignore',
-    'warning',
-    'enforce',
-    'enforce-all',
-    'random',
-    'random-all',
+    b'ignore',
+    b'warning',
+    b'enforce',
+    b'enforce-all',
+    b'random',
+    b'random-all',
 ]
 
 def _configtopicmode(ui):
     """ Parse the config to get the topicmode
     """
-    topicmode = ui.config('experimental', 'topic-mode')
+    topicmode = ui.config(b'experimental', b'topic-mode')
 
     # Fallback to read enforce-topic
     if topicmode is None:
-        enforcetopic = ui.configbool('experimental', 'enforce-topic')
+        enforcetopic = ui.configbool(b'experimental', b'enforce-topic')
         if enforcetopic:
-            topicmode = "enforce"
+            topicmode = b"enforce"
     if topicmode not in _validmode:
         topicmode = _validmode[0]
 
@@ -1155,37 +1155,37 @@
         ismergecommit = len(repo[None].parents()) == 2
 
         notopic = not repo.currenttopic
-        mayabort = (topicmode == "enforce" and not ismergecommit)
-        maywarn = (topicmode == "warning"
-                   or (topicmode == "enforce" and ismergecommit))
+        mayabort = (topicmode == b"enforce" and not ismergecommit)
+        maywarn = (topicmode == b"warning"
+                   or (topicmode == b"enforce" and ismergecommit))
 
         mayrandom = False
-        if topicmode == "random":
+        if topicmode == b"random":
             mayrandom = not ismergecommit
-        elif topicmode == "random-all":
+        elif topicmode == b"random-all":
             mayrandom = True
 
-        if topicmode == 'enforce-all':
+        if topicmode == b'enforce-all':
             ismergecommit = False
             mayabort = True
             maywarn = False
 
-        hint = _("see 'hg help -e topic.topic-mode' for details")
-        if opts.get('topic'):
-            t = opts['topic']
-            with repo.vfs.open('topic', 'w') as f:
+        hint = _(b"see 'hg help -e topic.topic-mode' for details")
+        if opts.get(b'topic'):
+            t = opts[b'topic']
+            with repo.vfs.open(b'topic', b'w') as f:
                 f.write(t)
-        elif opts.get('amend'):
+        elif opts.get(b'amend'):
             pass
         elif notopic and mayabort:
-            msg = _("no active topic")
+            msg = _(b"no active topic")
             raise error.Abort(msg, hint=hint)
         elif notopic and maywarn:
-            ui.warn(_("warning: new draft commit without topic\n"))
+            ui.warn(_(b"warning: new draft commit without topic\n"))
             if not ui.quiet:
-                ui.warn(("(%s)\n") % hint)
+                ui.warn((b"(%s)\n") % hint)
         elif notopic and mayrandom:
-            with repo.vfs.open('topic', 'w') as f:
+            with repo.vfs.open(b'topic', b'w') as f:
                 f.write(randomname.randomtopicname(ui))
         return orig(ui, repo, *args, **opts)
 
@@ -1194,18 +1194,18 @@
     if hastopicext(repo):
         t = repo.currenttopic
         if t:
-            ret = ret.replace("\nHG: branch",
-                              "\nHG: topic '%s'\nHG: branch" % t)
+            ret = ret.replace(b"\nHG: branch",
+                              b"\nHG: topic '%s'\nHG: branch" % t)
     return ret
 
 def pushoutgoingwrap(orig, ui, repo, *args, **opts):
-    if opts.get('topic'):
-        topicrevs = repo.revs('topic(%s) - obsolete()', opts['topic'])
-        opts.setdefault('rev', []).extend(topicrevs)
+    if opts.get(b'topic'):
+        topicrevs = repo.revs(b'topic(%s) - obsolete()', opts[b'topic'])
+        opts.setdefault(b'rev', []).extend(topicrevs)
     return orig(ui, repo, *args, **opts)
 
 def mergeupdatewrap(orig, repo, node, branchmerge, force, *args, **kwargs):
-    matcher = kwargs.get('matcher')
+    matcher = kwargs.get(b'matcher')
     partial = not (matcher is None or matcher.always())
     wlock = repo.wlock()
     isrebase = False
@@ -1220,37 +1220,37 @@
         # rebased commit. We have explicitly stored in config if rebase is
         # running.
         ot = repo.currenttopic
-        if repo.ui.hasconfig('experimental', 'topicrebase'):
+        if repo.ui.hasconfig(b'experimental', b'topicrebase'):
             isrebase = True
-        if repo.ui.configbool('_internal', 'keep-topic'):
+        if repo.ui.configbool(b'_internal', b'keep-topic'):
             ist0 = True
         if ((not partial and not branchmerge) or isrebase) and not ist0:
-            t = ''
+            t = b''
             pctx = repo[node]
             if pctx.phase() > phases.public:
                 t = pctx.topic()
-            with repo.vfs.open('topic', 'w') as f:
+            with repo.vfs.open(b'topic', b'w') as f:
                 f.write(t)
             if t and t != ot:
-                repo.ui.status(_("switching to topic %s\n") % t)
+                repo.ui.status(_(b"switching to topic %s\n") % t)
             if ot and not t:
                 st = stack.stack(repo, topic=ot)
                 if not st:
-                    repo.ui.status(_('clearing empty topic "%s"\n') % ot)
+                    repo.ui.status(_(b'clearing empty topic "%s"\n') % ot)
         elif ist0:
-            repo.ui.status(_("preserving the current topic '%s'\n") % ot)
+            repo.ui.status(_(b"preserving the current topic '%s'\n") % ot)
         return ret
     finally:
         wlock.release()
 
 def checkt0(orig, ui, repo, node=None, rev=None, *args, **kwargs):
 
-    thezeros = set(['t0', 'b0', 's0'])
-    backup = repo.ui.backupconfig('_internal', 'keep-topic')
+    thezeros = set([b't0', b'b0', b's0'])
+    backup = repo.ui.backupconfig(b'_internal', b'keep-topic')
     try:
         if node in thezeros or rev in thezeros:
-            repo.ui.setconfig('_internal', 'keep-topic', 'yes',
-                              source='topic-extension')
+            repo.ui.setconfig(b'_internal', b'keep-topic', b'yes',
+                              source=b'topic-extension')
         return orig(ui, repo, node=node, rev=rev, *args, **kwargs)
     finally:
         repo.ui.restoreconfig(backup)
@@ -1264,25 +1264,25 @@
             extra[constants.extrakey] = ctx.topic()
 
     def setrebaseconfig(orig, ui, repo, **opts):
-        repo.ui.setconfig('experimental', 'topicrebase', 'yes',
-                          source='topic-extension')
+        repo.ui.setconfig(b'experimental', b'topicrebase', b'yes',
+                          source=b'topic-extension')
         return orig(ui, repo, **opts)
 
     def new_init(orig, *args, **kwargs):
         runtime = orig(*args, **kwargs)
 
-        if util.safehasattr(runtime, 'extrafns'):
+        if util.safehasattr(runtime, b'extrafns'):
             runtime.extrafns.append(savetopic)
 
         return runtime
 
     try:
-        rebase = extensions.find("rebase")
-        extensions.wrapfunction(rebase.rebaseruntime, '__init__', new_init)
+        rebase = extensions.find(b"rebase")
+        extensions.wrapfunction(rebase.rebaseruntime, b'__init__', new_init)
         # This exists to store in the config that rebase is running so that we can
         # update the topic according to rebase. This is a hack and should be removed
         # when we have better options.
-        extensions.wrapcommand(rebase.cmdtable, 'rebase', setrebaseconfig)
+        extensions.wrapcommand(rebase.cmdtable, b'rebase', setrebaseconfig)
     except KeyError:
         pass
 
@@ -1291,27 +1291,27 @@
 def _exporttopic(seq, ctx):
     topic = ctx.topic()
     if topic:
-        return 'EXP-Topic %s' % topic
+        return b'EXP-Topic %s' % topic
     return None
 
 def _importtopic(repo, patchdata, extra, opts):
-    if 'topic' in patchdata:
-        extra['topic'] = patchdata['topic']
+    if b'topic' in patchdata:
+        extra[b'topic'] = patchdata[b'topic']
 
 def setupimportexport(ui):
     """run at ui setup time to install import/export logic"""
-    cmdutil.extraexport.append('topic')
-    cmdutil.extraexportmap['topic'] = _exporttopic
-    cmdutil.extrapreimport.append('topic')
-    cmdutil.extrapreimportmap['topic'] = _importtopic
-    patch.patchheadermap.append(('EXP-Topic', 'topic'))
+    cmdutil.extraexport.append(b'topic')
+    cmdutil.extraexportmap[b'topic'] = _exporttopic
+    cmdutil.extrapreimport.append(b'topic')
+    cmdutil.extrapreimportmap[b'topic'] = _importtopic
+    patch.patchheadermap.append((b'EXP-Topic', b'topic'))
 
 ## preserve topic during split
 
 def presplitupdatetopic(original, repo, ui, prev, ctx):
     # Save topic of revision
     topic = None
-    if util.safehasattr(ctx, 'topic'):
+    if util.safehasattr(ctx, b'topic'):
         topic = ctx.topic()
 
     # Update the working directory
diff --git a/hgext3rd/topic/constants.py b/hgext3rd/topic/constants.py
--- a/hgext3rd/topic/constants.py
+++ b/hgext3rd/topic/constants.py
@@ -1,2 +1,2 @@
-extrakey = 'topic'
-changekey = '_rewrite_noise'
+extrakey = b'topic'
+changekey = b'_rewrite_noise'
diff --git a/hgext3rd/topic/destination.py b/hgext3rd/topic/destination.py
--- a/hgext3rd/topic/destination.py
+++ b/hgext3rd/topic/destination.py
@@ -13,11 +13,11 @@
 )
 from .evolvebits import builddependencies
 
-def _destmergebranch(orig, repo, action='merge', sourceset=None,
+def _destmergebranch(orig, repo, action=b'merge', sourceset=None,
                      onheadcheck=True, destspace=None):
     # XXX: take destspace into account
     if sourceset is None:
-        p1 = repo['.']
+        p1 = repo[b'.']
     else:
         # XXX: using only the max here is flacky. That code should eventually
         # be updated to take care of the whole sourceset.
@@ -26,11 +26,11 @@
     if common.hastopicext(repo):
         top = p1.topic()
     if top:
-        revs = repo.revs('topic(%s) - obsolete()', top)
+        revs = repo.revs(b'topic(%s) - obsolete()', top)
         deps, rdeps = builddependencies(repo, revs)
         heads = [r for r in revs if not rdeps[r]]
         if onheadcheck and p1.rev() not in heads:
-            raise error.Abort(_("not at topic head, update or explicit"))
+            raise error.Abort(_(b"not at topic head, update or explicit"))
 
         # prune heads above the source
         otherheads = set(heads)
@@ -43,20 +43,20 @@
             # nothing to do at the topic level
             bhead = ngtip(repo, p1.branch(), all=True)
             if not bhead:
-                raise error.NoMergeDestAbort(_("nothing to merge"))
+                raise error.NoMergeDestAbort(_(b"nothing to merge"))
             elif 1 == len(bhead):
                 return bhead[0]
             else:
-                msg = _("branch '%s' has %d heads "
-                        "- please merge with an explicit rev")
-                hint = _("run 'hg heads .' to see heads")
+                msg = _(b"branch '%s' has %d heads "
+                        b"- please merge with an explicit rev")
+                hint = _(b"run 'hg heads .' to see heads")
                 raise error.ManyMergeDestAbort(msg % (p1.branch(), len(bhead)),
                                                hint=hint)
         elif len(otherheads) == 1:
             return otherheads.pop()
         else:
-            msg = _("topic '%s' has %d heads "
-                    "- please merge with an explicit rev") % (top, len(heads))
+            msg = _(b"topic '%s' has %d heads "
+                    b"- please merge with an explicit rev") % (top, len(heads))
             raise error.ManyMergeDestAbort(msg)
     return orig(repo, action, sourceset, onheadcheck, destspace=destspace)
 
@@ -67,23 +67,23 @@
     movemark = node = None
     topic = repo.currenttopic
     if topic:
-        revs = repo.revs('.::topic(%s)', topic)
+        revs = repo.revs(b'.::topic(%s)', topic)
     else:
         revs = []
     if not revs:
         return None, None, None
     node = revs.last()
     if bookmarks.isactivewdirparent(repo):
-        movemark = repo['.'].node()
+        movemark = repo[b'.'].node()
     return node, movemark, None
 
 def desthistedit(orig, ui, repo):
     if not common.hastopicext(repo):
         return None
-    if not (ui.config('histedit', 'defaultrev', None) is None
+    if not (ui.config(b'histedit', b'defaultrev', None) is None
             and repo.currenttopic):
         return orig(ui, repo)
-    revs = repo.revs('::. and stack()')
+    revs = repo.revs(b'::. and stack()')
     if revs:
         return revs.min()
     return None
@@ -106,8 +106,8 @@
 
 def modsetup(ui):
     """run a uisetup time to install all destinations wrapping"""
-    extensions.wrapfunction(destutil, '_destmergebranch', _destmergebranch)
-    bridx = destutil.destupdatesteps.index('branch')
-    destutil.destupdatesteps.insert(bridx, 'topic')
-    destutil.destupdatestepmap['topic'] = _destupdatetopic
-    extensions.wrapfunction(destutil, 'desthistedit', desthistedit)
+    extensions.wrapfunction(destutil, b'_destmergebranch', _destmergebranch)
+    bridx = destutil.destupdatesteps.index(b'branch')
+    destutil.destupdatesteps.insert(bridx, b'topic')
+    destutil.destupdatestepmap[b'topic'] = _destupdatetopic
+    extensions.wrapfunction(destutil, b'desthistedit', desthistedit)
diff --git a/hgext3rd/topic/discovery.py b/hgext3rd/topic/discovery.py
--- a/hgext3rd/topic/discovery.py
+++ b/hgext3rd/topic/discovery.py
@@ -27,12 +27,12 @@
     repo = pushop.repo.unfiltered()
     remote = pushop.remote
 
-    publishing = ('phases' not in remote.listkeys('namespaces')
-                  or bool(remote.listkeys('phases').get('publishing', False)))
+    publishing = (b'phases' not in remote.listkeys(b'namespaces')
+                  or bool(remote.listkeys(b'phases').get(b'publishing', False)))
 
     if not common.hastopicext(pushop.repo):
         return orig(pushop, *args, **kwargs)
-    elif ((publishing or not remote.capable('topics'))
+    elif ((publishing or not remote.capable(b'topics'))
             and not getattr(pushop, 'publish', False)):
         return orig(pushop, *args, **kwargs)
 
@@ -40,7 +40,7 @@
     remotebranchmap = None
     origremotebranchmap = remote.branchmap
     publishednode = [c.node() for c in pushop.outdatedphases]
-    publishedset = repo.revs('ancestors(%ln + %ln)',
+    publishedset = repo.revs(b'ancestors(%ln + %ln)',
                              publishednode,
                              pushop.remotephases.publicheads)
 
@@ -49,18 +49,18 @@
     def remotebranchmap():
         # drop topic information from changeset about to be published
         result = collections.defaultdict(list)
-        for branch, heads in origremotebranchmap().iteritems():
-            if ':' not in branch:
+        for branch, heads in origremotebranchmap().items():
+            if b':' not in branch:
                 result[branch].extend(heads)
             else:
-                namedbranch = branch.split(':', 1)[0]
+                namedbranch = branch.split(b':', 1)[0]
                 for h in heads:
                     r = rev(h)
                     if r is not None and r in publishedset:
                         result[namedbranch].append(h)
                     else:
                         result[branch].append(h)
-        for heads in result.itervalues():
+        for heads in result.values():
             heads.sort()
         return result
 
@@ -77,7 +77,7 @@
                     return branch
                 topic = ctx.topic()
                 if topic:
-                    branch = "%s:%s" % (branch, topic)
+                    branch = b"%s:%s" % (branch, topic)
                 return branch
 
             ctx.branch = branch
@@ -95,7 +95,7 @@
                     return branch, close
                 topic = repo[rev].topic()
                 if topic:
-                    branch = "%s:%s" % (branch, topic)
+                    branch = b"%s:%s" % (branch, topic)
                 return branch, close
 
             rbc.branchinfo = branchinfo
@@ -106,17 +106,17 @@
         repo.__class__ = repocls
         if remotebranchmap is not None:
             remote.branchmap = remotebranchmap
-        unxx = repo.filtered('unfiltered-topic')
+        unxx = repo.filtered(b'unfiltered-topic')
         repo.unfiltered = lambda: unxx
         pushop.repo = repo
         summary = orig(pushop)
-        for key, value in summary.iteritems():
-            if ':' in key: # This is a topic
+        for key, value in summary.items():
+            if b':' in key: # This is a topic
                 if value[0] is None and value[1]:
                     summary[key] = ([value[1][0]], ) + value[1:]
         return summary
     finally:
-        if 'unfiltered' in vars(repo):
+        if b'unfiltered' in vars(repo):
             del repo.unfiltered
         repo.__class__ = oldrepocls
         if remotebranchmap is not None:
@@ -146,7 +146,7 @@
 def _nbheads(repo):
     data = {}
     for b in repo.branchmap().iterbranches():
-        if ':' in b[0]:
+        if b':' in b[0]:
             continue
         data[b[0]] = len(b[1])
     return data
@@ -157,11 +157,11 @@
     if not common.hastopicext(op.repo) or op.repo.publishing():
         return
     tr = op.gettransaction()
-    if tr.hookargs['source'] not in ('push', 'serve'): # not a push
+    if tr.hookargs[b'source'] not in (b'push', b'serve'): # not a push
         return
     tr._prepushheads = _nbheads(op.repo)
     reporef = weakref.ref(op.repo)
-    if util.safehasattr(tr, 'validator'): # hg <= 4.7
+    if util.safehasattr(tr, b'validator'): # hg <= 4.7
         oldvalidator = tr.validator
     else:
         oldvalidator = tr._validator
@@ -171,18 +171,18 @@
         if repo is not None:
             repo.invalidatecaches()
             finalheads = _nbheads(repo)
-            for branch, oldnb in tr._prepushheads.iteritems():
+            for branch, oldnb in tr._prepushheads.items():
                 newnb = finalheads.pop(branch, 0)
                 if oldnb < newnb:
-                    msg = _('push create a new head on branch "%s"' % branch)
+                    msg = _(b'push create a new head on branch "%s"' % branch)
                     raise error.Abort(msg)
-            for branch, newnb in finalheads.iteritems():
+            for branch, newnb in finalheads.items():
                 if 1 < newnb:
-                    msg = _('push create more than 1 head on new branch "%s"'
+                    msg = _(b'push create more than 1 head on new branch "%s"'
                             % branch)
                     raise error.Abort(msg)
         return oldvalidator(tr)
-    if util.safehasattr(tr, 'validator'): # hg <= 4.7
+    if util.safehasattr(tr, b'validator'): # hg <= 4.7
         tr.validator = validator
     else:
         tr._validator = validator
@@ -190,7 +190,7 @@
 
 def _pushb2phases(orig, pushop, bundler):
     if common.hastopicext(pushop.repo):
-        checktypes = ('check:heads', 'check:updated-heads')
+        checktypes = (b'check:heads', b'check:updated-heads')
         hascheck = any(p.type in checktypes for p in bundler._parts)
         if not hascheck and pushop.outdatedphases:
             exchange._pushb2ctxcheckheads(pushop, bundler)
@@ -198,23 +198,23 @@
 
 def wireprotocaps(orig, repo, proto):
     caps = orig(repo, proto)
-    if common.hastopicext(repo) and repo.peer().capable('topics'):
-        caps.append('topics')
+    if common.hastopicext(repo) and repo.peer().capable(b'topics'):
+        caps.append(b'topics')
     return caps
 
 def modsetup(ui):
     """run at uisetup time to install all destinations wrapping"""
-    extensions.wrapfunction(discovery, '_headssummary', _headssummary)
-    extensions.wrapfunction(wireproto, 'branchmap', wireprotobranchmap)
-    extensions.wrapfunction(wireproto, '_capabilities', wireprotocaps)
+    extensions.wrapfunction(discovery, b'_headssummary', _headssummary)
+    extensions.wrapfunction(wireproto, b'branchmap', wireprotobranchmap)
+    extensions.wrapfunction(wireproto, b'_capabilities', wireprotocaps)
     # we need a proper wrap b2 part stuff
-    extensions.wrapfunction(bundle2, 'handlecheckheads', handlecheckheads)
+    extensions.wrapfunction(bundle2, b'handlecheckheads', handlecheckheads)
     bundle2.handlecheckheads.params = frozenset()
-    bundle2.parthandlermapping['check:heads'] = bundle2.handlecheckheads
-    if util.safehasattr(bundle2, 'handlecheckupdatedheads'):
+    bundle2.parthandlermapping[b'check:heads'] = bundle2.handlecheckheads
+    if util.safehasattr(bundle2, b'handlecheckupdatedheads'):
         # we still need a proper wrap b2 part stuff
-        extensions.wrapfunction(bundle2, 'handlecheckupdatedheads', handlecheckheads)
+        extensions.wrapfunction(bundle2, b'handlecheckupdatedheads', handlecheckheads)
         bundle2.handlecheckupdatedheads.params = frozenset()
-        bundle2.parthandlermapping['check:updated-heads'] = bundle2.handlecheckupdatedheads
-    extensions.wrapfunction(exchange, '_pushb2phases', _pushb2phases)
-    exchange.b2partsgenmapping['phase'] = exchange._pushb2phases
+        bundle2.parthandlermapping[b'check:updated-heads'] = bundle2.handlecheckupdatedheads
+    extensions.wrapfunction(exchange, b'_pushb2phases', _pushb2phases)
+    exchange.b2partsgenmapping[b'phase'] = exchange._pushb2phases
diff --git a/hgext3rd/topic/evolvebits.py b/hgext3rd/topic/evolvebits.py
--- a/hgext3rd/topic/evolvebits.py
+++ b/hgext3rd/topic/evolvebits.py
@@ -78,8 +78,8 @@
     newer = obsutil.successorssets(repo, obs.node())
     # search of a parent which is not killed
     while not newer:
-        ui.debug("stabilize target %s is plain dead,"
-                 " trying to stabilize on its parent\n" %
+        ui.debug(b"stabilize target %s is plain dead,"
+                 b" trying to stabilize on its parent\n" %
                  obs)
         obs = obs.parents()[0]
         newer = obsutil.successorssets(repo, obs.node())
@@ -88,7 +88,7 @@
         # we should pick as arbitrary one
         raise MultipleSuccessorsError(newer)
     elif 1 < len(newer[0]):
-        splitheads = list(repo.revs('heads(%ln::%ln)', newer[0], newer[0]))
+        splitheads = list(repo.revs(b'heads(%ln::%ln)', newer[0], newer[0]))
         if 1 < len(splitheads):
             # split case, See if we can make sense of it.
             raise MultipleSuccessorsError(newer)
diff --git a/hgext3rd/topic/flow.py b/hgext3rd/topic/flow.py
--- a/hgext3rd/topic/flow.py
+++ b/hgext3rd/topic/flow.py
@@ -12,18 +12,18 @@
 from mercurial.i18n import _
 
 def enforcesinglehead(repo, tr):
-    for name, heads in repo.filtered('visible').branchmap().iteritems():
+    for name, heads in repo.filtered(b'visible').branchmap().items():
         if len(heads) > 1:
             hexs = [node.short(n) for n in heads]
-            raise error.Abort(_('%d heads on "%s"') % (len(heads), name),
-                              hint=(', '.join(hexs)))
+            raise error.Abort(_(b'%d heads on "%s"') % (len(heads), name),
+                              hint=(b', '.join(hexs)))
 
 def publishbarebranch(repo, tr):
     """Publish changeset without topic"""
-    if 'node' not in tr.hookargs: # no new node
+    if b'node' not in tr.hookargs: # no new node
         return
-    startnode = node.bin(tr.hookargs['node'])
-    topublish = repo.revs('not public() and (%n:) - hidden() - topic()', startnode)
+    startnode = node.bin(tr.hookargs[b'node'])
+    topublish = repo.revs(b'not public() and (%n:) - hidden() - topic()', startnode)
     if topublish:
         cl = repo.changelog
         nodes = [cl.node(r) for r in topublish]
@@ -31,56 +31,56 @@
 
 def rejectuntopicedchangeset(repo, tr):
     """Reject the push if there are changeset without topic"""
-    if 'node' not in tr.hookargs: # no new revs
+    if b'node' not in tr.hookargs: # no new revs
         return
 
-    startnode = node.bin(tr.hookargs['node'])
+    startnode = node.bin(tr.hookargs[b'node'])
 
-    mode = repo.ui.config('experimental', 'topic-mode.server', 'ignore')
+    mode = repo.ui.config(b'experimental', b'topic-mode.server', b'ignore')
 
-    untopiced = repo.revs('not public() and (%n:) - hidden() - topic()', startnode)
+    untopiced = repo.revs(b'not public() and (%n:) - hidden() - topic()', startnode)
     if untopiced:
         num = len(untopiced)
         fnode = repo[untopiced.first()].hex()[:10]
         if num == 1:
-            msg = _("%s") % fnode
+            msg = _(b"%s") % fnode
         else:
-            msg = _("%s and %d more") % (fnode, num - 1)
-        if mode == 'warning':
-            fullmsg = _("pushed draft changeset without topic: %s\n")
+            msg = _(b"%s and %d more") % (fnode, num - 1)
+        if mode == b'warning':
+            fullmsg = _(b"pushed draft changeset without topic: %s\n")
             repo.ui.warn(fullmsg % msg)
-        elif mode == 'enforce':
-            fullmsg = _("rejecting draft changesets: %s")
+        elif mode == b'enforce':
+            fullmsg = _(b"rejecting draft changesets: %s")
             raise error.Abort(fullmsg % msg)
         else:
-            repo.ui.warn(_("unknown 'topic-mode.server': %s\n" % mode))
+            repo.ui.warn(_(b"unknown 'topic-mode.server': %s\n" % mode))
 
 def reject_publish(repo, tr):
     """prevent a transaction to be publish anything"""
     published = set()
-    for r, (o, n) in tr.changes['phases'].items():
+    for r, (o, n) in tr.changes[b'phases'].items():
         if n == phases.public:
             published.add(r)
     if published:
         r = min(published)
-        msg = "rejecting publishing of changeset %s" % repo[r]
+        msg = b"rejecting publishing of changeset %s" % repo[r]
         if len(published) > 1:
-            msg += ' and %d others' % (len(published) - 1)
+            msg += b' and %d others' % (len(published) - 1)
         raise error.Abort(msg)
 
 def wrappush(orig, repo, remote, *args, **kwargs):
     """interpret the --publish flag and pass it to the push operation"""
     newargs = kwargs.copy()
-    if kwargs.pop('publish', False):
-        opargs = kwargs.get('opargs')
+    if kwargs.pop(b'publish', False):
+        opargs = kwargs.get(b'opargs')
         if opargs is None:
             opargs = {}
-        newargs['opargs'] = opargs.copy()
-        newargs['opargs']['publish'] = True
+        newargs[b'opargs'] = opargs.copy()
+        newargs[b'opargs'][b'publish'] = True
     return orig(repo, remote, *args, **newargs)
 
 def extendpushoperation(orig, self, *args, **kwargs):
-    publish = kwargs.pop('publish', False)
+    publish = kwargs.pop(b'publish', False)
     orig(self, *args, **kwargs)
     self.publish = publish
 
@@ -90,16 +90,16 @@
         if not pushop.remotephases.publishing:
             unfi = pushop.repo.unfiltered()
             droots = pushop.remotephases.draftroots
-            revset = '%ln and (not public() or %ln::)'
+            revset = b'%ln and (not public() or %ln::)'
             future = list(unfi.set(revset, pushop.futureheads, droots))
             pushop.outdatedphases = future
 
 def installpushflag(ui):
-    entry = extensions.wrapcommand(commands.table, 'push', wrappush)
-    if not any(opt for opt in entry[1] if opt[1] == 'publish'): # hg <= 4.9
-        entry[1].append(('', 'publish', False,
-                         _('push the changeset as public')))
-    extensions.wrapfunction(exchange.pushoperation, '__init__',
+    entry = extensions.wrapcommand(commands.table, b'push', wrappush)
+    if not any(opt for opt in entry[1] if opt[1] == b'publish'): # hg <= 4.9
+        entry[1].append((b'', b'publish', False,
+                         _(b'push the changeset as public')))
+    extensions.wrapfunction(exchange.pushoperation, b'__init__',
                             extendpushoperation)
-    extensions.wrapfunction(exchange, '_pushdiscoveryphase', wrapphasediscovery)
-    exchange.pushdiscoverymapping['phase'] = exchange._pushdiscoveryphase
+    extensions.wrapfunction(exchange, b'_pushdiscoveryphase', wrapphasediscovery)
+    exchange.pushdiscoverymapping[b'phase'] = exchange._pushdiscoveryphase
diff --git a/hgext3rd/topic/randomname.py b/hgext3rd/topic/randomname.py
--- a/hgext3rd/topic/randomname.py
+++ b/hgext3rd/topic/randomname.py
@@ -8,1003 +8,1003 @@
 import random
 
 animals = [
-    'aardvark',
-    'albatross',
-    'alligator',
-    'alpaca',
-    'ant',
-    'anteater',
-    'antelope',
-    'ape',
-    'armadillo',
-    'baboon',
-    'badger',
-    'barracuda',
-    'bat',
-    'bear',
-    'beaver',
-    'bee',
-    'beetle',
-    'bison',
-    'boar',
-    'buffalo',
-    'bushbaby',
-    'bustard',
-    'butterfly',
-    'camel',
-    'capuchin',
-    'carabao',
-    'caribou',
-    'cat',
-    'caterpillar',
-    'cattle',
-    'chameleon',
-    'chamois',
-    'cheetah',
-    'chicken',
-    'chimpanzee',
-    'chinchilla',
-    'chipmunk',
-    'chough',
-    'cicada',
-    'clam',
-    'cobra',
-    'cockroach',
-    'cod',
-    'cormorant',
-    'coyote',
-    'crab',
-    'crane',
-    'cricket',
-    'crocodile',
-    'crow',
-    'curlew',
-    'deer',
-    'dinosaur',
-    'dog',
-    'dogfish',
-    'dolphin',
-    'donkey',
-    'dotterel',
-    'dove',
-    'dragon',
-    'dragonfly',
-    'duck',
-    'dugong',
-    'dunlin',
-    'eagle',
-    'echidna',
-    'eel',
-    'eland',
-    'elephant',
-    'elk',
-    'emu',
-    'falcon',
-    'ferret',
-    'finch',
-    'fish',
-    'flamingo',
-    'fly',
-    'fox',
-    'frog',
-    'gaur',
-    'gazelle',
-    'gecko',
-    'gerbil',
-    'giraffe',
-    'gnat',
-    'gnu',
-    'goat',
-    'goldfish',
-    'goose',
-    'gorilla',
-    'goshawk',
-    'grasshopper',
-    'grouse',
-    'guanaco',
-    'guinea',
-    'gull',
-    'hamster',
-    'hare',
-    'hawk',
-    'hedgehog',
-    'heron',
-    'herring',
-    'hippopotamus',
-    'hornet',
-    'horse',
-    'horsecrab',
-    'hound',
-    'hummingbird',
-    'hyena',
-    'hyrax',
-    'ibex',
-    'ibis',
-    'iguana',
-    'impala',
-    'insect',
-    'jackal',
-    'jaguar',
-    'jay',
-    'jellyfish',
-    'kangaroo',
-    'koala',
-    'kouprey',
-    'kudu',
-    'lapwing',
-    'lark',
-    'lemming',
-    'lemur',
-    'leopard',
-    'lion',
-    'lizard',
-    'llama',
-    'lobster',
-    'locust',
-    'loris',
-    'louse',
-    'lynx',
-    'lyrebird',
-    'magpie',
-    'mallard',
-    'mammoth',
-    'manatee',
-    'marten',
-    'meerkat',
-    'mink',
-    'minnow',
-    'mole',
-    'mongoose',
-    'monkey',
-    'moose',
-    'mosquito',
-    'mouse',
-    'mule',
-    'muskrat',
-    'narwhal',
-    'newt',
-    'nightingale',
-    'numbat',
-    'octopus',
-    'okapi',
-    'opossum',
-    'oryx',
-    'ostrich',
-    'otter',
-    'owl',
-    'ox',
-    'oyster',
-    'panda',
-    'panther',
-    'parrot',
-    'partridge',
-    'peacock',
-    'peafowl',
-    'pelican',
-    'penguin',
-    'pheasant',
-    'pig',
-    'pigeon',
-    'platypus',
-    'pony',
-    'porcupine',
-    'porpoise',
-    'puffin',
-    'pug',
-    'quagga',
-    'quail',
-    'quelea',
-    'rabbit',
-    'raccoon',
-    'ram',
-    'rat',
-    'raven',
-    'reindeer',
-    'rhea',
-    'rhinoceros',
-    'rook',
-    'ruff',
-    'salamander',
-    'salmon',
-    'sambar',
-    'sandpiper',
-    'sardine',
-    'scorpion',
-    'seahorse',
-    'seal',
-    'serval',
-    'shark',
-    'sheep',
-    'shrew',
-    'shrimp',
-    'skink',
-    'skunk',
-    'snail',
-    'snake',
-    'spider',
-    'squid',
-    'squirrel',
-    'starling',
-    'stinkbug',
-    'stork',
-    'swan',
-    'tapir',
-    'tarsier',
-    'termite',
-    'tern',
-    'tiger',
-    'toad',
-    'trout',
-    'turkey',
-    'turtle',
-    'unicorn',
-    'viper',
-    'vulture',
-    'wallaby',
-    'walrus',
-    'wasp',
-    'weasel',
-    'whale',
-    'wolf',
-    'wolverine',
-    'wombat',
-    'woodchuck',
-    'woodcock',
-    'woodpecker',
-    'worm',
-    'wren',
-    'yak',
-    'zebra',
-    'zorilla'
+    b'aardvark',
+    b'albatross',
+    b'alligator',
+    b'alpaca',
+    b'ant',
+    b'anteater',
+    b'antelope',
+    b'ape',
+    b'armadillo',
+    b'baboon',
+    b'badger',
+    b'barracuda',
+    b'bat',
+    b'bear',
+    b'beaver',
+    b'bee',
+    b'beetle',
+    b'bison',
+    b'boar',
+    b'buffalo',
+    b'bushbaby',
+    b'bustard',
+    b'butterfly',
+    b'camel',
+    b'capuchin',
+    b'carabao',
+    b'caribou',
+    b'cat',
+    b'caterpillar',
+    b'cattle',
+    b'chameleon',
+    b'chamois',
+    b'cheetah',
+    b'chicken',
+    b'chimpanzee',
+    b'chinchilla',
+    b'chipmunk',
+    b'chough',
+    b'cicada',
+    b'clam',
+    b'cobra',
+    b'cockroach',
+    b'cod',
+    b'cormorant',
+    b'coyote',
+    b'crab',
+    b'crane',
+    b'cricket',
+    b'crocodile',
+    b'crow',
+    b'curlew',
+    b'deer',
+    b'dinosaur',
+    b'dog',
+    b'dogfish',
+    b'dolphin',
+    b'donkey',
+    b'dotterel',
+    b'dove',
+    b'dragon',
+    b'dragonfly',
+    b'duck',
+    b'dugong',
+    b'dunlin',
+    b'eagle',
+    b'echidna',
+    b'eel',
+    b'eland',
+    b'elephant',
+    b'elk',
+    b'emu',
+    b'falcon',
+    b'ferret',
+    b'finch',
+    b'fish',
+    b'flamingo',
+    b'fly',
+    b'fox',
+    b'frog',
+    b'gaur',
+    b'gazelle',
+    b'gecko',
+    b'gerbil',
+    b'giraffe',
+    b'gnat',
+    b'gnu',
+    b'goat',
+    b'goldfish',
+    b'goose',
+    b'gorilla',
+    b'goshawk',
+    b'grasshopper',
+    b'grouse',
+    b'guanaco',
+    b'guinea',
+    b'gull',
+    b'hamster',
+    b'hare',
+    b'hawk',
+    b'hedgehog',
+    b'heron',
+    b'herring',
+    b'hippopotamus',
+    b'hornet',
+    b'horse',
+    b'horsecrab',
+    b'hound',
+    b'hummingbird',
+    b'hyena',
+    b'hyrax',
+    b'ibex',
+    b'ibis',
+    b'iguana',
+    b'impala',
+    b'insect',
+    b'jackal',
+    b'jaguar',
+    b'jay',
+    b'jellyfish',
+    b'kangaroo',
+    b'koala',
+    b'kouprey',
+    b'kudu',
+    b'lapwing',
+    b'lark',
+    b'lemming',
+    b'lemur',
+    b'leopard',
+    b'lion',
+    b'lizard',
+    b'llama',
+    b'lobster',
+    b'locust',
+    b'loris',
+    b'louse',
+    b'lynx',
+    b'lyrebird',
+    b'magpie',
+    b'mallard',
+    b'mammoth',
+    b'manatee',
+    b'marten',
+    b'meerkat',
+    b'mink',
+    b'minnow',
+    b'mole',
+    b'mongoose',
+    b'monkey',
+    b'moose',
+    b'mosquito',
+    b'mouse',
+    b'mule',
+    b'muskrat',
+    b'narwhal',
+    b'newt',
+    b'nightingale',
+    b'numbat',
+    b'octopus',
+    b'okapi',
+    b'opossum',
+    b'oryx',
+    b'ostrich',
+    b'otter',
+    b'owl',
+    b'ox',
+    b'oyster',
+    b'panda',
+    b'panther',
+    b'parrot',
+    b'partridge',
+    b'peacock',
+    b'peafowl',
+    b'pelican',
+    b'penguin',
+    b'pheasant',
+    b'pig',
+    b'pigeon',
+    b'platypus',
+    b'pony',
+    b'porcupine',
+    b'porpoise',
+    b'puffin',
+    b'pug',
+    b'quagga',
+    b'quail',
+    b'quelea',
+    b'rabbit',
+    b'raccoon',
+    b'ram',
+    b'rat',
+    b'raven',
+    b'reindeer',
+    b'rhea',
+    b'rhinoceros',
+    b'rook',
+    b'ruff',
+    b'salamander',
+    b'salmon',
+    b'sambar',
+    b'sandpiper',
+    b'sardine',
+    b'scorpion',
+    b'seahorse',
+    b'seal',
+    b'serval',
+    b'shark',
+    b'sheep',
+    b'shrew',
+    b'shrimp',
+    b'skink',
+    b'skunk',
+    b'snail',
+    b'snake',
+    b'spider',
+    b'squid',
+    b'squirrel',
+    b'starling',
+    b'stinkbug',
+    b'stork',
+    b'swan',
+    b'tapir',
+    b'tarsier',
+    b'termite',
+    b'tern',
+    b'tiger',
+    b'toad',
+    b'trout',
+    b'turkey',
+    b'turtle',
+    b'unicorn',
+    b'viper',
+    b'vulture',
+    b'wallaby',
+    b'walrus',
+    b'wasp',
+    b'weasel',
+    b'whale',
+    b'wolf',
+    b'wolverine',
+    b'wombat',
+    b'woodchuck',
+    b'woodcock',
+    b'woodpecker',
+    b'worm',
+    b'wren',
+    b'yak',
+    b'zebra',
+    b'zorilla'
 ]
 
 adjectives = [
-    'abiding',
-    'abject',
-    'ablaze',
-    'able',
-    'aboard',
-    'abounding',
-    'absorbed',
-    'absorbing',
-    'abstracted',
-    'abundant',
-    'acceptable',
-    'accessible',
-    'accurate',
-    'acoustic',
-    'adamant',
-    'adaptable',
-    'adhesive',
-    'adjoining',
-    'adorable',
-    'adventurous',
-    'affable',
-    'affectionate',
-    'agreeable',
-    'alert',
-    'alive',
-    'alluring',
-    'amazing',
-    'ambiguous',
-    'ambitious',
-    'amiable',
-    'amicable',
-    'amused',
-    'amusing',
-    'ancient',
-    'animated',
-    'apricot',
-    'aquatic',
-    'arctic',
-    'arenaceous',
-    'aromatic',
-    'aspiring',
-    'assiduous',
-    'assorted',
-    'astonishing',
-    'attractive',
-    'auspicious',
-    'automatic',
-    'available',
-    'average',
-    'awake',
-    'aware',
-    'awesome',
-    'axiomatic',
-    'bashful',
-    'bawdy',
-    'beautiful',
-    'beefy',
-    'befitting',
-    'beneficial',
-    'benevolent',
-    'bent',
-    'best',
-    'better',
-    'bewildered',
-    'bewitching',
-    'big',
-    'billowy',
-    'bizarre',
-    'black',
-    'blithe',
-    'blue',
-    'blushing',
-    'bouncy',
-    'boundless',
-    'brainy',
-    'brash',
-    'brave',
-    'brawny',
-    'brazen',
-    'breezy',
-    'brief',
-    'bright',
-    'brilliant',
-    'broad',
-    'brown',
-    'bucolic',
-    'bulky',
-    'bumpy',
-    'burgundy',
-    'burly',
-    'bustling',
-    'busy',
-    'calm',
-    'capable',
-    'capricious',
-    'captivating',
-    'carefree',
-    'careful',
-    'caring',
-    'carrot',
-    'ceaseless',
-    'cerise',
-    'certain',
-    'challenging',
-    'changeable',
-    'charming',
-    'cheerful',
-    'chief',
-    'chilly',
-    'chipper',
-    'classy',
-    'clean',
-    'clear',
-    'clever',
-    'cloudy',
-    'coherent',
-    'colorful',
-    'colossal',
-    'comfortable',
-    'common',
-    'communicative',
-    'compassionate',
-    'complete',
-    'complex',
-    'compulsive',
-    'confused',
-    'conscientious',
-    'conscious',
-    'conservative',
-    'considerate',
-    'convivial',
-    'cooing',
-    'cool',
-    'cooperative',
-    'coordinated',
-    'courageous',
-    'courteous',
-    'crazy',
-    'creative',
-    'crispy',
-    'crooked',
-    'crowded',
-    'cuddly',
-    'cultured',
-    'cunning',
-    'curious',
-    'curly',
-    'curved',
-    'curvy',
-    'cut',
-    'cute',
-    'daily',
-    'damp',
-    'dapper',
-    'dashing',
-    'dazzling',
-    'dear',
-    'debonair',
-    'decisive',
-    'decorous',
-    'deep',
-    'defiant',
-    'delicate',
-    'delicious',
-    'delighted',
-    'delightful',
-    'delirious',
-    'descriptive',
-    'detached',
-    'detailed',
-    'determined',
-    'different',
-    'diligent',
-    'diminutive',
-    'diplomatic',
-    'discreet',
-    'distinct',
-    'distinctive',
-    'dramatic',
-    'dry',
-    'dynamic',
-    'dynamite',
-    'eager',
-    'early',
-    'earthy',
-    'easy',
-    'easygoing',
-    'eatable',
-    'economic',
-    'ecstatic',
-    'educated',
-    'efficacious',
-    'efficient',
-    'effortless',
-    'eight',
-    'elastic',
-    'elated',
-    'electric',
-    'elegant',
-    'elfin',
-    'elite',
-    'eminent',
-    'emotional',
-    'enchanted',
-    'enchanting',
-    'encouraging',
-    'endless',
-    'energetic',
-    'enormous',
-    'entertaining',
-    'enthusiastic',
-    'envious',
-    'epicurean',
-    'equable',
-    'equal',
-    'eternal',
-    'ethereal',
-    'evanescent',
-    'even',
-    'excellent',
-    'excited',
-    'exciting',
-    'exclusive',
-    'exotic',
-    'expensive',
-    'exquisite',
-    'extroverted',
-    'exuberant',
-    'exultant',
-    'fabulous',
-    'fair',
-    'faithful',
-    'familiar',
-    'famous',
-    'fancy',
-    'fantastic',
-    'far',
-    'fascinated',
-    'fast',
-    'fearless',
-    'female',
-    'fertile',
-    'festive',
-    'few',
-    'fine',
-    'first',
-    'five',
-    'fixed',
-    'flamboyant',
-    'flashy',
-    'flat',
-    'flawless',
-    'flirtatious',
-    'florid',
-    'flowery',
-    'fluffy',
-    'fluttering',
-    'foamy',
-    'foolish',
-    'foregoing',
-    'fortunate',
-    'four',
-    'frank',
-    'free',
-    'frequent',
-    'fresh',
-    'friendly',
-    'full',
-    'functional',
-    'funny',
-    'furry',
-    'future',
-    'futuristic',
-    'fuzzy',
-    'gabby',
-    'gainful',
-    'garrulous',
-    'general',
-    'generous',
-    'gentle',
-    'giant',
-    'giddy',
-    'gifted',
-    'gigantic',
-    'gilded',
-    'glamorous',
-    'gleaming',
-    'glorious',
-    'glossy',
-    'glowing',
-    'godly',
-    'good',
-    'goofy',
-    'gorgeous',
-    'graceful',
-    'grandiose',
-    'grateful',
-    'gratis',
-    'gray',
-    'great',
-    'green',
-    'gregarious',
-    'grey',
-    'groovy',
-    'guiltless',
-    'gusty',
-    'guttural',
-    'habitual',
-    'half',
-    'hallowed',
-    'halting',
-    'handsome',
-    'happy',
-    'hard',
-    'hardworking',
-    'harmonious',
-    'heady',
-    'healthy',
-    'heavenly',
-    'helpful',
-    'hilarious',
-    'historical',
-    'holistic',
-    'hollow',
-    'honest',
-    'honorable',
-    'hopeful',
-    'hospitable',
-    'hot',
-    'huge',
-    'humorous',
-    'hungry',
-    'hushed',
-    'hypnotic',
-    'illustrious',
-    'imaginary',
-    'imaginative',
-    'immense',
-    'imminent',
-    'impartial',
-    'important',
-    'imported',
-    'impossible',
-    'incandescent',
-    'inconclusive',
-    'incredible',
-    'independent',
-    'industrious',
-    'inexpensive',
-    'innate',
-    'innocent',
-    'inquisitive',
-    'instinctive',
-    'intellectual',
-    'intelligent',
-    'intense',
-    'interesting',
-    'internal',
-    'intuitive',
-    'inventive',
-    'invincible',
-    'jazzy',
-    'jolly',
-    'joyful',
-    'joyous',
-    'judicious',
-    'juicy',
-    'jumpy',
-    'keen',
-    'kind',
-    'kindhearted',
-    'kindly',
-    'knotty',
-    'knowing',
-    'knowledgeable',
-    'known',
-    'laconic',
-    'large',
-    'lavish',
-    'lean',
-    'learned',
-    'left',
-    'legal',
-    'level',
-    'light',
-    'likeable',
-    'literate',
-    'little',
-    'lively',
-    'living',
-    'long',
-    'longing',
-    'loud',
-    'lovely',
-    'loving',
-    'loyal',
-    'lucky',
-    'luminous',
-    'lush',
-    'luxuriant',
-    'luxurious',
-    'lyrical',
-    'magenta',
-    'magical',
-    'magnificent',
-    'majestic',
-    'male',
-    'mammoth',
-    'many',
-    'marvelous',
-    'massive',
-    'material',
-    'mature',
-    'meandering',
-    'meaty',
-    'medical',
-    'mellow',
-    'melodic',
-    'melted',
-    'merciful',
-    'mighty',
-    'miniature',
-    'miniscule',
-    'minor',
-    'minute',
-    'misty',
-    'modern',
-    'modest',
-    'momentous',
-    'motionless',
-    'mountainous',
-    'mute',
-    'mysterious',
-    'narrow',
-    'natural',
-    'near',
-    'neat',
-    'nebulous',
-    'necessary',
-    'neighborly',
-    'new',
-    'next',
-    'nice',
-    'nifty',
-    'nimble',
-    'nine',
-    'nippy',
-    'noiseless',
-    'noisy',
-    'nonchalant',
-    'normal',
-    'numberless',
-    'numerous',
-    'nutritious',
-    'obedient',
-    'observant',
-    'obtainable',
-    'oceanic',
-    'omniscient',
-    'one',
-    'open',
-    'opposite',
-    'optimal',
-    'optimistic',
-    'opulent',
-    'orange',
-    'ordinary',
-    'organic',
-    'outgoing',
-    'outrageous',
-    'outstanding',
-    'oval',
-    'overjoyed',
-    'overt',
-    'palatial',
-    'panoramic',
-    'parallel',
-    'passionate',
-    'past',
-    'pastoral',
-    'patient',
-    'peaceful',
-    'perfect',
-    'periodic',
-    'permissible',
-    'perpetual',
-    'persistent',
-    'petite',
-    'philosophical',
-    'physical',
-    'picturesque',
-    'pink',
-    'pioneering',
-    'piquant',
-    'plausible',
-    'pleasant',
-    'plucky',
-    'poised',
-    'polite',
-    'possible',
-    'powerful',
-    'practical',
-    'precious',
-    'premium',
-    'present',
-    'pretty',
-    'previous',
-    'private',
-    'probable',
-    'productive',
-    'profound',
-    'profuse',
-    'protective',
-    'proud',
-    'psychedelic',
-    'public',
-    'pumped',
-    'purple',
-    'purring',
-    'puzzled',
-    'puzzling',
-    'quaint',
-    'quick',
-    'quicker',
-    'quickest',
-    'quiet',
-    'quirky',
-    'quixotic',
-    'quizzical',
-    'rainy',
-    'rapid',
-    'rare',
-    'rational',
-    'ready',
-    'real',
-    'rebel',
-    'receptive',
-    'red',
-    'reflective',
-    'regular',
-    'relaxed',
-    'reliable',
-    'relieved',
-    'remarkable',
-    'reminiscent',
-    'reserved',
-    'resolute',
-    'resonant',
-    'resourceful',
-    'responsible',
-    'rich',
-    'ridiculous',
-    'right',
-    'rightful',
-    'ripe',
-    'ritzy',
-    'roasted',
-    'robust',
-    'romantic',
-    'roomy',
-    'round',
-    'royal',
-    'ruddy',
-    'rural',
-    'rustic',
-    'sable',
-    'safe',
-    'salty',
-    'same',
-    'satisfying',
-    'savory',
-    'scientific',
-    'scintillating',
-    'scrumptious',
-    'second',
-    'secret',
-    'secretive',
-    'seemly',
-    'selective',
-    'sensible',
-    'separate',
-    'shaggy',
-    'shaky',
-    'shining',
-    'shiny',
-    'short',
-    'shy',
-    'silent',
-    'silky',
-    'silly',
-    'simple',
-    'simplistic',
-    'sincere',
-    'six',
-    'sizzling',
-    'skillful',
-    'sleepy',
-    'slick',
-    'slim',
-    'smart',
-    'smiling',
-    'smooth',
-    'soaring',
-    'sociable',
-    'soft',
-    'solid',
-    'sophisticated',
-    'sparkling',
-    'special',
-    'spectacular',
-    'speedy',
-    'spicy',
-    'spiffy',
-    'spiritual',
-    'splendid',
-    'spooky',
-    'spotless',
-    'spotted',
-    'square',
-    'standing',
-    'statuesque',
-    'steadfast',
-    'steady',
-    'steep',
-    'stimulating',
-    'straight',
-    'straightforward',
-    'striking',
-    'striped',
-    'strong',
-    'stunning',
-    'stupendous',
-    'sturdy',
-    'subsequent',
-    'substantial',
-    'subtle',
-    'successful',
-    'succinct',
-    'sudden',
-    'super',
-    'superb',
-    'supreme',
-    'swanky',
-    'sweet',
-    'swift',
-    'sympathetic',
-    'synonymous',
-    'talented',
-    'tall',
-    'tame',
-    'tan',
-    'tangible',
-    'tangy',
-    'tasteful',
-    'tasty',
-    'telling',
-    'temporary',
-    'tempting',
-    'ten',
-    'tender',
-    'terrific',
-    'tested',
-    'thankful',
-    'therapeutic',
-    'thin',
-    'thinkable',
-    'third',
-    'thoughtful',
-    'three',
-    'thrifty',
-    'tidy',
-    'tiny',
-    'toothsome',
-    'towering',
-    'tranquil',
-    'tremendous',
-    'tricky',
-    'true',
-    'truthful',
-    'two',
-    'typical',
-    'ubiquitous',
-    'ultra',
-    'unassuming',
-    'unbiased',
-    'uncovered',
-    'understanding',
-    'understood',
-    'unequaled',
-    'unique',
-    'unusual',
-    'unwritten',
-    'upbeat',
-    'useful',
-    'utopian',
-    'utter',
-    'uttermost',
-    'valuable',
-    'various',
-    'vast',
-    'verdant',
-    'vermilion',
-    'versatile',
-    'versed',
-    'victorious',
-    'vigorous',
-    'violet',
-    'vivacious',
-    'voiceless',
-    'voluptuous',
-    'wacky',
-    'waiting',
-    'wakeful',
-    'wandering',
-    'warm',
-    'warmhearted',
-    'wealthy',
-    'whimsical',
-    'whispering',
-    'white',
-    'whole',
-    'wholesale',
-    'whopping',
-    'wide',
-    'wiggly',
-    'wild',
-    'willing',
-    'windy',
-    'winsome',
-    'wiry',
-    'wise',
-    'wistful',
-    'witty',
-    'womanly',
-    'wonderful',
-    'workable',
-    'young',
-    'youthful',
-    'yummy',
-    'zany',
-    'zealous',
-    'zesty',
-    'zippy'
+    b'abiding',
+    b'abject',
+    b'ablaze',
+    b'able',
+    b'aboard',
+    b'abounding',
+    b'absorbed',
+    b'absorbing',
+    b'abstracted',
+    b'abundant',
+    b'acceptable',
+    b'accessible',
+    b'accurate',
+    b'acoustic',
+    b'adamant',
+    b'adaptable',
+    b'adhesive',
+    b'adjoining',
+    b'adorable',
+    b'adventurous',
+    b'affable',
+    b'affectionate',
+    b'agreeable',
+    b'alert',
+    b'alive',
+    b'alluring',
+    b'amazing',
+    b'ambiguous',
+    b'ambitious',
+    b'amiable',
+    b'amicable',
+    b'amused',
+    b'amusing',
+    b'ancient',
+    b'animated',
+    b'apricot',
+    b'aquatic',
+    b'arctic',
+    b'arenaceous',
+    b'aromatic',
+    b'aspiring',
+    b'assiduous',
+    b'assorted',
+    b'astonishing',
+    b'attractive',
+    b'auspicious',
+    b'automatic',
+    b'available',
+    b'average',
+    b'awake',
+    b'aware',
+    b'awesome',
+    b'axiomatic',
+    b'bashful',
+    b'bawdy',
+    b'beautiful',
+    b'beefy',
+    b'befitting',
+    b'beneficial',
+    b'benevolent',
+    b'bent',
+    b'best',
+    b'better',
+    b'bewildered',
+    b'bewitching',
+    b'big',
+    b'billowy',
+    b'bizarre',
+    b'black',
+    b'blithe',
+    b'blue',
+    b'blushing',
+    b'bouncy',
+    b'boundless',
+    b'brainy',
+    b'brash',
+    b'brave',
+    b'brawny',
+    b'brazen',
+    b'breezy',
+    b'brief',
+    b'bright',
+    b'brilliant',
+    b'broad',
+    b'brown',
+    b'bucolic',
+    b'bulky',
+    b'bumpy',
+    b'burgundy',
+    b'burly',
+    b'bustling',
+    b'busy',
+    b'calm',
+    b'capable',
+    b'capricious',
+    b'captivating',
+    b'carefree',
+    b'careful',
+    b'caring',
+    b'carrot',
+    b'ceaseless',
+    b'cerise',
+    b'certain',
+    b'challenging',
+    b'changeable',
+    b'charming',
+    b'cheerful',
+    b'chief',
+    b'chilly',
+    b'chipper',
+    b'classy',
+    b'clean',
+    b'clear',
+    b'clever',
+    b'cloudy',
+    b'coherent',
+    b'colorful',
+    b'colossal',
+    b'comfortable',
+    b'common',
+    b'communicative',
+    b'compassionate',
+    b'complete',
+    b'complex',
+    b'compulsive',
+    b'confused',
+    b'conscientious',
+    b'conscious',
+    b'conservative',
+    b'considerate',
+    b'convivial',
+    b'cooing',
+    b'cool',
+    b'cooperative',
+    b'coordinated',
+    b'courageous',
+    b'courteous',
+    b'crazy',
+    b'creative',
+    b'crispy',
+    b'crooked',
+    b'crowded',
+    b'cuddly',
+    b'cultured',
+    b'cunning',
+    b'curious',
+    b'curly',
+    b'curved',
+    b'curvy',
+    b'cut',
+    b'cute',
+    b'daily',
+    b'damp',
+    b'dapper',
+    b'dashing',
+    b'dazzling',
+    b'dear',
+    b'debonair',
+    b'decisive',
+    b'decorous',
+    b'deep',
+    b'defiant',
+    b'delicate',
+    b'delicious',
+    b'delighted',
+    b'delightful',
+    b'delirious',
+    b'descriptive',
+    b'detached',
+    b'detailed',
+    b'determined',
+    b'different',
+    b'diligent',
+    b'diminutive',
+    b'diplomatic',
+    b'discreet',
+    b'distinct',
+    b'distinctive',
+    b'dramatic',
+    b'dry',
+    b'dynamic',
+    b'dynamite',
+    b'eager',
+    b'early',
+    b'earthy',
+    b'easy',
+    b'easygoing',
+    b'eatable',
+    b'economic',
+    b'ecstatic',
+    b'educated',
+    b'efficacious',
+    b'efficient',
+    b'effortless',
+    b'eight',
+    b'elastic',
+    b'elated',
+    b'electric',
+    b'elegant',
+    b'elfin',
+    b'elite',
+    b'eminent',
+    b'emotional',
+    b'enchanted',
+    b'enchanting',
+    b'encouraging',
+    b'endless',
+    b'energetic',
+    b'enormous',
+    b'entertaining',
+    b'enthusiastic',
+    b'envious',
+    b'epicurean',
+    b'equable',
+    b'equal',
+    b'eternal',
+    b'ethereal',
+    b'evanescent',
+    b'even',
+    b'excellent',
+    b'excited',
+    b'exciting',
+    b'exclusive',
+    b'exotic',
+    b'expensive',
+    b'exquisite',
+    b'extroverted',
+    b'exuberant',
+    b'exultant',
+    b'fabulous',
+    b'fair',
+    b'faithful',
+    b'familiar',
+    b'famous',
+    b'fancy',
+    b'fantastic',
+    b'far',
+    b'fascinated',
+    b'fast',
+    b'fearless',
+    b'female',
+    b'fertile',
+    b'festive',
+    b'few',
+    b'fine',
+    b'first',
+    b'five',
+    b'fixed',
+    b'flamboyant',
+    b'flashy',
+    b'flat',
+    b'flawless',
+    b'flirtatious',
+    b'florid',
+    b'flowery',
+    b'fluffy',
+    b'fluttering',
+    b'foamy',
+    b'foolish',
+    b'foregoing',
+    b'fortunate',
+    b'four',
+    b'frank',
+    b'free',
+    b'frequent',
+    b'fresh',
+    b'friendly',
+    b'full',
+    b'functional',
+    b'funny',
+    b'furry',
+    b'future',
+    b'futuristic',
+    b'fuzzy',
+    b'gabby',
+    b'gainful',
+    b'garrulous',
+    b'general',
+    b'generous',
+    b'gentle',
+    b'giant',
+    b'giddy',
+    b'gifted',
+    b'gigantic',
+    b'gilded',
+    b'glamorous',
+    b'gleaming',
+    b'glorious',
+    b'glossy',
+    b'glowing',
+    b'godly',
+    b'good',
+    b'goofy',
+    b'gorgeous',
+    b'graceful',
+    b'grandiose',
+    b'grateful',
+    b'gratis',
+    b'gray',
+    b'great',
+    b'green',
+    b'gregarious',
+    b'grey',
+    b'groovy',
+    b'guiltless',
+    b'gusty',
+    b'guttural',
+    b'habitual',
+    b'half',
+    b'hallowed',
+    b'halting',
+    b'handsome',
+    b'happy',
+    b'hard',
+    b'hardworking',
+    b'harmonious',
+    b'heady',
+    b'healthy',
+    b'heavenly',
+    b'helpful',
+    b'hilarious',
+    b'historical',
+    b'holistic',
+    b'hollow',
+    b'honest',
+    b'honorable',
+    b'hopeful',
+    b'hospitable',
+    b'hot',
+    b'huge',
+    b'humorous',
+    b'hungry',
+    b'hushed',
+    b'hypnotic',
+    b'illustrious',
+    b'imaginary',
+    b'imaginative',
+    b'immense',
+    b'imminent',
+    b'impartial',
+    b'important',
+    b'imported',
+    b'impossible',
+    b'incandescent',
+    b'inconclusive',
+    b'incredible',
+    b'independent',
+    b'industrious',
+    b'inexpensive',
+    b'innate',
+    b'innocent',
+    b'inquisitive',
+    b'instinctive',
+    b'intellectual',
+    b'intelligent',
+    b'intense',
+    b'interesting',
+    b'internal',
+    b'intuitive',
+    b'inventive',
+    b'invincible',
+    b'jazzy',
+    b'jolly',
+    b'joyful',
+    b'joyous',
+    b'judicious',
+    b'juicy',
+    b'jumpy',
+    b'keen',
+    b'kind',
+    b'kindhearted',
+    b'kindly',
+    b'knotty',
+    b'knowing',
+    b'knowledgeable',
+    b'known',
+    b'laconic',
+    b'large',
+    b'lavish',
+    b'lean',
+    b'learned',
+    b'left',
+    b'legal',
+    b'level',
+    b'light',
+    b'likeable',
+    b'literate',
+    b'little',
+    b'lively',
+    b'living',
+    b'long',
+    b'longing',
+    b'loud',
+    b'lovely',
+    b'loving',
+    b'loyal',
+    b'lucky',
+    b'luminous',
+    b'lush',
+    b'luxuriant',
+    b'luxurious',
+    b'lyrical',
+    b'magenta',
+    b'magical',
+    b'magnificent',
+    b'majestic',
+    b'male',
+    b'mammoth',
+    b'many',
+    b'marvelous',
+    b'massive',
+    b'material',
+    b'mature',
+    b'meandering',
+    b'meaty',
+    b'medical',
+    b'mellow',
+    b'melodic',
+    b'melted',
+    b'merciful',
+    b'mighty',
+    b'miniature',
+    b'miniscule',
+    b'minor',
+    b'minute',
+    b'misty',
+    b'modern',
+    b'modest',
+    b'momentous',
+    b'motionless',
+    b'mountainous',
+    b'mute',
+    b'mysterious',
+    b'narrow',
+    b'natural',
+    b'near',
+    b'neat',
+    b'nebulous',
+    b'necessary',
+    b'neighborly',
+    b'new',
+    b'next',
+    b'nice',
+    b'nifty',
+    b'nimble',
+    b'nine',
+    b'nippy',
+    b'noiseless',
+    b'noisy',
+    b'nonchalant',
+    b'normal',
+    b'numberless',
+    b'numerous',
+    b'nutritious',
+    b'obedient',
+    b'observant',
+    b'obtainable',
+    b'oceanic',
+    b'omniscient',
+    b'one',
+    b'open',
+    b'opposite',
+    b'optimal',
+    b'optimistic',
+    b'opulent',
+    b'orange',
+    b'ordinary',
+    b'organic',
+    b'outgoing',
+    b'outrageous',
+    b'outstanding',
+    b'oval',
+    b'overjoyed',
+    b'overt',
+    b'palatial',
+    b'panoramic',
+    b'parallel',
+    b'passionate',
+    b'past',
+    b'pastoral',
+    b'patient',
+    b'peaceful',
+    b'perfect',
+    b'periodic',
+    b'permissible',
+    b'perpetual',
+    b'persistent',
+    b'petite',
+    b'philosophical',
+    b'physical',
+    b'picturesque',
+    b'pink',
+    b'pioneering',
+    b'piquant',
+    b'plausible',
+    b'pleasant',
+    b'plucky',
+    b'poised',
+    b'polite',
+    b'possible',
+    b'powerful',
+    b'practical',
+    b'precious',
+    b'premium',
+    b'present',
+    b'pretty',
+    b'previous',
+    b'private',
+    b'probable',
+    b'productive',
+    b'profound',
+    b'profuse',
+    b'protective',
+    b'proud',
+    b'psychedelic',
+    b'public',
+    b'pumped',
+    b'purple',
+    b'purring',
+    b'puzzled',
+    b'puzzling',
+    b'quaint',
+    b'quick',
+    b'quicker',
+    b'quickest',
+    b'quiet',
+    b'quirky',
+    b'quixotic',
+    b'quizzical',
+    b'rainy',
+    b'rapid',
+    b'rare',
+    b'rational',
+    b'ready',
+    b'real',
+    b'rebel',
+    b'receptive',
+    b'red',
+    b'reflective',
+    b'regular',
+    b'relaxed',
+    b'reliable',
+    b'relieved',
+    b'remarkable',
+    b'reminiscent',
+    b'reserved',
+    b'resolute',
+    b'resonant',
+    b'resourceful',
+    b'responsible',
+    b'rich',
+    b'ridiculous',
+    b'right',
+    b'rightful',
+    b'ripe',
+    b'ritzy',
+    b'roasted',
+    b'robust',
+    b'romantic',
+    b'roomy',
+    b'round',
+    b'royal',
+    b'ruddy',
+    b'rural',
+    b'rustic',
+    b'sable',
+    b'safe',
+    b'salty',
+    b'same',
+    b'satisfying',
+    b'savory',
+    b'scientific',
+    b'scintillating',
+    b'scrumptious',
+    b'second',
+    b'secret',
+    b'secretive',
+    b'seemly',
+    b'selective',
+    b'sensible',
+    b'separate',
+    b'shaggy',
+    b'shaky',
+    b'shining',
+    b'shiny',
+    b'short',
+    b'shy',
+    b'silent',
+    b'silky',
+    b'silly',
+    b'simple',
+    b'simplistic',
+    b'sincere',
+    b'six',
+    b'sizzling',
+    b'skillful',
+    b'sleepy',
+    b'slick',
+    b'slim',
+    b'smart',
+    b'smiling',
+    b'smooth',
+    b'soaring',
+    b'sociable',
+    b'soft',
+    b'solid',
+    b'sophisticated',
+    b'sparkling',
+    b'special',
+    b'spectacular',
+    b'speedy',
+    b'spicy',
+    b'spiffy',
+    b'spiritual',
+    b'splendid',
+    b'spooky',
+    b'spotless',
+    b'spotted',
+    b'square',
+    b'standing',
+    b'statuesque',
+    b'steadfast',
+    b'steady',
+    b'steep',
+    b'stimulating',
+    b'straight',
+    b'straightforward',
+    b'striking',
+    b'striped',
+    b'strong',
+    b'stunning',
+    b'stupendous',
+    b'sturdy',
+    b'subsequent',
+    b'substantial',
+    b'subtle',
+    b'successful',
+    b'succinct',
+    b'sudden',
+    b'super',
+    b'superb',
+    b'supreme',
+    b'swanky',
+    b'sweet',
+    b'swift',
+    b'sympathetic',
+    b'synonymous',
+    b'talented',
+    b'tall',
+    b'tame',
+    b'tan',
+    b'tangible',
+    b'tangy',
+    b'tasteful',
+    b'tasty',
+    b'telling',
+    b'temporary',
+    b'tempting',
+    b'ten',
+    b'tender',
+    b'terrific',
+    b'tested',
+    b'thankful',
+    b'therapeutic',
+    b'thin',
+    b'thinkable',
+    b'third',
+    b'thoughtful',
+    b'three',
+    b'thrifty',
+    b'tidy',
+    b'tiny',
+    b'toothsome',
+    b'towering',
+    b'tranquil',
+    b'tremendous',
+    b'tricky',
+    b'true',
+    b'truthful',
+    b'two',
+    b'typical',
+    b'ubiquitous',
+    b'ultra',
+    b'unassuming',
+    b'unbiased',
+    b'uncovered',
+    b'understanding',
+    b'understood',
+    b'unequaled',
+    b'unique',
+    b'unusual',
+    b'unwritten',
+    b'upbeat',
+    b'useful',
+    b'utopian',
+    b'utter',
+    b'uttermost',
+    b'valuable',
+    b'various',
+    b'vast',
+    b'verdant',
+    b'vermilion',
+    b'versatile',
+    b'versed',
+    b'victorious',
+    b'vigorous',
+    b'violet',
+    b'vivacious',
+    b'voiceless',
+    b'voluptuous',
+    b'wacky',
+    b'waiting',
+    b'wakeful',
+    b'wandering',
+    b'warm',
+    b'warmhearted',
+    b'wealthy',
+    b'whimsical',
+    b'whispering',
+    b'white',
+    b'whole',
+    b'wholesale',
+    b'whopping',
+    b'wide',
+    b'wiggly',
+    b'wild',
+    b'willing',
+    b'windy',
+    b'winsome',
+    b'wiry',
+    b'wise',
+    b'wistful',
+    b'witty',
+    b'womanly',
+    b'wonderful',
+    b'workable',
+    b'young',
+    b'youthful',
+    b'yummy',
+    b'zany',
+    b'zealous',
+    b'zesty',
+    b'zippy'
 ]
 
 def randomtopicname(ui):
-    if ui.configint("devel", "randomseed"):
-        random.seed(ui.configint("devel", "randomseed"))
-    return random.choice(adjectives) + "-" + random.choice(animals)
+    if ui.configint(b"devel", b"randomseed"):
+        random.seed(ui.configint(b"devel", b"randomseed"))
+    return random.choice(adjectives) + b"-" + random.choice(animals)
diff --git a/hgext3rd/topic/revset.py b/hgext3rd/topic/revset.py
--- a/hgext3rd/topic/revset.py
+++ b/hgext3rd/topic/revset.py
@@ -24,11 +24,11 @@
 revsetpredicate = registrar.revsetpredicate()
 
 def getstringstrict(x, err):
-    if x and x[0] == 'string':
+    if x and x[0] == b'string':
         return x[1]
     raise error.ParseError(err)
 
- at revsetpredicate('topic([string or set])')
+ at revsetpredicate(b'topic([string or set])')
 def topicset(repo, subset, x):
     """All changesets with the specified topic or the topics of the given
     changesets. Without the argument, all changesets with any topic specified.
@@ -36,7 +36,7 @@
     If `string` starts with `re:` the remainder of the name is treated
     as a regular expression.
     """
-    args = revset.getargs(x, 0, 1, 'topic takes one or no arguments')
+    args = revset.getargs(x, 0, 1, b'topic takes one or no arguments')
 
     mutable = revset._notpublic(repo, revset.fullreposet(repo), ())
 
@@ -44,15 +44,15 @@
         return (subset & mutable).filter(lambda r: bool(repo[r].topic()))
 
     try:
-        topic = getstringstrict(args[0], '')
+        topic = getstringstrict(args[0], b'')
     except error.ParseError:
         # not a string, but another revset
         pass
     else:
         kind, pattern, matcher = mkmatcher(topic)
 
-        if topic.startswith('literal:') and pattern not in repo.topics:
-            raise error.RepoLookupError("topic '%s' does not exist" % pattern)
+        if topic.startswith(b'literal:') and pattern not in repo.topics:
+            raise error.RepoLookupError(b"topic '%s' does not exist" % pattern)
 
         def matches(r):
             topic = repo[r].topic()
@@ -64,7 +64,7 @@
 
     s = revset.getset(repo, revset.fullreposet(repo), x)
     topics = {repo[r].topic() for r in s}
-    topics.discard('')
+    topics.discard(b'')
 
     def matches(r):
         if r in s:
@@ -76,20 +76,20 @@
 
     return (subset & mutable).filter(matches)
 
- at revsetpredicate('ngtip([branch])')
+ at revsetpredicate(b'ngtip([branch])')
 def ngtipset(repo, subset, x):
     """The untopiced tip.
 
     Name is horrible so that people change it.
     """
-    args = revset.getargs(x, 1, 1, 'ngtip takes one argument')
+    args = revset.getargs(x, 1, 1, b'ngtip takes one argument')
     # match a specific topic
-    branch = revset.getstring(args[0], 'ngtip requires a string')
-    if branch == '.':
-        branch = repo['.'].branch()
+    branch = revset.getstring(args[0], b'ngtip requires a string')
+    if branch == b'.':
+        branch = repo[b'.'].branch()
     return subset & revset.baseset(destination.ngtip(repo, branch))
 
- at revsetpredicate('stack()')
+ at revsetpredicate(b'stack()')
 def stackset(repo, subset, x):
     """All relevant changes in the current topic,
 
@@ -97,7 +97,7 @@
     unstable changeset after there future parent (as if evolve where already
     run).
     """
-    err = 'stack takes no arguments, it works on current topic'
+    err = b'stack takes no arguments, it works on current topic'
     revset.getargs(x, 0, 0, err)
     topic = None
     branch = None
@@ -107,7 +107,7 @@
         branch = repo[None].branch()
     return revset.baseset(stack.stack(repo, branch=branch, topic=topic)[1:]) & subset
 
-if util.safehasattr(revset, 'subscriptrelations'):
+if util.safehasattr(revset, b'subscriptrelations'):
     def stackrel(repo, subset, x, rel, z, order):
         """This is a revset-flavored implementation of stack aliases.
 
@@ -120,8 +120,8 @@
         if isinstance(z, tuple):
             a, b = revset.getintrange(
                 z,
-                'relation subscript must be an integer or a range',
-                'relation subscript bounds must be integers',
+                b'relation subscript must be an integer or a range',
+                b'relation subscript bounds must be integers',
                 None, None)
         else:
             a = b = z
@@ -159,12 +159,12 @@
 
         return subset & revset.baseset(revs)
 
-    revset.subscriptrelations['stack'] = stackrel
-    revset.subscriptrelations['s'] = stackrel
+    revset.subscriptrelations[b'stack'] = stackrel
+    revset.subscriptrelations[b's'] = stackrel
 
     def topicrel(repo, subset, x, *args):
         subset &= topicset(repo, subset, x)
         return revset.generationsrel(repo, subset, x, *args)
 
-    revset.subscriptrelations['topic'] = topicrel
-    revset.subscriptrelations['t'] = topicrel
+    revset.subscriptrelations[b'topic'] = topicrel
+    revset.subscriptrelations[b't'] = topicrel
diff --git a/hgext3rd/topic/stack.py b/hgext3rd/topic/stack.py
--- a/hgext3rd/topic/stack.py
+++ b/hgext3rd/topic/stack.py
@@ -25,7 +25,7 @@
     username = None
     if user:
         # user is of form "abc <abc at xyz.com>"
-        username = user.split('<')[0]
+        username = user.split(b'<')[0]
         if not username:
             # assuming user is of form "<abc at xyz.com>"
             if len(user) > 1:
@@ -44,10 +44,10 @@
     """
     phasesets = repo._phasecache._phasesets
     if not phasesets or None in phasesets[phases.draft:]:
-        return repo.revs('(not public()) - obsolete()')
+        return repo.revs(b'(not public()) - obsolete()')
 
     result = set.union(*phasesets[phases.draft:])
-    result -= obsolete.getrevs(repo, 'obsolete')
+    result -= obsolete.getrevs(repo, b'obsolete')
     return result
 
 class stack(object):
@@ -62,13 +62,13 @@
         subset = _stackcandidates(repo)
 
         if topic is not None and branch is not None:
-            raise error.ProgrammingError('both branch and topic specified (not defined yet)')
+            raise error.ProgrammingError(b'both branch and topic specified (not defined yet)')
         elif topic is not None:
-            trevs = repo.revs("%ld and topic(%s)", subset, topic)
+            trevs = repo.revs(b"%ld and topic(%s)", subset, topic)
         elif branch is not None:
-            trevs = repo.revs("%ld and branch(%s) - topic()", subset, branch)
+            trevs = repo.revs(b"%ld and branch(%s) - topic()", subset, branch)
         else:
-            raise error.ProgrammingError('neither branch and topic specified (not defined yet)')
+            raise error.ProgrammingError(b'neither branch and topic specified (not defined yet)')
         self._revs = trevs
 
     def __iter__(self):
@@ -168,7 +168,7 @@
         if revs:
             pt1 = self._repo[revs[0]].p1()
         else:
-            pt1 = self._repo['.']
+            pt1 = self._repo[b'.']
 
         if pt1.obsolete():
             pt1 = self._repo[_singlesuccessor(self._repo, pt1)]
@@ -196,15 +196,15 @@
         if revs:
             minroot = [min(r for r in revs if not deps[r])]
             try:
-                dest = destutil.destmerge(self._repo, action='rebase',
+                dest = destutil.destmerge(self._repo, action=b'rebase',
                                           sourceset=minroot,
                                           onheadcheck=False)
-                return len(self._repo.revs("only(%d, %ld)", dest, minroot))
+                return len(self._repo.revs(b"only(%d, %ld)", dest, minroot))
             except error.NoMergeDestAbort:
                 return 0
             except error.ManyMergeDestAbort as exc:
                 # XXX we should make it easier for upstream to provide the information
-                self.behinderror = str(exc).split('-', 1)[0].rstrip()
+                self.behinderror = str(exc).split(b'-', 1)[0].rstrip()
                 return -1
         return 0
 
@@ -216,68 +216,68 @@
         return branches
 
 def labelsgen(prefix, parts):
-    fmt = prefix + '.%s'
-    return prefix + ' ' + ' '.join(fmt % p.replace(' ', '-') for p in parts)
+    fmt = prefix + b'.%s'
+    return prefix + b' ' + b' '.join(fmt % p.replace(b' ', b'-') for p in parts)
 
 def showstack(ui, repo, branch=None, topic=None, opts=None):
     if opts is None:
         opts = {}
 
     if topic is not None and branch is not None:
-        msg = 'both branch and topic specified [%s]{%s}(not defined yet)'
+        msg = b'both branch and topic specified [%s]{%s}(not defined yet)'
         msg %= (branch, topic)
         raise error.ProgrammingError(msg)
     elif topic is not None:
-        prefix = 's'
+        prefix = b's'
         if topic not in repo.topics:
-            raise error.Abort(_('cannot resolve "%s": no such topic found') % topic)
+            raise error.Abort(_(b'cannot resolve "%s": no such topic found') % topic)
     elif branch is not None:
-        prefix = 's'
+        prefix = b's'
     else:
-        raise error.ProgrammingError('neither branch and topic specified (not defined yet)')
+        raise error.ProgrammingError(b'neither branch and topic specified (not defined yet)')
 
-    fm = ui.formatter('topicstack', opts)
+    fm = ui.formatter(b'topicstack', opts)
     prev = None
     entries = []
     idxmap = {}
 
-    label = 'topic'
+    label = b'topic'
     if topic == repo.currenttopic:
-        label = 'topic.active'
+        label = b'topic.active'
 
     st = stack(repo, branch, topic)
     if topic is not None:
-        fm.plain(_('### topic: %s')
+        fm.plain(_(b'### topic: %s')
                  % ui.label(topic, label),
-                 label='stack.summary.topic')
+                 label=b'stack.summary.topic')
 
         if 1 < len(st.heads):
-            fm.plain(' (')
-            fm.plain('%d heads' % len(st.heads),
-                     label='stack.summary.headcount.multiple')
-            fm.plain(')')
-        fm.plain('\n')
-    fm.plain(_('### target: %s (branch)')
-             % '+'.join(st.branches), # XXX handle multi branches
-             label='stack.summary.branches')
+            fm.plain(b' (')
+            fm.plain(b'%d heads' % len(st.heads),
+                     label=b'stack.summary.headcount.multiple')
+            fm.plain(b')')
+        fm.plain(b'\n')
+    fm.plain(_(b'### target: %s (branch)')
+             % b'+'.join(st.branches), # XXX handle multi branches
+             label=b'stack.summary.branches')
     if topic is None:
         if 1 < len(st.heads):
-            fm.plain(' (')
-            fm.plain('%d heads' % len(st.heads),
-                     label='stack.summary.headcount.multiple')
-            fm.plain(')')
+            fm.plain(b' (')
+            fm.plain(b'%d heads' % len(st.heads),
+                     label=b'stack.summary.headcount.multiple')
+            fm.plain(b')')
     else:
         if st.behindcount == -1:
-            fm.plain(', ')
-            fm.plain('ambiguous rebase destination - %s' % st.behinderror,
-                     label='stack.summary.behinderror')
+            fm.plain(b', ')
+            fm.plain(b'ambiguous rebase destination - %s' % st.behinderror,
+                     label=b'stack.summary.behinderror')
         elif st.behindcount:
-            fm.plain(', ')
-            fm.plain('%d behind' % st.behindcount, label='stack.summary.behindcount')
-    fm.plain('\n')
+            fm.plain(b', ')
+            fm.plain(b'%d behind' % st.behindcount, label=b'stack.summary.behindcount')
+    fm.plain(b'\n')
 
     if not st:
-        fm.plain(_("(stack is empty)\n"))
+        fm.plain(_(b"(stack is empty)\n"))
 
     st = stack(repo, branch=branch, topic=topic)
     for idx, r in enumerate(st, 0):
@@ -316,40 +316,40 @@
 
         symbol = None
         states = []
-        if opts.get('children'):
-            expr = 'children(%d) and merge() - %ld'
+        if opts.get(b'children'):
+            expr = b'children(%d) and merge() - %ld'
             revisions = repo.revs(expr, ctx.rev(), st._revs)
             if len(revisions) > 0:
-                states.append('external-children')
+                states.append(b'external-children')
 
         if ctx.orphan():
-            symbol = '$'
-            states.append('orphan')
+            symbol = b'$'
+            states.append(b'orphan')
 
         if ctx.contentdivergent():
-            symbol = '$'
-            states.append('content divergent')
+            symbol = b'$'
+            states.append(b'content divergent')
 
         if ctx.phasedivergent():
-            symbol = '$'
-            states.append('phase divergent')
+            symbol = b'$'
+            states.append(b'phase divergent')
 
-        iscurrentrevision = repo.revs('%d and parents()', ctx.rev())
+        iscurrentrevision = repo.revs(b'%d and parents()', ctx.rev())
         if iscurrentrevision:
-            symbol = '@'
-            states.append('current')
+            symbol = b'@'
+            states.append(b'current')
 
         if not isentry:
-            symbol = '^'
+            symbol = b'^'
             # "base" is kind of a "ghost" entry
-            states.append('base')
+            states.append(b'base')
 
         # none of the above if statments get executed
         if not symbol:
-            symbol = ':'
+            symbol = b':'
 
         if not states:
-            states.append('clean')
+            states.append(b'clean')
 
         states.sort()
 
@@ -367,22 +367,22 @@
                 spacewidth = 2 + 40
             # s# alias width
             spacewidth += 2
-            fm.plain(' ' * spacewidth)
+            fm.plain(b' ' * spacewidth)
         else:
-            fm.write('stack_index', '%s%%d' % prefix, idx,
-                     label=labelsgen('stack.index', states))
+            fm.write(b'stack_index', b'%s%%d' % prefix, idx,
+                     label=labelsgen(b'stack.index', states))
             if ui.verbose:
-                fm.write('node', '(%s)', fm.hexfunc(ctx.node()),
-                         label=labelsgen('stack.shortnode', states))
+                fm.write(b'node', b'(%s)', fm.hexfunc(ctx.node()),
+                         label=labelsgen(b'stack.shortnode', states))
             else:
                 fm.data(node=fm.hexfunc(ctx.node()))
-        fm.write('symbol', '%s', symbol,
-                 label=labelsgen('stack.state', states))
-        fm.plain(' ')
-        fm.write('desc', '%s', ctx.description().splitlines()[0],
-                 label=labelsgen('stack.desc', states))
-        fm.condwrite(states != ['clean'] and idx is not None, 'state',
-                     ' (%s)', fm.formatlist(states, 'stack.state'),
-                     label=labelsgen('stack.state', states))
-        fm.plain('\n')
+        fm.write(b'symbol', b'%s', symbol,
+                 label=labelsgen(b'stack.state', states))
+        fm.plain(b' ')
+        fm.write(b'desc', b'%s', ctx.description().splitlines()[0],
+                 label=labelsgen(b'stack.desc', states))
+        fm.condwrite(states != [b'clean'] and idx is not None, b'state',
+                     b' (%s)', fm.formatlist(states, b'stack.state'),
+                     label=labelsgen(b'stack.state', states))
+        fm.plain(b'\n')
     fm.end()
diff --git a/hgext3rd/topic/topicmap.py b/hgext3rd/topic/topicmap.py
--- a/hgext3rd/topic/topicmap.py
+++ b/hgext3rd/topic/topicmap.py
@@ -16,22 +16,22 @@
     common,
 )
 
-basefilter = set(['base', 'immutable'])
+basefilter = set([b'base', b'immutable'])
 def topicfilter(name):
     """return a "topic" version of a filter level"""
     if name in basefilter:
         return name
     elif name is None:
         return None
-    elif name.endswith('-topic'):
+    elif name.endswith(b'-topic'):
         return name
     else:
-        return name + '-topic'
+        return name + b'-topic'
 
 def istopicfilter(filtername):
     if filtername is None:
         return False
-    return filtername.endswith('-topic')
+    return filtername.endswith(b'-topic')
 
 def gettopicrepo(repo):
     if not common.hastopicext(repo):
@@ -61,8 +61,8 @@
         if newfilter not in funcmap:
             funcmap[newfilter] = revsfunc
             partialmap[newfilter] = base
-    funcmap['unfiltered-topic'] = lambda repo: frozenset()
-    partialmap['unfiltered-topic'] = 'visible-topic'
+    funcmap[b'unfiltered-topic'] = lambda repo: frozenset()
+    partialmap[b'unfiltered-topic'] = b'visible-topic'
 
 def _phaseshash(repo, maxrev):
     """uniq ID for a phase matching a set of rev"""
@@ -80,7 +80,7 @@
     if revs:
         s = hashlib.sha1()
         for rev in revs:
-            s.update('%s;' % rev)
+            s.update(b'%s;' % rev)
         key = s.digest()
     return key
 
@@ -88,8 +88,8 @@
     """call at uisetup time to install various wrappings"""
     _setuptopicfilter(ui)
     _wrapbmcache(ui)
-    extensions.wrapfunction(changegroup.cg1unpacker, 'apply', cgapply)
-    extensions.wrapfunction(cmdutil, 'commitstatus', commitstatus)
+    extensions.wrapfunction(changegroup.cg1unpacker, b'apply', cgapply)
+    extensions.wrapfunction(cmdutil, b'commitstatus', commitstatus)
 
 def cgapply(orig, self, repo, *args, **kwargs):
     """make sure a topicmap is used when applying a changegroup"""
@@ -100,8 +100,8 @@
     # wrap commit status use the topic branch heads
     ctx = repo[node]
     if ctx.topic() and ctx.branch() == branch:
-        subbranch = "%s:%s" % (branch, ctx.topic())
-        bheads = repo.branchheads("%s:%s" % (subbranch, ctx.topic()))
+        subbranch = b"%s:%s" % (branch, ctx.topic())
+        bheads = repo.branchheads(b"%s:%s" % (subbranch, ctx.topic()))
 
     ret = orig(repo, node, branch, bheads=bheads, opts=opts)
 
@@ -112,10 +112,10 @@
         return ret
     parents = ctx.parents()
 
-    if (not opts.get('amend') and bheads and node not in bheads and not
+    if (not opts.get(b'amend') and bheads and node not in bheads and not
         [x for x in parents if x.node() in bheads and x.branch() == branch]):
-        repo.ui.status(_("(consider using topic for lightweight branches."
-                         " See 'hg help topic')\n"))
+        repo.ui.status(_(b"(consider using topic for lightweight branches."
+                         b" See 'hg help topic')\n"))
 
     return ret
 
@@ -133,10 +133,10 @@
         def _wrapupdatebmcachemethod(orig, self, repo):
             # pass in the bound method as the original
             return _wrapupdatebmcache(orig.__get__(self), repo)
-        extensions.wrapfunction(branchmap.BranchMapCache, 'updatecache', _wrapupdatebmcachemethod)
+        extensions.wrapfunction(branchmap.BranchMapCache, b'updatecache', _wrapupdatebmcachemethod)
     except AttributeError:
         # Mercurial 4.8 and before
-        extensions.wrapfunction(branchmap, 'updatecache', _wrapupdatebmcache)
+        extensions.wrapfunction(branchmap, b'updatecache', _wrapupdatebmcache)
 
 
 def _wrapupdatebmcache(orig, repo):
@@ -170,7 +170,7 @@
 
     def copy(self):
         """return an deep copy of the branchcache object"""
-        if util.safehasattr(self, '_entries'):
+        if util.safehasattr(self, b'_entries'):
             _entries = self._entries
         else:
             # hg <= 4.9 (624d6683c705, b137a6793c51)
@@ -180,17 +180,17 @@
         new.phaseshash = self.phaseshash
         return new
 
-    def branchtip(self, branch, topic=''):
+    def branchtip(self, branch, topic=b''):
         '''Return the tipmost open head on branch head, otherwise return the
         tipmost closed head on branch.
         Raise KeyError for unknown branch.'''
         if topic:
-            branch = '%s:%s' % (branch, topic)
+            branch = b'%s:%s' % (branch, topic)
         return super(_topiccache, self).branchtip(branch)
 
-    def branchheads(self, branch, closed=False, topic=''):
+    def branchheads(self, branch, closed=False, topic=b''):
         if topic:
-            branch = '%s:%s' % (branch, topic)
+            branch = b'%s:%s' % (branch, topic)
         return super(_topiccache, self).branchheads(branch, closed=closed)
 
     def validfor(self, repo):
@@ -230,13 +230,13 @@
 
         def branchinfo(r, changelog=None):
             info = oldgetbranchinfo(r)
-            topic = ''
+            topic = b''
             ctx = unfi[r]
             if ctx.mutable():
                 topic = ctx.topic()
             branch = info[0]
             if topic:
-                branch = '%s:%s' % (branch, topic)
+                branch = b'%s:%s' % (branch, topic)
             return (branch, info[1])
         try:
             unfi.revbranchcache().branchinfo = branchinfo


More information about the Mercurial-devel mailing list