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

comparison mercurial/cmdutil.py @ 43077:687b865b95ad

formatting: byteify all mercurial/ and hgext/ string literals Done with python3.7 contrib/byteify-strings.py -i $(hg files 'set:mercurial/**.py - mercurial/thirdparty/** + hgext/**.py - hgext/fsmonitor/pywatchman/** - mercurial/__init__.py') black -l 80 -t py33 -S $(hg files 'set:**.py - mercurial/thirdparty/** - "contrib/python-zstandard/**" - hgext/fsmonitor/pywatchman/**') # skip-blame mass-reformatting only Differential Revision: https://phab.mercurial-scm.org/D6972

author	Augie Fackler <augie@google.com>
date	Sun, 06 Oct 2019 09:48:39 -0400
parents	2372284d9457
children	eef9a2d67051

comparison

equal deleted inserted replaced

-:2372284d9457
+:687b865b95ad
 stringio = util.stringio
 # templates of common command options
 dryrunopts = [
-('n', 'dry-run', None, _('do not perform actions, just print output')),
+(b'n', b'dry-run', None, _(b'do not perform actions, just print output')),
 ]
 confirmopts = [
-('', 'confirm', None, _('ask before applying actions')),
+(b'', b'confirm', None, _(b'ask before applying actions')),
 ]
 remoteopts = [
-('e', 'ssh', '', _('specify ssh command to use'), _('CMD')),
+(b'e', b'ssh', b'', _(b'specify ssh command to use'), _(b'CMD')),
 (
-'',
+b'',
-'remotecmd',
+b'remotecmd',
-'',
+b'',
-_('specify hg command to run on the remote side'),
+_(b'specify hg command to run on the remote side'),
-_('CMD'),
+_(b'CMD'),
 ),
 (
-'',
+b'',
-'insecure',
+b'insecure',
 None,
-_('do not verify server certificate (ignoring web.cacerts config)'),
+_(b'do not verify server certificate (ignoring web.cacerts config)'),
 ),
 ]
 walkopts = [
 (
-'I',
+b'I',
-'include',
+b'include',
 [],
-_('include names matching the given patterns'),
+_(b'include names matching the given patterns'),
-_('PATTERN'),
+_(b'PATTERN'),
 ),
 (
-'X',
+b'X',
-'exclude',
+b'exclude',
 [],
-_('exclude names matching the given patterns'),
+_(b'exclude names matching the given patterns'),
-_('PATTERN'),
+_(b'PATTERN'),
 ),
 ]
 commitopts = [
-('m', 'message', '', _('use text as commit message'), _('TEXT')),
+(b'm', b'message', b'', _(b'use text as commit message'), _(b'TEXT')),
-('l', 'logfile', '', _('read commit message from file'), _('FILE')),
+(b'l', b'logfile', b'', _(b'read commit message from file'), _(b'FILE')),
 ]
 commitopts2 = [
-('d', 'date', '', _('record the specified date as commit date'), _('DATE')),
+(
-('u', 'user', '', _('record the specified user as committer'), _('USER')),
+b'd',
+b'date',
+b'',
+_(b'record the specified date as commit date'),
+_(b'DATE'),
+),
+(
+b'u',
+b'user',
+b'',
+_(b'record the specified user as committer'),
+_(b'USER'),
+),
 ]
 commitopts3 = [
 (b'D', b'currentdate', None, _(b'record the current date as commit date')),
 (b'U', b'currentuser', None, _(b'record the current user as committer')),
 ]
 formatteropts = [
-('T', 'template', '', _('display with template'), _('TEMPLATE')),
+(b'T', b'template', b'', _(b'display with template'), _(b'TEMPLATE')),
 ]
 templateopts = [
 (
-'',
+b'',
-'style',
+b'style',
-'',
+b'',
-_('display using template map file (DEPRECATED)'),
+_(b'display using template map file (DEPRECATED)'),
-_('STYLE'),
+_(b'STYLE'),
 ),
-('T', 'template', '', _('display with template'), _('TEMPLATE')),
+(b'T', b'template', b'', _(b'display with template'), _(b'TEMPLATE')),
 ]
 logopts = [
-('p', 'patch', None, _('show patch')),
+(b'p', b'patch', None, _(b'show patch')),
-('g', 'git', None, _('use git extended diff format')),
+(b'g', b'git', None, _(b'use git extended diff format')),
-('l', 'limit', '', _('limit number of changes displayed'), _('NUM')),
+(b'l', b'limit', b'', _(b'limit number of changes displayed'), _(b'NUM')),
-('M', 'no-merges', None, _('do not show merges')),
+(b'M', b'no-merges', None, _(b'do not show merges')),
-('', 'stat', None, _('output diffstat-style summary of changes')),
+(b'', b'stat', None, _(b'output diffstat-style summary of changes')),
-('G', 'graph', None, _("show the revision DAG")),
+(b'G', b'graph', None, _(b"show the revision DAG")),
 ] + templateopts
 diffopts = [
-('a', 'text', None, _('treat all files as text')),
+(b'a', b'text', None, _(b'treat all files as text')),
-('g', 'git', None, _('use git extended diff format')),
+(b'g', b'git', None, _(b'use git extended diff format')),
-('', 'binary', None, _('generate binary diffs in git mode (default)')),
+(b'', b'binary', None, _(b'generate binary diffs in git mode (default)')),
-('', 'nodates', None, _('omit dates from diff headers')),
+(b'', b'nodates', None, _(b'omit dates from diff headers')),
 ]
 diffwsopts = [
 (
-'w',
+b'w',
-'ignore-all-space',
+b'ignore-all-space',
 None,
-_('ignore white space when comparing lines'),
+_(b'ignore white space when comparing lines'),
 ),
 (
-'b',
+b'b',
-'ignore-space-change',
+b'ignore-space-change',
 None,
-_('ignore changes in the amount of white space'),
+_(b'ignore changes in the amount of white space'),
 ),
 (
-'B',
+b'B',
-'ignore-blank-lines',
+b'ignore-blank-lines',
 None,
-_('ignore changes whose lines are all blank'),
+_(b'ignore changes whose lines are all blank'),
 ),
 (
-'Z',
+b'Z',
-'ignore-space-at-eol',
+b'ignore-space-at-eol',
 None,
-_('ignore changes in whitespace at EOL'),
+_(b'ignore changes in whitespace at EOL'),
 ),
 ]
 diffopts2 = (
 [
-('', 'noprefix', None, _('omit a/ and b/ prefixes from filenames')),
+(b'', b'noprefix', None, _(b'omit a/ and b/ prefixes from filenames')),
 (
-'p',
+b'p',
-'show-function',
+b'show-function',
 None,
-_('show which function each change is in'),
+_(b'show which function each change is in'),
 ),
-('', 'reverse', None, _('produce a diff that undoes the changes')),
+(b'', b'reverse', None, _(b'produce a diff that undoes the changes')),
 ]
 + diffwsopts
 + [
-('U', 'unified', '', _('number of lines of context to show'), _('NUM')),
+(
-('', 'stat', None, _('output diffstat-style summary of changes')),
+b'U',
-('', 'root', '', _('produce diffs relative to subdirectory'), _('DIR')),
+b'unified',
+b'',
+_(b'number of lines of context to show'),
+_(b'NUM'),
+),
+(b'', b'stat', None, _(b'output diffstat-style summary of changes')),
+(
+b'',
+b'root',
+b'',
+_(b'produce diffs relative to subdirectory'),
+_(b'DIR'),
+),
 ]
 )
 mergetoolopts = [
-('t', 'tool', '', _('specify merge tool'), _('TOOL')),
+(b't', b'tool', b'', _(b'specify merge tool'), _(b'TOOL')),
 ]
 similarityopts = [
 (
-'s',
+b's',
-'similarity',
+b'similarity',
-'',
+b'',
-_('guess renamed files by similarity (0<=s<=100)'),
+_(b'guess renamed files by similarity (0<=s<=100)'),
-_('SIMILARITY'),
+_(b'SIMILARITY'),
 )
 ]
-subrepoopts = [('S', 'subrepos', None, _('recurse into subrepositories'))]
+subrepoopts = [(b'S', b'subrepos', None, _(b'recurse into subrepositories'))]
 debugrevlogopts = [
-('c', 'changelog', False, _('open changelog')),
+(b'c', b'changelog', False, _(b'open changelog')),
-('m', 'manifest', False, _('open manifest')),
+(b'm', b'manifest', False, _(b'open manifest')),
-('', 'dir', '', _('open directory manifest')),
+(b'', b'dir', b'', _(b'open directory manifest')),
 ]
 # special string such that everything below this line will be ingored in the
 # editor text
-_linebelow = "^HG: ------------------------ >8 ------------------------$"
+_linebelow = b"^HG: ------------------------ >8 ------------------------$"
 def resolvecommitoptions(ui, opts):
 """modify commit options dict to handle related options
 The return value indicates that ``rewrite.update-timestamp`` is the reason
 the ``date`` option is set.
 """
-if opts.get('date') and opts.get('currentdate'):
+if opts.get(b'date') and opts.get(b'currentdate'):
 raise error.Abort(
-_('--date and --currentdate are mutually ' 'exclusive')
+_(b'--date and --currentdate are mutually ' b'exclusive')
 )
 if opts.get(b'user') and opts.get(b'currentuser'):
 raise error.Abort(
-_('--user and --currentuser are mutually ' 'exclusive')
+_(b'--user and --currentuser are mutually ' b'exclusive')
 )
 datemaydiffer = False  # date-only change should be ignored?
 if opts.get(b'currentdate'):
 opts[b'date'] = b'%d %d' % dateutil.makedate()
 elif (
-not opts.get('date')
+not opts.get(b'date')
-and ui.configbool('rewrite', 'update-timestamp')
+and ui.configbool(b'rewrite', b'update-timestamp')
-and opts.get('currentdate') is None
+and opts.get(b'currentdate') is None
 ):
 opts[b'date'] = b'%d %d' % dateutil.makedate()
 datemaydiffer = True
 if opts.get(b'currentuser'):
 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 len(note) > 255:
 raise error.Abort(_(b"cannot store a note of more than 255 bytes"))
 )
 return newlyaddedandmodifiedfiles, alsorestore
 def parsealiases(cmd):
-return cmd.split("|")
+return cmd.split(b"|")
 def setupwrapcolorwrite(ui):
 # wrap ui.write so diff output can be labeled/colorized
 def wrapwrite(orig, *args, **kw):
-label = kw.pop(r'label', '')
+label = kw.pop(r'label', b'')
 for chunk, l in patch.difflabel(lambda: args):
 orig(chunk, label=label + l)
 oldwrite = ui.write
 return crecordmod.filterpatch(
 ui, originalhunks, recordfn, operation
 )
 except crecordmod.fallbackerror as e:
-ui.warn('%s\n' % e.message)
+ui.warn(b'%s\n' % e.message)
-ui.warn(_('falling back to text mode\n'))
+ui.warn(_(b'falling back to text mode\n'))
 return patch.filterpatch(ui, originalhunks, match, operation)
 def recordfilter(ui, originalhunks, match, operation=None):
 *operation* is used for to build ui messages to indicate the user what
 kind of filtering they are doing: reverting, committing, shelving, etc.
 (see patch.filterpatch).
 """
 usecurses = crecordmod.checkcurses(ui)
-testfile = ui.config('experimental', 'crecordtest')
+testfile = ui.config(b'experimental', b'crecordtest')
 oldwrite = setupwrapcolorwrite(ui)
 try:
 newchunks, newopts = filterchunks(
 ui, originalhunks, usecurses, testfile, match, operation
 )
 ui, repo, commitfunc, cmdsuggest, backupall, filterfn, *pats, **opts
 ):
 opts = pycompat.byteskwargs(opts)
 if not ui.interactive():
 if cmdsuggest:
-msg = _('running non-interactively, use %s instead') % cmdsuggest
+msg = _(b'running non-interactively, use %s instead') % cmdsuggest
 else:
-msg = _('running non-interactively')
+msg = _(b'running non-interactively')
 raise error.Abort(msg)
 # make sure username is set before going interactive
-if not opts.get('user'):
+if not opts.get(b'user'):
 ui.username()  # raise exception, username not provided
 def recordfunc(ui, repo, message, match, opts):
 """This is generic record driver.
 working directory is restored to its original state.
 In the end we'll record interesting changes, and everything else
 will be left in place, so the user can continue working.
 """
-if not opts.get('interactive-unshelve'):
+if not opts.get(b'interactive-unshelve'):
 checkunfinished(repo, commit=True)
 wctx = repo[None]
 merge = len(wctx.parents()) > 1
 if merge:
 raise error.Abort(
 _(
-'cannot partially commit a merge '
+b'cannot partially commit a merge '
-'(use "hg commit" instead)'
+b'(use "hg commit" instead)'
 )
 )
 def fail(f, msg):
-raise error.Abort('%s: %s' % (f, msg))
+raise error.Abort(b'%s: %s' % (f, msg))
-force = opts.get('force')
+force = opts.get(b'force')
 if not force:
 vdirs = []
 match = matchmod.badmatch(match, fail)
 match.explicitdir = vdirs.append
 repo.checkcommitpatterns(wctx, vdirs, match, status, fail)
 diffopts = patch.difffeatureopts(
 ui,
 opts=opts,
 whitespace=True,
-section='commands',
+section=b'commands',
-configprefix='commit.interactive.',
+configprefix=b'commit.interactive.',
 )
 diffopts.nodates = True
 diffopts.git = True
 diffopts.showfunc = True
 originaldiff = patch.diff(repo, changes=status, opts=diffopts)
 # 1. filter patch, since we are intending to apply subset of it
 try:
 chunks, newopts = filterfn(ui, originalchunks, match)
 except error.PatchError as err:
-raise error.Abort(_('error parsing patch: %s') % err)
+raise error.Abort(_(b'error parsing patch: %s') % err)
 opts.update(newopts)
 # We need to keep a backup of files that have been newly added and
 # modified during the recording process because there is a previous
 # version without the edit in the workdir. We also will need to restore
 pass
 changed = status.modified + status.added + status.removed
 newfiles = [f for f in changed if f in contenders]
 if not newfiles:
-ui.status(_('no changes to record\n'))
+ui.status(_(b'no changes to record\n'))
 return 0
 modified = set(status.modified)
 # 2. backup changed files, so we can restore them in the end
 for f in newfiles
 if f in modified or f in newlyaddedandmodifiedfiles
 ]
 backups = {}
 if tobackup:
-backupdir = repo.vfs.join('record-backups')
+backupdir = repo.vfs.join(b'record-backups')
 try:
 os.mkdir(backupdir)
 except OSError as err:
 if err.errno != errno.EEXIST:
 raise
 try:
 # backup continues
 for f in tobackup:
 fd, tmpname = pycompat.mkstemp(
-prefix=f.replace('/', '_') + '.', dir=backupdir
+prefix=f.replace(b'/', b'_') + b'.', dir=backupdir
 )
 os.close(fd)
-ui.debug('backup %r as %r\n' % (f, tmpname))
+ui.debug(b'backup %r as %r\n' % (f, tmpname))
 util.copyfile(repo.wjoin(f), tmpname, copystat=True)
 backups[f] = tmpname
 fp = stringio()
 for c in chunks:
 c.write(fp)
 dopatch = fp.tell()
 fp.seek(0)
 # 2.5 optionally review / modify patch in text editor
-if opts.get('review', False):
+if opts.get(b'review', False):
 patchtext = (
 crecordmod.diffhelptext
 + crecordmod.patchhelptext
 + fp.read()
 )
 reviewedpatch = ui.edit(
-patchtext, "", action="diff", repopath=repo.path
+patchtext, b"", action=b"diff", repopath=repo.path
 )
 fp.truncate(0)
 fp.write(reviewedpatch)
 fp.seek(0)
 )
 # 3b. (apply)
 if dopatch:
 try:
-ui.debug('applying patch\n')
+ui.debug(b'applying patch\n')
 ui.debug(fp.getvalue())
 patch.internalpatch(ui, repo, fp, 1, eolmode=None)
 except error.PatchError as err:
 raise error.Abort(pycompat.bytestr(err))
 del fp
 finally:
 # 5. finally restore backed-up files
 try:
 dirstate = repo.dirstate
 for realname, tmpname in backups.iteritems():
-ui.debug('restoring %r to %r\n' % (tmpname, realname))
+ui.debug(b'restoring %r to %r\n' % (tmpname, realname))
-if dirstate[realname] == 'n':
+if dirstate[realname] == b'n':
 # without normallookup, restoring timestamp
 # may cause partially committed files
 # to be treated as unmodified
 dirstate.normallookup(realname)
 there.
 """
 # the filename contains a path separator, it means it's not the direct
 # child of this directory
-if '/' in filename:
+if b'/' in filename:
-subdir, filep = filename.split('/', 1)
+subdir, filep = filename.split(b'/', 1)
 # does the dirnode object for subdir exists
 if subdir not in self.subdirs:
 subdirpath = pathutil.join(self.path, subdir)
 self.subdirs[subdir] = dirnode(subdirpath)
 onlyst = self.statuses.pop()
 # Making sure we terse only when the status abbreviation is
 # passed as terse argument
 if onlyst in terseargs:
-yield onlyst, self.path + '/'
+yield onlyst, self.path + b'/'
 return
 # add the files to status list
 for st, fpath in self.iterfilepaths():
 yield st, fpath
 The function makes a tree of objects of dirnode class, and at each node it
 stores the information required to know whether we can terse a certain
 directory or not.
 """
 # the order matters here as that is used to produce final list
-allst = ('m', 'a', 'r', 'd', 'u', 'i', 'c')
+allst = (b'm', b'a', b'r', b'd', b'u', b'i', b'c')
 # checking the argument validity
 for s in pycompat.bytestr(terseargs):
 if s not in allst:
-raise error.Abort(_("'%s' not recognized") % s)
+raise error.Abort(_(b"'%s' not recognized") % s)
 # creating a dirnode object for the root of the repo
-rootobj = dirnode('')
+rootobj = dirnode(b'')
 pstatus = (
-'modified',
+b'modified',
-'added',
+b'added',
-'deleted',
+b'deleted',
-'clean',
+b'clean',
-'unknown',
+b'unknown',
-'ignored',
+b'ignored',
-'removed',
+b'removed',
 )
 tersedict = {}
 for attrname in pstatus:
 statuschar = attrname[0:1]
 def _commentlines(raw):
 '''Surround lineswith a comment char and a new line'''
 lines = raw.splitlines()
-commentedlines = ['# %s' % line for line in lines]
+commentedlines = [b'# %s' % line for line in lines]
-return '\n'.join(commentedlines) + '\n'
+return b'\n'.join(commentedlines) + b'\n'
 def _conflictsmsg(repo):
 mergestate = mergemod.mergestate.read(repo)
 if not mergestate.active():
 return
 m = scmutil.match(repo[None])
 unresolvedlist = [f for f in mergestate.unresolved() if m(f)]
 if unresolvedlist:
-mergeliststr = '\n'.join(
+mergeliststr = b'\n'.join(
 [
-'    %s' % util.pathto(repo.root, encoding.getcwd(), path)
+b'    %s' % util.pathto(repo.root, encoding.getcwd(), path)
 for path in sorted(unresolvedlist)
 ]
 )
 msg = (
 _(
 To mark files as resolved:  hg resolve --mark FILE'''
 )
 % mergeliststr
 )
 else:
-msg = _('No unresolved merge conflicts.')
+msg = _(b'No unresolved merge conflicts.')
 return _commentlines(msg)
 def morestatus(repo, fm):
 statetuple = statemod.getrepostate(repo)
-label = 'status.morestatus'
+label = b'status.morestatus'
 if statetuple:
 state, helpfulmsg = statetuple
-statemsg = _('The repository is in an unfinished *%s* state.') % state
+statemsg = _(b'The repository is in an unfinished *%s* state.') % state
-fm.plain('%s\n' % _commentlines(statemsg), label=label)
+fm.plain(b'%s\n' % _commentlines(statemsg), label=label)
 conmsg = _conflictsmsg(repo)
 if conmsg:
-fm.plain('%s\n' % conmsg, label=label)
+fm.plain(b'%s\n' % conmsg, label=label)
 if helpfulmsg:
-fm.plain('%s\n' % _commentlines(helpfulmsg), label=label)
+fm.plain(b'%s\n' % _commentlines(helpfulmsg), label=label)
 def findpossible(cmd, table, strict=False):
 """
 Return cmd -> (aliases, command table entry)
 for a in aliases:
 if a.startswith(cmd):
 found = a
 break
 if found is not None:
-if aliases[0].startswith("debug") or found.startswith("debug"):
+if aliases[0].startswith(b"debug") or found.startswith(b"debug"):
 debugchoice[found] = (aliases, table[e])
 else:
 choice[found] = (aliases, table[e])
 if not choice and debugchoice:
 def changebranch(ui, repo, revs, label):
 """ Change the branch name of given revs to label """
-with repo.wlock(), repo.lock(), repo.transaction('branches'):
+with repo.wlock(), repo.lock(), repo.transaction(b'branches'):
 # abort in case of uncommitted merge or dirty wdir
 bailifchanged(repo)
 revs = scmutil.revrange(repo, revs)
 if not revs:
-raise error.Abort("empty revision set")
+raise error.Abort(b"empty revision set")
-roots = repo.revs('roots(%ld)', revs)
+roots = repo.revs(b'roots(%ld)', revs)
 if len(roots) > 1:
-raise error.Abort(_("cannot change branch of non-linear revisions"))
+raise error.Abort(
-rewriteutil.precheck(repo, revs, 'change branch of')
+_(b"cannot change branch of non-linear revisions")
+)
+rewriteutil.precheck(repo, revs, b'change branch of')
 root = repo[roots.first()]
 rpb = {parent.branch() for parent in root.parents()}
 if label not in rpb and label in repo.branchmap():
-raise error.Abort(_("a branch of the same name already exists"))
+raise error.Abort(_(b"a branch of the same name already exists"))
-if repo.revs('obsolete() and %ld', revs):
+if repo.revs(b'obsolete() and %ld', revs):
-raise error.Abort(_("cannot change branch of a obsolete changeset"))
+raise error.Abort(
+_(b"cannot change branch of a obsolete changeset")
+)
 # make sure only topological heads
-if repo.revs('heads(%ld) - head()', revs):
+if repo.revs(b'heads(%ld) - head()', revs):
-raise error.Abort(_("cannot change branch in middle of a stack"))
+raise error.Abort(_(b"cannot change branch in middle of a stack"))
 replacements = {}
 # avoid import cycle mercurial.cmdutil -> mercurial.context ->
 # mercurial.subrepo -> mercurial.cmdutil
 from . import context
 return ctx[path]
 except error.ManifestLookupError:
 return None
 ui.debug(
-"changing branch of '%s' from '%s' to '%s'\n"
+b"changing branch of '%s' from '%s' to '%s'\n"
 % (hex(ctx.node()), oldbranch, label)
 )
 extra = ctx.extra()
-extra['branch_change'] = hex(ctx.node())
+extra[b'branch_change'] = hex(ctx.node())
 # While changing branch 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 branch
 p1 = ctx.p1().node()
 p2 = ctx.p2().node()
 branch=label,
 )
 newnode = repo.commitctx(mc)
 replacements[ctx.node()] = (newnode,)
-ui.debug('new node id is %s\n' % hex(newnode))
+ui.debug(b'new node id is %s\n' % hex(newnode))
 # create obsmarkers and move bookmarks
-scmutil.cleanupnodes(repo, replacements, 'branch-change', fixphase=True)
+scmutil.cleanupnodes(
+repo, replacements, b'branch-change', fixphase=True
+)
 # move the working copy too
 wctx = repo[None]
 # in-progress merge is a bit too complex for now.
 if len(wctx.parents()) == 1:
 # mercurial.cmdutil
 from . import hg
 hg.update(repo, newid[0], quietempty=True)
-ui.status(_("changed branch on %d changesets\n") % len(replacements))
+ui.status(_(b"changed branch on %d changesets\n") % len(replacements))
 def findrepo(p):
-while not os.path.isdir(os.path.join(p, ".hg")):
+while not os.path.isdir(os.path.join(p, b".hg")):
 oldp, p = p, os.path.dirname(p)
 if p == oldp:
 return None
 return p
 'hint' is the usual hint given to Abort exception.
 """
 if merge and repo.dirstate.p2() != nullid:
-raise error.Abort(_('outstanding uncommitted merge'), hint=hint)
+raise error.Abort(_(b'outstanding uncommitted merge'), hint=hint)
 modified, added, removed, deleted = repo.status()[:4]
 if modified or added or removed or deleted:
-raise error.Abort(_('uncommitted changes'), hint=hint)
+raise error.Abort(_(b'uncommitted changes'), hint=hint)
 ctx = repo[None]
 for s in sorted(ctx.substate):
 ctx.sub(s).bailifchanged(hint=hint)
 def logmessage(ui, opts):
 """ get the log message according to -m and -l option """
-message = opts.get('message')
+message = opts.get(b'message')
-logfile = opts.get('logfile')
+logfile = opts.get(b'logfile')
 if message and logfile:
 raise error.Abort(
-_('options --message and --logfile are mutually ' 'exclusive')
+_(b'options --message and --logfile are mutually ' b'exclusive')
 )
 if not message and logfile:
 try:
 if isstdiofilename(logfile):
 message = ui.fin.read()
 else:
-message = '\n'.join(util.readfile(logfile).splitlines())
+message = b'\n'.join(util.readfile(logfile).splitlines())
 except IOError as inst:
 raise error.Abort(
-_("can't read commit message '%s': %s")
+_(b"can't read commit message '%s': %s")
 % (logfile, encoding.strtolocal(inst.strerror))
 )
 return message
 This returns baseformname with '.merge' appended if it is a merge,
 otherwise '.normal' is appended.
 """
 if isinstance(ctxorbool, bool):
 if ctxorbool:
-return baseformname + ".merge"
+return baseformname + b".merge"
 elif len(ctxorbool.parents()) > 1:
-return baseformname + ".merge"
+return baseformname + b".merge"
-return baseformname + ".normal"
+return baseformname + b".normal"
 def getcommiteditor(
-edit=False, finishdesc=None, extramsg=None, editform='', **opts
+edit=False, finishdesc=None, extramsg=None, editform=b'', **opts
 ):
 """get appropriate commit message editor according to '--edit' option
 'finishdesc' is a function to be called with edited commit message
 (= 'description' of the new changeset) just after editing, but
 repo = ctx.repo()
 tres = formatter.templateresources(repo.ui, repo)
 t = formatter.maketemplater(
 repo.ui, tmpl, defaults=templatekw.keywords, resources=tres
 )
-mapping = {'ctx': ctx}
+mapping = {b'ctx': ctx}
 if props:
 mapping.update(props)
 return t.renderdefault(mapping)
 newname.append(stringutil.escapestr(pat[i:end]))
 break
 newname.append(stringutil.escapestr(pat[i:n]))
 if n + 2 > end:
 raise error.Abort(
-_("incomplete format spec in output " "filename")
+_(b"incomplete format spec in output " b"filename")
 )
 c = pat[n + 1 : n + 2]
 i = n + 2
 try:
 newname.append(expander[c])
 except KeyError:
 raise error.Abort(
-_("invalid format spec '%%%s' in output " "filename") % c
+_(b"invalid format spec '%%%s' in output " b"filename") % c
 )
-return ''.join(newname)
+return b''.join(newname)
 def makefilename(ctx, pat, **props):
 if not pat:
 return pat
 return rendertemplate(ctx, tmpl, pycompat.byteskwargs(props))
 def isstdiofilename(pat):
 """True if the given pat looks like a filename denoting stdin/stdout"""
-return not pat or pat == '-'
+return not pat or pat == b'-'
 class _unclosablefile(object):
 def __init__(self, fp):
 self._fp = fp
 def __exit__(self, exc_type, exc_value, exc_tb):
 pass
-def makefileobj(ctx, pat, mode='wb', **props):
+def makefileobj(ctx, pat, mode=b'wb', **props):
-writable = mode not in ('r', 'rb')
+writable = mode not in (b'r', b'rb')
 if isstdiofilename(pat):
 repo = ctx.repo()
 if writable:
 fp = repo.ui.fout
 return open(fn, mode)
 def openstorage(repo, cmd, file_, opts, returnrevlog=False):
 """opens the changelog, manifest, a filelog or a given revlog"""
-cl = opts['changelog']
+cl = opts[b'changelog']
-mf = opts['manifest']
+mf = opts[b'manifest']
-dir = opts['dir']
+dir = opts[b'dir']
 msg = None
 if cl and mf:
-msg = _('cannot specify --changelog and --manifest at the same time')
+msg = _(b'cannot specify --changelog and --manifest at the same time')
 elif cl and dir:
-msg = _('cannot specify --changelog and --dir at the same time')
+msg = _(b'cannot specify --changelog and --dir at the same time')
 elif cl or mf or dir:
 if file_:
-msg = _('cannot specify filename with --changelog or --manifest')
+msg = _(b'cannot specify filename with --changelog or --manifest')
 elif not repo:
 msg = _(
-'cannot specify --changelog or --manifest or --dir '
+b'cannot specify --changelog or --manifest or --dir '
-'without a repository'
+b'without a repository'
 )
 if msg:
 raise error.Abort(msg)
 r = None
 if repo:
 if cl:
 r = repo.unfiltered().changelog
 elif dir:
-if 'treemanifest' not in repo.requirements:
+if b'treemanifest' not in repo.requirements:
 raise error.Abort(
 _(
-"--dir can only be used on repos with "
+b"--dir can only be used on repos with "
-"treemanifest enabled"
+b"treemanifest enabled"
 )
 )
-if not dir.endswith('/'):
+if not dir.endswith(b'/'):
-dir = dir + '/'
+dir = dir + b'/'
 dirlog = repo.manifestlog.getstorage(dir)
 if len(dirlog):
 r = dirlog
 elif mf:
 r = repo.manifestlog.getstorage(b'')
 # Not all storage may be revlogs. If requested, try to return an actual
 # revlog instance.
 if returnrevlog:
 if isinstance(r, revlog.revlog):
 pass
-elif util.safehasattr(r, '_revlog'):
+elif util.safehasattr(r, b'_revlog'):
 r = r._revlog
 elif r is not None:
-raise error.Abort(_('%r does not appear to be a revlog') % r)
+raise error.Abort(_(b'%r does not appear to be a revlog') % r)
 if not r:
 if not returnrevlog:
-raise error.Abort(_('cannot give path to non-revlog'))
+raise error.Abort(_(b'cannot give path to non-revlog'))
 if not file_:
-raise error.CommandError(cmd, _('invalid arguments'))
+raise error.CommandError(cmd, _(b'invalid arguments'))
 if not os.path.isfile(file_):
-raise error.Abort(_("revlog '%s' not found") % file_)
+raise error.Abort(_(b"revlog '%s' not found") % file_)
 r = revlog.revlog(
-vfsmod.vfs(encoding.getcwd(), audit=False), file_[:-2] + ".i"
+vfsmod.vfs(encoding.getcwd(), audit=False), file_[:-2] + b".i"
 )
 return r
 def openrevlog(repo, cmd, file_, opts):
 #
 # hgsep => pathname that uses "/" to separate directories
 # ossep => pathname that uses os.sep to separate directories
 cwd = repo.getcwd()
 targets = {}
-after = opts.get("after")
+after = opts.get(b"after")
-dryrun = opts.get("dry_run")
+dryrun = opts.get(b"dry_run")
 wctx = repo[None]
 uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=True)
 def walkpat(pat):
 srcs = []
 if after:
-badstates = '?'
+badstates = b'?'
 else:
-badstates = '?r'
+badstates = b'?r'
 m = scmutil.match(wctx, [pat], opts, globbed=True)
 for abs in wctx.walk(m):
 state = repo.dirstate[abs]
 rel = uipathfn(abs)
 exact = m.exact(abs)
 if state in badstates:
-if exact and state == '?':
+if exact and state == b'?':
-ui.warn(_('%s: not copying - file is not managed\n') % rel)
+ui.warn(_(b'%s: not copying - file is not managed\n') % rel)
-if exact and state == 'r':
+if exact and state == b'r':
 ui.warn(
 _(
-'%s: not copying - file has been marked for'
+b'%s: not copying - file has been marked for'
-' remove\n'
+b' remove\n'
 )
 % rel
 )
 continue
 # abs: hgsep
 # abssrc: hgsep
 # relsrc: ossep
 # otarget: ossep
 def copyfile(abssrc, relsrc, otarget, exact):
 abstarget = pathutil.canonpath(repo.root, cwd, otarget)
-if '/' in abstarget:
+if b'/' in abstarget:
 # We cannot normalize abstarget itself, this would prevent
 # case only renames, like a => A.
-abspath, absname = abstarget.rsplit('/', 1)
+abspath, absname = abstarget.rsplit(b'/', 1)
-abstarget = repo.dirstate.normalize(abspath) + '/' + absname
+abstarget = repo.dirstate.normalize(abspath) + b'/' + absname
 reltarget = repo.pathto(abstarget, cwd)
 target = repo.wjoin(abstarget)
 src = repo.wjoin(abssrc)
 state = repo.dirstate[abstarget]
 # check for collisions
 prevsrc = targets.get(abstarget)
 if prevsrc is not None:
 ui.warn(
-_('%s: not overwriting - %s collides with %s\n')
+_(b'%s: not overwriting - %s collides with %s\n')
 % (
 reltarget,
 repo.pathto(abssrc, cwd),
 repo.pathto(prevsrc, cwd),
 )
 if exists and abssrc != abstarget:
 if repo.dirstate.normalize(abssrc) == repo.dirstate.normalize(
 abstarget
 ):
 if not rename:
-ui.warn(_("%s: can't copy - same file\n") % reltarget)
+ui.warn(_(b"%s: can't copy - same file\n") % reltarget)
 return True  # report a failure
 exists = False
 samefile = True
-if not after and exists or after and state in 'mn':
+if not after and exists or after and state in b'mn':
-if not opts['force']:
+if not opts[b'force']:
-if state in 'mn':
+if state in b'mn':
-msg = _('%s: not overwriting - file already committed\n')
+msg = _(b'%s: not overwriting - file already committed\n')
 if after:
-flags = '--after --force'
+flags = b'--after --force'
 else:
-flags = '--force'
+flags = b'--force'
 if rename:
 hint = (
 _(
-"('hg rename %s' to replace the file by "
+b"('hg rename %s' to replace the file by "
-'recording a rename)\n'
+b'recording a rename)\n'
 )
 % flags
 )
 else:
 hint = (
 _(
-"('hg copy %s' to replace the file by "
+b"('hg copy %s' to replace the file by "
-'recording a copy)\n'
+b'recording a copy)\n'
 )
 % flags
 )
 else:
-msg = _('%s: not overwriting - file exists\n')
+msg = _(b'%s: not overwriting - file exists\n')
 if rename:
-hint = _("('hg rename --after' to record the rename)\n")
+hint = _(
+b"('hg rename --after' to record the rename)\n"
+)
 else:
-hint = _("('hg copy --after' to record the copy)\n")
+hint = _(b"('hg copy --after' to record the copy)\n")
 ui.warn(msg % reltarget)
 ui.warn(hint)
 return True  # report a failure
 if after:
 if not exists:
 if rename:
 ui.warn(
-_('%s: not recording move - %s does not exist\n')
+_(b'%s: not recording move - %s does not exist\n')
 % (relsrc, reltarget)
 )
 else:
 ui.warn(
-_('%s: not recording copy - %s does not exist\n')
+_(b'%s: not recording copy - %s does not exist\n')
 % (relsrc, reltarget)
 )
 return True  # report a failure
 elif not dryrun:
 try:
 if exists:
 os.unlink(target)
-targetdir = os.path.dirname(target) or '.'
+targetdir = os.path.dirname(target) or b'.'
 if not os.path.isdir(targetdir):
 os.makedirs(targetdir)
 if samefile:
-tmp = target + "~hgrename"
+tmp = target + b"~hgrename"
 os.rename(src, tmp)
 os.rename(tmp, target)
 else:
 # Preserve stat info on renames, not on copies; this matches
 # Linux CLI behavior.
 util.copyfile(src, target, copystat=rename)
 srcexists = True
 except IOError as inst:
 if inst.errno == errno.ENOENT:
-ui.warn(_('%s: deleted in working directory\n') % relsrc)
+ui.warn(_(b'%s: deleted in working directory\n') % relsrc)
 srcexists = False
 else:
 ui.warn(
-_('%s: cannot copy - %s\n')
+_(b'%s: cannot copy - %s\n')
 % (relsrc, encoding.strtolocal(inst.strerror))
 )
 return True  # report a failure
 if ui.verbose or not exact:
 if rename:
-ui.status(_('moving %s to %s\n') % (relsrc, reltarget))
+ui.status(_(b'moving %s to %s\n') % (relsrc, reltarget))
 else:
-ui.status(_('copying %s to %s\n') % (relsrc, reltarget))
+ui.status(_(b'copying %s to %s\n') % (relsrc, reltarget))
 targets[abstarget] = abssrc
 # fix up dirstate
 scmutil.dirstatecopy(
 ui, repo, wctx, abssrc, abstarget, dryrun=dryrun, cwd=cwd
 )
 if rename and not dryrun:
 if not after and srcexists and not samefile:
-rmdir = repo.ui.configbool('experimental', 'removeemptydirs')
+rmdir = repo.ui.configbool(b'experimental', b'removeemptydirs')
 repo.wvfs.unlinkpath(abssrc, rmdir=rmdir)
 wctx.forget([abssrc])
 # pat: ossep
 # dest ossep
 res = lambda p: dest
 return res
 pats = scmutil.expandpats(pats)
 if not pats:
-raise error.Abort(_('no source or destination specified'))
+raise error.Abort(_(b'no source or destination specified'))
 if len(pats) == 1:
-raise error.Abort(_('no destination specified'))
+raise error.Abort(_(b'no destination specified'))
 dest = pats.pop()
 destdirexists = os.path.isdir(dest) and not os.path.islink(dest)
 if not destdirexists:
 if len(pats) > 1 or matchmod.patkind(pats[0]):
 raise error.Abort(
 _(
-'with multiple sources, destination must be an '
+b'with multiple sources, destination must be an '
-'existing directory'
+b'existing directory'
 )
 )
 if util.endswithsep(dest):
-raise error.Abort(_('destination %s is not a directory') % dest)
+raise error.Abort(_(b'destination %s is not a directory') % dest)
 tfn = targetpathfn
 if after:
 tfn = targetpathafterfn
 copylist = []
 srcs = walkpat(pat)
 if not srcs:
 continue
 copylist.append((tfn(pat, dest, srcs), srcs))
 if not copylist:
-raise error.Abort(_('no files to copy'))
+raise error.Abort(_(b'no files to copy'))
 errors = 0
 for targetpath, srcs in copylist:
 for abssrc, relsrc, exact in srcs:
 if copyfile(abssrc, relsrc, targetpath(abssrc), exact):
 updatefunc(<repo>, <node>)
 """
 # avoid cycle context -> subrepo -> cmdutil
 from . import context
-tmpname = patchdata.get('filename')
+tmpname = patchdata.get(b'filename')
-message = patchdata.get('message')
+message = patchdata.get(b'message')
-user = opts.get('user') or patchdata.get('user')
+user = opts.get(b'user') or patchdata.get(b'user')
-date = opts.get('date') or patchdata.get('date')
+date = opts.get(b'date') or patchdata.get(b'date')
-branch = patchdata.get('branch')
+branch = patchdata.get(b'branch')
-nodeid = patchdata.get('nodeid')
+nodeid = patchdata.get(b'nodeid')
-p1 = patchdata.get('p1')
+p1 = patchdata.get(b'p1')
-p2 = patchdata.get('p2')
+p2 = patchdata.get(b'p2')
-nocommit = opts.get('no_commit')
+nocommit = opts.get(b'no_commit')
-importbranch = opts.get('import_branch')
+importbranch = opts.get(b'import_branch')
-update = not opts.get('bypass')
+update = not opts.get(b'bypass')
-strip = opts["strip"]
+strip = opts[b"strip"]
-prefix = opts["prefix"]
+prefix = opts[b"prefix"]
-sim = float(opts.get('similarity') or 0)
+sim = float(opts.get(b'similarity') or 0)
 if not tmpname:
 return None, None, False
 rejects = False
 # pickup the patch msg
 message = message.strip()
 else:
 # launch the editor
 message = None
-ui.debug('message:\n%s\n' % (message or ''))
+ui.debug(b'message:\n%s\n' % (message or b''))
 if len(parents) == 1:
 parents.append(repo[nullid])
-if opts.get('exact'):
+if opts.get(b'exact'):
 if not nodeid or not p1:
-raise error.Abort(_('not a Mercurial patch'))
+raise error.Abort(_(b'not a Mercurial patch'))
 p1 = repo[p1]
 p2 = repo[p2 or nullid]
 elif p2:
 try:
 p1 = repo[p1]
 except error.RepoError:
 p1, p2 = parents
 if p2.node() == nullid:
 ui.warn(
 _(
-"warning: import the patch as a normal revision\n"
+b"warning: import the patch as a normal revision\n"
-"(use --exact to import the patch as a merge)\n"
+b"(use --exact to import the patch as a merge)\n"
 )
 )
 else:
 p1, p2 = parents
 if p1 != parents[0]:
 updatefunc(repo, p1.node())
 if p2 != parents[1]:
 repo.setparents(p1.node(), p2.node())
-if opts.get('exact') or importbranch:
+if opts.get(b'exact') or importbranch:
-repo.dirstate.setbranch(branch or 'default')
+repo.dirstate.setbranch(branch or b'default')
-partial = opts.get('partial', False)
+partial = opts.get(b'partial', False)
 files = set()
 try:
 patch.patch(
 ui,
 repo,
 files = list(files)
 if nocommit:
 if message:
 msgs.append(message)
 else:
-if opts.get('exact') or p2:
+if opts.get(b'exact') or p2:
 # If you got here, you either use --force and know what
 # you are doing or used --exact or a merge patch while
 # being updated to its first parent.
 m = None
 else:
 m = scmutil.matchfiles(repo, files or [])
-editform = mergeeditform(repo[None], 'import.normal')
+editform = mergeeditform(repo[None], b'import.normal')
-if opts.get('exact'):
+if opts.get(b'exact'):
 editor = None
 else:
 editor = getcommiteditor(
 editform=editform, **pycompat.strkwargs(opts)
 )
 extra = {}
 for idfunc in extrapreimport:
 extrapreimportmap[idfunc](repo, patchdata, extra, opts)
 overrides = {}
 if partial:
-overrides[('ui', 'allowemptycommit')] = True
+overrides[(b'ui', b'allowemptycommit')] = True
-with repo.ui.configoverride(overrides, 'import'):
+with repo.ui.configoverride(overrides, b'import'):
 n = repo.commit(
 message, user, date, match=m, editor=editor, extra=extra
 )
 for idfunc in extrapostimport:
 extrapostimportmap[idfunc](repo[n])
 else:
-if opts.get('exact') or importbranch:
+if opts.get(b'exact') or importbranch:
-branch = branch or 'default'
+branch = branch or b'default'
 else:
 branch = p1.branch()
 store = patch.filestore()
 try:
 files = set()
 files,
 eolmode=None,
 )
 except error.PatchError as e:
 raise error.Abort(stringutil.forcebytestr(e))
-if opts.get('exact'):
+if opts.get(b'exact'):
 editor = None
 else:
-editor = getcommiteditor(editform='import.bypass')
+editor = getcommiteditor(editform=b'import.bypass')
 memctx = context.memctx(
 repo,
 (p1.node(), p2.node()),
 message,
 files=files,
 editor=editor,
 )
 n = memctx.commit()
 finally:
 store.close()
-if opts.get('exact') and nocommit:
+if opts.get(b'exact') and nocommit:
 # --exact with --no-commit is still useful in that it does merge
 # and branch bits
-ui.warn(_("warning: can't check exact import with --no-commit\n"))
+ui.warn(_(b"warning: can't check exact import with --no-commit\n"))
-elif opts.get('exact') and (not n or hex(n) != nodeid):
+elif opts.get(b'exact') and (not n or hex(n) != nodeid):
-raise error.Abort(_('patch is damaged or loses information'))
+raise error.Abort(_(b'patch is damaged or loses information'))
-msg = _('applied to working directory')
+msg = _(b'applied to working directory')
 if n:
 # i18n: refers to a short changeset id
-msg = _('created %s') % short(n)
+msg = _(b'created %s') % short(n)
 return msg, n, rejects
 # facility to let extensions include additional data in an exported patch
 # list of identifiers to be executed in order
 prev = parents[0]
 else:
 prev = nullid
 fm.context(ctx=ctx)
-fm.plain('# HG changeset patch\n')
+fm.plain(b'# HG changeset patch\n')
-fm.write('user', '# User %s\n', ctx.user())
+fm.write(b'user', b'# User %s\n', ctx.user())
-fm.plain('# Date %d %d\n' % ctx.date())
+fm.plain(b'# Date %d %d\n' % ctx.date())
-fm.write('date', '#      %s\n', fm.formatdate(ctx.date()))
+fm.write(b'date', b'#      %s\n', fm.formatdate(ctx.date()))
 fm.condwrite(
-branch and branch != 'default', 'branch', '# Branch %s\n', branch
+branch and branch != b'default', b'branch', b'# Branch %s\n', branch
 )
-fm.write('node', '# Node ID %s\n', hex(node))
+fm.write(b'node', b'# Node ID %s\n', hex(node))
-fm.plain('# Parent  %s\n' % hex(prev))
+fm.plain(b'# Parent  %s\n' % hex(prev))
 if len(parents) > 1:
-fm.plain('# Parent  %s\n' % hex(parents[1]))
+fm.plain(b'# Parent  %s\n' % hex(parents[1]))
-fm.data(parents=fm.formatlist(pycompat.maplist(hex, parents), name='node'))
+fm.data(parents=fm.formatlist(pycompat.maplist(hex, parents), name=b'node'))
 # TODO: redesign extraexportmap function to support formatter
 for headerid in extraexport:
 header = extraexportmap[headerid](seqno, ctx)
 if header is not None:
-fm.plain('# %s\n' % header)
+fm.plain(b'# %s\n' % header)
-fm.write('desc', '%s\n', ctx.description().rstrip())
+fm.write(b'desc', b'%s\n', ctx.description().rstrip())
-fm.plain('\n')
+fm.plain(b'\n')
 if fm.isplain():
 chunkiter = patch.diffui(repo, prev, node, match, opts=diffopts)
 for chunk, label in chunkiter:
 fm.plain(chunk, label=label)
 def _exportfile(repo, revs, fm, dest, switch_parent, diffopts, match):
 """Export changesets to stdout or a single file"""
 for seqno, rev in enumerate(revs, 1):
 ctx = repo[rev]
-if not dest.startswith('<'):
+if not dest.startswith(b'<'):
-repo.ui.note("%s\n" % dest)
+repo.ui.note(b"%s\n" % dest)
 fm.startitem()
 _exportsingle(repo, ctx, fm, match, switch_parent, seqno, diffopts)
 def _exportfntemplate(
 )
 filemap.setdefault(dest, []).append((seqno, rev))
 for dest in filemap:
 with formatter.maybereopen(basefm, dest) as fm:
-repo.ui.note("%s\n" % dest)
+repo.ui.note(b"%s\n" % dest)
 for seqno, rev in filemap[dest]:
 fm.startitem()
 ctx = repo[rev]
 _exportsingle(
 repo, ctx, fm, match, switch_parent, seqno, diffopts
 def export(
 repo,
 revs,
 basefm,
-fntemplate='hg-%h.patch',
+fntemplate=b'hg-%h.patch',
 switch_parent=False,
 opts=None,
 match=None,
 ):
 '''export changesets as hg patches
 Otherwise: All revs will be written to basefm.
 '''
 _prefetchchangedfiles(repo, revs, match)
 if not fntemplate:
-_exportfile(repo, revs, basefm, '<unnamed>', switch_parent, opts, match)
+_exportfile(
+repo, revs, basefm, b'<unnamed>', switch_parent, opts, match
+)
 else:
 _exportfntemplate(
 repo, revs, basefm, fntemplate, switch_parent, opts, match
 )
 def exportfile(repo, revs, fp, switch_parent=False, opts=None, match=None):
 """Export changesets to the given file stream"""
 _prefetchchangedfiles(repo, revs, match)
-dest = getattr(fp, 'name', '<unnamed>')
+dest = getattr(fp, 'name', b'<unnamed>')
-with formatter.formatter(repo.ui, fp, 'export', {}) as fm:
+with formatter.formatter(repo.ui, fp, b'export', {}) as fm:
 _exportfile(repo, revs, fm, dest, switch_parent, opts, match)
 def showmarker(fm, marker, index=None):
 """utility function to display obsolescence marker in a readable way
 To be used by debug function."""
 if index is not None:
-fm.write('index', '%i ', index)
+fm.write(b'index', b'%i ', index)
-fm.write('prednode', '%s ', hex(marker.prednode()))
+fm.write(b'prednode', b'%s ', hex(marker.prednode()))
 succs = marker.succnodes()
 fm.condwrite(
-succs, 'succnodes', '%s ', fm.formatlist(map(hex, succs), name='node')
+succs,
+b'succnodes',
+b'%s ',
+fm.formatlist(map(hex, succs), name=b'node'),
 )
-fm.write('flag', '%X ', marker.flags())
+fm.write(b'flag', b'%X ', marker.flags())
 parents = marker.parentnodes()
 if parents is not None:
 fm.write(
-'parentnodes',
+b'parentnodes',
-'{%s} ',
+b'{%s} ',
-fm.formatlist(map(hex, parents), name='node', sep=', '),
+fm.formatlist(map(hex, parents), name=b'node', sep=b', '),
 )
-fm.write('date', '(%s) ', fm.formatdate(marker.date()))
+fm.write(b'date', b'(%s) ', fm.formatdate(marker.date()))
 meta = marker.metadata().copy()
-meta.pop('date', None)
+meta.pop(b'date', None)
 smeta = pycompat.rapply(pycompat.maybebytestr, meta)
-fm.write('metadata', '{%s}', fm.formatdict(smeta, fmt='%r: %r', sep=', '))
+fm.write(
-fm.plain('\n')
+b'metadata', b'{%s}', fm.formatdict(smeta, fmt=b'%r: %r', sep=b', ')
+)
+fm.plain(b'\n')
 def finddate(ui, repo, date):
 """Find the tipmost changeset that matches the given date spec"""
 def prep(ctx, fns):
 d = ctx.date()
 if df(d[0]):
 results[ctx.rev()] = d
-for ctx in walkchangerevs(repo, m, {'rev': None}, prep):
+for ctx in walkchangerevs(repo, m, {b'rev': None}, prep):
 rev = ctx.rev()
 if rev in results:
 ui.status(
-_("found revision %s from %s\n")
+_(b"found revision %s from %s\n")
 % (rev, dateutil.datestr(results[rev]))
 )
-return '%d' % rev
+return b'%d' % rev
-raise error.Abort(_("revision matching date not found"))
+raise error.Abort(_(b"revision matching date not found"))
 def increasingwindows(windowsize=8, sizelimit=512):
 while True:
 yield windowsize
 def _walkrevs(repo, opts):
 # Default --rev value depends on --follow but --follow behavior
 # depends on revisions resolved from --rev...
-follow = opts.get('follow') or opts.get('follow_first')
+follow = opts.get(b'follow') or opts.get(b'follow_first')
-if opts.get('rev'):
+if opts.get(b'rev'):
-revs = scmutil.revrange(repo, opts['rev'])
+revs = scmutil.revrange(repo, opts[b'rev'])
 elif follow and repo.dirstate.p1() == nullid:
 revs = smartset.baseset()
 elif follow:
-revs = repo.revs('reverse(:.)')
+revs = repo.revs(b'reverse(:.)')
 else:
 revs = smartset.spanset(repo)
 revs.reverse()
 return revs
 )
 return reversed(revs)
 def iterfiles():
-pctx = repo['.']
+pctx = repo[b'.']
 for filename in match.files():
 if follow:
 if filename not in pctx:
 raise error.Abort(
-_('cannot follow file not in parent ' 'revision: "%s"')
+_(
+b'cannot follow file not in parent '
+b'revision: "%s"'
+)
 % filename
 )
 yield filename, pctx[filename].filenode()
 else:
 yield filename, None
 if node is None:
 # A zero count may be a directory or deleted file, so
 # try to find matching entries on the slow path.
 if follow:
 raise error.Abort(
-_('cannot follow nonexistent file: "%s"') % file_
+_(b'cannot follow nonexistent file: "%s"') % file_
 )
-raise FileWalkError("Cannot walk via filelog")
+raise FileWalkError(b"Cannot walk via filelog")
 else:
 continue
 if node is None:
 last = len(filelog) - 1
 This function returns an iterator yielding contexts. Before
 yielding each context, the iterator will first call the prepare
 function on each context in the window in forward order.'''
-allfiles = opts.get('all_files')
+allfiles = opts.get(b'all_files')
-follow = opts.get('follow') or opts.get('follow_first')
+follow = opts.get(b'follow') or opts.get(b'follow_first')
 revs = _walkrevs(repo, opts)
 if not revs:
 return []
 wanted = set()
-slowpath = match.anypats() or (not match.always() and opts.get('removed'))
+slowpath = match.anypats() or (not match.always() and opts.get(b'removed'))
 fncache = {}
 change = repo.__getitem__
 # First step is to fill wanted, the set of revisions that we want to yield.
 # When it does not induce extra cost, we also fill fncache for revisions in
 # We decided to fall back to the slowpath because at least one
 # of the paths was not a file. Check to see if at least one of them
 # existed in history, otherwise simply return
 for path in match.files():
-if path == '.' or path in repo.store:
+if path == b'.' or path in repo.store:
 break
 else:
 return []
 if slowpath:
 # We have to read the changelog to match filenames against
 # changed files
 if follow:
 raise error.Abort(
-_('can only follow copies/renames for explicit ' 'filenames')
+_(b'can only follow copies/renames for explicit ' b'filenames')
 )
 # The slow path checks files modified in every changeset.
 # This is really slow on large repos, so compute the set lazily.
 class lazywantedset(object):
 wanted = lazywantedset()
 # it might be worthwhile to do this in the iterator if the rev range
 # is descending and the prune args are all within that range
-for rev in opts.get('prune', ()):
+for rev in opts.get(b'prune', ()):
 rev = repo[rev].rev()
 ff = _followfilter(repo)
 stop = min(revs[0], revs[-1])
 for x in pycompat.xrange(rev, stop - 1, -1):
 if ff.match(x):
 # Now that wanted is correctly initialized, we can iterate over the
 # revision range, yielding only revisions in wanted.
 def iterate():
 if follow and match.always():
-ff = _followfilter(repo, onlyfirst=opts.get('follow_first'))
+ff = _followfilter(repo, onlyfirst=opts.get(b'follow_first'))
 def want(rev):
 return ff.match(rev) and rev in wanted
 else:
 if cca:
 cca(f)
 names.append(f)
 if ui.verbose or not exact:
 ui.status(
-_('adding %s\n') % uipathfn(f), label='ui.addremove.added'
+_(b'adding %s\n') % uipathfn(f), label=b'ui.addremove.added'
 )
 for subpath in sorted(wctx.substate):
 sub = wctx.sub(subpath)
 try:
 bad.extend(
 sub.add(ui, submatch, subprefix, subuipathfn, True, **opts)
 )
 except error.LookupError:
 ui.status(
-_("skipping missing subrepository: %s\n") % uipathfn(subpath)
+_(b"skipping missing subrepository: %s\n") % uipathfn(subpath)
 )
 if not opts.get(r'dry_run'):
 rejected = wctx.add(names, prefix)
 bad.extend(f for f in rejected if f in match.files())
 return bad
 def addwebdirpath(repo, serverpath, webconf):
 webconf[serverpath] = repo.root
-repo.ui.debug('adding %s = %s\n' % (serverpath, repo.root))
+repo.ui.debug(b'adding %s = %s\n' % (serverpath, repo.root))
-for r in repo.revs('filelog("path:.hgsub")'):
+for r in repo.revs(b'filelog("path:.hgsub")'):
 ctx = repo[r]
 for subpath in ctx.substate:
 ctx.sub(subpath).addwebdirpath(serverpath, webconf)
 def forget(
 ui, repo, match, prefix, uipathfn, explicitonly, dryrun, interactive
 ):
 if dryrun and interactive:
-raise error.Abort(_("cannot specify both --dry-run and --interactive"))
+raise error.Abort(_(b"cannot specify both --dry-run and --interactive"))
 bad = []
 badfn = lambda x, y: bad.append(x) or match.bad(x, y)
 wctx = repo[None]
 forgot = []
 subprefix,
 subuipathfn,
 dryrun=dryrun,
 interactive=interactive,
 )
-bad.extend([subpath + '/' + f for f in subbad])
+bad.extend([subpath + b'/' + f for f in subbad])
-forgot.extend([subpath + '/' + f for f in subforgot])
+forgot.extend([subpath + b'/' + f for f in subforgot])
 except error.LookupError:
 ui.status(
-_("skipping missing subrepository: %s\n") % uipathfn(subpath)
+_(b"skipping missing subrepository: %s\n") % uipathfn(subpath)
 )
 if not explicitonly:
 for f in match.files():
 if f not in repo.dirstate and not repo.wvfs.isdir(f):
 # that subrepo files aren't normalized, and this op is
 # purely from data cached by the status walk above.
 if repo.dirstate.normalize(f) in repo.dirstate:
 continue
 ui.warn(
-_('not removing %s: ' 'file is already untracked\n')
+_(
+b'not removing %s: '
+b'file is already untracked\n'
+)
 % uipathfn(f)
 )
 bad.append(f)
 if interactive:
 responses = _(
-'[Ynsa?]'
+b'[Ynsa?]'
-'$$ &Yes, forget this file'
+b'$$ &Yes, forget this file'
-'$$ &No, skip this file'
+b'$$ &No, skip this file'
-'$$ &Skip remaining files'
+b'$$ &Skip remaining files'
-'$$ Include &all remaining files'
+b'$$ Include &all remaining files'
-'$$ &? (display help)'
+b'$$ &? (display help)'
 )
 for filename in forget[:]:
 r = ui.promptchoice(
-_('forget %s %s') % (uipathfn(filename), responses)
+_(b'forget %s %s') % (uipathfn(filename), responses)
 )
 if r == 4:  # ?
 while r == 4:
 for c, t in ui.extractchoices(responses)[1]:
-ui.write('%s - %s\n' % (c, encoding.lower(t)))
+ui.write(b'%s - %s\n' % (c, encoding.lower(t)))
 r = ui.promptchoice(
-_('forget %s %s') % (uipathfn(filename), responses)
+_(b'forget %s %s') % (uipathfn(filename), responses)
 )
 if r == 0:  # yes
 continue
 elif r == 1:  # no
 forget.remove(filename)
 break
 for f in forget:
 if ui.verbose or not match.exact(f) or interactive:
 ui.status(
-_('removing %s\n') % uipathfn(f), label='ui.addremove.removed'
+_(b'removing %s\n') % uipathfn(f), label=b'ui.addremove.removed'
 )
 if not dryrun:
 rejected = wctx.forget(forget, prefix)
 bad.extend(f for f in rejected if f in match.files())
 def files(ui, ctx, m, uipathfn, fm, fmt, subrepos):
 ret = 1
-needsfctx = ui.verbose or {'size', 'flags'} & fm.datahint()
+needsfctx = ui.verbose or {b'size', b'flags'} & fm.datahint()
 for f in ctx.matches(m):
 fm.startitem()
 fm.context(ctx=ctx)
 if needsfctx:
 fc = ctx[f]
-fm.write('size flags', '% 10d % 1s ', fc.size(), fc.flags())
+fm.write(b'size flags', b'% 10d % 1s ', fc.size(), fc.flags())
 fm.data(path=f)
 fm.plain(fmt % uipathfn(f))
 ret = 0
 for subpath in sorted(ctx.substate):
 == 0
 ):
 ret = 0
 except error.LookupError:
 ui.status(
-_("skipping missing subrepository: %s\n")
+_(b"skipping missing subrepository: %s\n")
 % uipathfn(subpath)
 )
 return ret
 else:
 warn = False
 subs = sorted(wctx.substate)
 progress = ui.makeprogress(
-_('searching'), total=len(subs), unit=_('subrepos')
+_(b'searching'), total=len(subs), unit=_(b'subrepos')
 )
 for subpath in subs:
 submatch = matchmod.subdirmatcher(subpath, m)
 subprefix = repo.wvfs.reljoin(prefix, subpath)
 subuipathfn = scmutil.subdiruipathfn(subpath, uipathfn)
 warnings,
 ):
 ret = 1
 except error.LookupError:
 warnings.append(
-_("skipping missing subrepository: %s\n")
+_(b"skipping missing subrepository: %s\n")
 % uipathfn(subpath)
 )
 progress.complete()
 # warn about failure to delete explicit files/dirs
 deleteddirs = util.dirs(deleted)
 files = m.files()
-progress = ui.makeprogress(_('deleting'), total=len(files), unit=_('files'))
+progress = ui.makeprogress(
+_(b'deleting'), total=len(files), unit=_(b'files')
+)
 for f in files:
 def insubrepo():
 for subpath in wctx.substate:
-if f.startswith(subpath + '/'):
+if f.startswith(subpath + b'/'):
 return True
 return False
 progress.increment()
 isdir = f in deleteddirs or wctx.hasdir(f)
-if f in repo.dirstate or isdir or f == '.' or insubrepo() or f in subs:
+if f in repo.dirstate or isdir or f == b'.' or insubrepo() or f in subs:
 continue
 if repo.wvfs.exists(f):
 if repo.wvfs.isdir(f):
 warnings.append(
-_('not removing %s: no tracked files\n') % uipathfn(f)
+_(b'not removing %s: no tracked files\n') % uipathfn(f)
 )
 else:
 warnings.append(
-_('not removing %s: file is untracked\n') % uipathfn(f)
+_(b'not removing %s: file is untracked\n') % uipathfn(f)
 )
 # missing files will generate a warning elsewhere
 ret = 1
 progress.complete()
 list = modified + deleted + clean + added
 elif after:
 list = deleted
 remaining = modified + added + clean
 progress = ui.makeprogress(
-_('skipping'), total=len(remaining), unit=_('files')
+_(b'skipping'), total=len(remaining), unit=_(b'files')
 )
 for f in remaining:
 progress.increment()
 if ui.verbose or (f in files):
 warnings.append(
-_('not removing %s: file still exists\n') % uipathfn(f)
+_(b'not removing %s: file still exists\n') % uipathfn(f)
 )
 ret = 1
 progress.complete()
 else:
 list = deleted + clean
 progress = ui.makeprogress(
-_('skipping'), total=(len(modified) + len(added)), unit=_('files')
+_(b'skipping'), total=(len(modified) + len(added)), unit=_(b'files')
 )
 for f in modified:
 progress.increment()
 warnings.append(
 _(
-'not removing %s: file is modified (use -f'
+b'not removing %s: file is modified (use -f'
-' to force removal)\n'
+b' to force removal)\n'
 )
 % uipathfn(f)
 )
 ret = 1
 for f in added:
 progress.increment()
 warnings.append(
 _(
-"not removing %s: file has been marked for add"
+b"not removing %s: file has been marked for add"
-" (use 'hg forget' to undo add)\n"
+b" (use 'hg forget' to undo add)\n"
 )
 % uipathfn(f)
 )
 ret = 1
 progress.complete()
 list = sorted(list)
-progress = ui.makeprogress(_('deleting'), total=len(list), unit=_('files'))
+progress = ui.makeprogress(
+_(b'deleting'), total=len(list), unit=_(b'files')
+)
 for f in list:
 if ui.verbose or not m.exact(f):
 progress.increment()
 ui.status(
-_('removing %s\n') % uipathfn(f), label='ui.addremove.removed'
+_(b'removing %s\n') % uipathfn(f), label=b'ui.addremove.removed'
 )
 progress.complete()
 if not dryrun:
 with repo.wlock():
 if not after:
 for f in list:
 if f in added:
 continue  # we never unlink added files on remove
 rmdir = repo.ui.configbool(
-'experimental', 'removeemptydirs'
+b'experimental', b'removeemptydirs'
 )
 repo.wvfs.unlinkpath(f, ignoremissing=True, rmdir=rmdir)
 repo[None].forget(list)
 if warn:
 return ret
 def _catfmtneedsdata(fm):
-return not fm.datahint() or 'data' in fm.datahint()
+return not fm.datahint() or b'data' in fm.datahint()
 def _updatecatformatter(fm, ctx, matcher, path, decode):
 """Hook for adding data to the formatter used by ``hg cat``.
 data = ctx[path].data()
 if decode:
 data = ctx.repo().wwritedata(path, data)
 fm.startitem()
 fm.context(ctx=ctx)
-fm.write('data', '%s', data)
+fm.write(b'data', b'%s', data)
 fm.data(path=path)
 def cat(ui, repo, ctx, matcher, basefm, fntemplate, prefix, **opts):
 err = 1
 try:
 os.makedirs(os.path.dirname(filename))
 except OSError:
 pass
 with formatter.maybereopen(basefm, filename) as fm:
-_updatecatformatter(fm, ctx, matcher, path, opts.get('decode'))
+_updatecatformatter(fm, ctx, matcher, path, opts.get(b'decode'))
 # Automation often uses hg cat on single files, so special case it
 # for performance to avoid the cost of parsing the manifest.
 if len(matcher.files()) == 1 and not matcher.anypats():
 file = matcher.files()[0]
 **pycompat.strkwargs(opts)
 ):
 err = 0
 except error.RepoLookupError:
 ui.status(
-_("skipping missing subrepository: %s\n") % uipathfn(subpath)
+_(b"skipping missing subrepository: %s\n") % uipathfn(subpath)
 )
 return err
 def commit(ui, repo, commitfunc, pats, opts):
 '''commit the specified files or all outstanding changes'''
-date = opts.get('date')
+date = opts.get(b'date')
 if date:
-opts['date'] = dateutil.parsedate(date)
+opts[b'date'] = dateutil.parsedate(date)
 message = logmessage(ui, opts)
 matcher = scmutil.match(repo[None], pats, opts)
 dsguard = None
 # extract addremove carefully -- this function can be called from a command
 # that doesn't support addremove
-if opts.get('addremove'):
+if opts.get(b'addremove'):
-dsguard = dirstateguard.dirstateguard(repo, 'commit')
+dsguard = dirstateguard.dirstateguard(repo, b'commit')
 with dsguard or util.nullcontextmanager():
 if dsguard:
 relative = scmutil.anypats(pats, opts)
 uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=relative)
-if scmutil.addremove(repo, matcher, "", uipathfn, opts) != 0:
+if scmutil.addremove(repo, matcher, b"", uipathfn, opts) != 0:
 raise error.Abort(
-_("failed to mark all new/missing files as added/removed")
+_(b"failed to mark all new/missing files as added/removed")
 )
 return commitfunc(ui, repo, message, matcher, opts)
 # amend will reuse the existing user if not specified, but the obsolete
 # marker creation requires that the current user's name is specified.
 if obsolete.isenabled(repo, obsolete.createmarkersopt):
 ui.username()  # raise exception if username not set
-ui.note(_('amending changeset %s\n') % old)
+ui.note(_(b'amending changeset %s\n') % old)
 base = old.p1()
-with repo.wlock(), repo.lock(), repo.transaction('amend'):
+with repo.wlock(), repo.lock(), repo.transaction(b'amend'):
 # Participating changesets:
 #
 # wctx     o - workingctx that contains changes from working copy
 #          |   to go into amending commit
 #          |
 # date-only change should be ignored?
 datemaydiffer = resolvecommitoptions(ui, opts)
 date = old.date()
-if opts.get('date'):
+if opts.get(b'date'):
-date = dateutil.parsedate(opts.get('date'))
+date = dateutil.parsedate(opts.get(b'date'))
-user = opts.get('user') or old.user()
+user = opts.get(b'user') or old.user()
 if len(old.parents()) > 1:
 # ctx.files() isn't reliable for merges, so fall back to the
 # slower repo.status() method
 files = {fn for st in base.status(old)[:3] for fn in st}
 # add/remove the files to the working copy if the "addremove" option
 # was specified.
 matcher = scmutil.match(wctx, pats, opts)
 relative = scmutil.anypats(pats, opts)
 uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=relative)
-if opts.get('addremove') and scmutil.addremove(
+if opts.get(b'addremove') and scmutil.addremove(
-repo, matcher, "", uipathfn, opts
+repo, matcher, b"", uipathfn, opts
 ):
 raise error.Abort(
-_("failed to mark all new/missing files as added/removed")
+_(b"failed to mark all new/missing files as added/removed")
 )
 # Check subrepos. This depends on in-place wctx._status update in
 # subrepo.precommit(). To minimize the risk of this hack, we do
 # nothing if .hgsub does not exist.
-if '.hgsub' in wctx or '.hgsub' in old:
+if b'.hgsub' in wctx or b'.hgsub' in old:
 subs, commitsubs, newsubstate = subrepoutil.precommit(
 ui, wctx, wctx._status, matcher
 )
 # amend should abort if commitsubrepos is enabled
 assert not commitsubs
 mctx = context.memfilectx(
 repo,
 ctx_,
 fctx.path(),
 fctx.data(),
-islink='l' in flags,
+islink=b'l' in flags,
-isexec='x' in flags,
+isexec=b'x' in flags,
 copysource=copied.get(path),
 )
 return mctx
 except KeyError:
 return None
 else:
-ui.note(_('copying changeset %s to %s\n') % (old, base))
+ui.note(_(b'copying changeset %s to %s\n') % (old, base))
 # Use version of files as in the old cset
 def filectxfn(repo, ctx_, path):
 try:
 return old.filectx(path)
 # See if we got a message from -m or -l, if not, open the editor with
 # the message of the changeset to amend.
 message = logmessage(ui, opts)
-editform = mergeeditform(old, 'commit.amend')
+editform = mergeeditform(old, b'commit.amend')
 if not message:
 message = old.description()
 # Default if message isn't provided and --edit is not passed is to
 # invoke editor, but allow --no-edit. If somehow we don't have any
 # description, let's always start the editor.
-doedit = not message or opts.get('edit') in [True, None]
+doedit = not message or opts.get(b'edit') in [True, None]
 else:
 # Default if message is provided is to not invoke editor, but allow
 # --edit.
-doedit = opts.get('edit') is True
+doedit = opts.get(b'edit') is True
 editor = getcommiteditor(edit=doedit, editform=editform)
 pureextra = extra.copy()
-extra['amend_source'] = old.hex()
+extra[b'amend_source'] = old.hex()
 new = context.memctx(
 repo,
 parents=[base.node(), old.p2().node()],
 text=message,
 #
 # This not what we expect from amend.
 return old.node()
 commitphase = None
-if opts.get('secret'):
+if opts.get(b'secret'):
 commitphase = phases.secret
 newid = repo.commitctx(new)
 # Reroute the working copy parent to the new changeset
 repo.setparents(newid, nullid)
 mapping = {old.node(): (newid,)}
 obsmetadata = None
-if opts.get('note'):
+if opts.get(b'note'):
-obsmetadata = {'note': encoding.fromlocal(opts['note'])}
+obsmetadata = {b'note': encoding.fromlocal(opts[b'note'])}
-backup = ui.configbool('rewrite', 'backup-bundle')
+backup = ui.configbool(b'rewrite', b'backup-bundle')
 scmutil.cleanupnodes(
 repo,
 mapping,
-'amend',
+b'amend',
 metadata=obsmetadata,
 fixphase=True,
 targetphase=commitphase,
 backup=backup,
 )
 dirstate.drop(f)
 return newid
-def commiteditor(repo, ctx, subs, editform=''):
+def commiteditor(repo, ctx, subs, editform=b''):
 if ctx.description():
 return ctx.description()
 return commitforceeditor(
 repo, ctx, subs, editform=editform, unchangedmessagedetection=True
 )
 repo,
 ctx,
 subs,
 finishdesc=None,
 extramsg=None,
-editform='',
+editform=b'',
 unchangedmessagedetection=False,
 ):
 if not extramsg:
-extramsg = _("Leave message empty to abort commit.")
+extramsg = _(b"Leave message empty to abort commit.")
-forms = [e for e in editform.split('.') if e]
+forms = [e for e in editform.split(b'.') if e]
-forms.insert(0, 'changeset')
+forms.insert(0, b'changeset')
 templatetext = None
 while forms:
-ref = '.'.join(forms)
+ref = b'.'.join(forms)
-if repo.ui.config('committemplate', ref):
+if repo.ui.config(b'committemplate', ref):
 templatetext = committext = buildcommittemplate(
 repo, ctx, subs, extramsg, ref
 )
 break
 forms.pop()
 ctx.user(),
 ctx.extra(),
 editform=editform,
 pending=pending,
 repopath=repo.path,
-action='commit',
+action=b'commit',
 )
 text = editortext
 # strip away anything below this special string (used for editors that want
 # to display the diff)
 stripbelow = re.search(_linebelow, text, flags=re.MULTILINE)
 if stripbelow:
 text = text[: stripbelow.start()]
-text = re.sub("(?m)^HG:.*(\n|$)", "", text)
+text = re.sub(b"(?m)^HG:.*(\n|$)", b"", text)
 os.chdir(olddir)
 if finishdesc:
 text = finishdesc(text)
 if not text.strip():
-raise error.Abort(_("empty commit message"))
+raise error.Abort(_(b"empty commit message"))
 if unchangedmessagedetection and editortext == templatetext:
-raise error.Abort(_("commit message unchanged"))
+raise error.Abort(_(b"commit message unchanged"))
 return text
 def buildcommittemplate(repo, ctx, subs, extramsg, ref):
 ui = repo.ui
 spec = formatter.templatespec(ref, None, None)
 t = logcmdutil.changesettemplater(ui, repo, spec)
 t.t.cache.update(
 (k, templater.unquotestring(v))
-for k, v in repo.ui.configitems('committemplate')
+for k, v in repo.ui.configitems(b'committemplate')
 )
 if not extramsg:
-extramsg = ''  # ensure that extramsg is string
+extramsg = b''  # ensure that extramsg is string
 ui.pushbuffer()
 t.show(ctx, extramsg=extramsg)
 return ui.popbuffer()
 def hgprefix(msg):
-return "\n".join(["HG: %s" % a for a in msg.split("\n") if a])
+return b"\n".join([b"HG: %s" % a for a in msg.split(b"\n") if a])
 def buildcommittext(repo, ctx, subs, extramsg):
 edittext = []
 modified, added, removed = ctx.modified(), ctx.added(), ctx.removed()
 if ctx.description():
 edittext.append(ctx.description())
-edittext.append("")
+edittext.append(b"")
-edittext.append("")  # Empty line between message and comments.
+edittext.append(b"")  # Empty line between message and comments.
 edittext.append(
 hgprefix(
 _(
-"Enter commit message."
+b"Enter commit message."
-"  Lines beginning with 'HG:' are removed."
+b"  Lines beginning with 'HG:' are removed."
 )
 )
 )
 edittext.append(hgprefix(extramsg))
-edittext.append("HG: --")
+edittext.append(b"HG: --")
-edittext.append(hgprefix(_("user: %s") % ctx.user()))
+edittext.append(hgprefix(_(b"user: %s") % ctx.user()))
 if ctx.p2():
-edittext.append(hgprefix(_("branch merge")))
+edittext.append(hgprefix(_(b"branch merge")))
 if ctx.branch():
-edittext.append(hgprefix(_("branch '%s'") % ctx.branch()))
+edittext.append(hgprefix(_(b"branch '%s'") % ctx.branch()))
 if bookmarks.isactivewdirparent(repo):
-edittext.append(hgprefix(_("bookmark '%s'") % repo._activebookmark))
+edittext.append(hgprefix(_(b"bookmark '%s'") % repo._activebookmark))
-edittext.extend([hgprefix(_("subrepo %s") % s) for s in subs])
+edittext.extend([hgprefix(_(b"subrepo %s") % s) for s in subs])
-edittext.extend([hgprefix(_("added %s") % f) for f in added])
+edittext.extend([hgprefix(_(b"added %s") % f) for f in added])
-edittext.extend([hgprefix(_("changed %s") % f) for f in modified])
+edittext.extend([hgprefix(_(b"changed %s") % f) for f in modified])
-edittext.extend([hgprefix(_("removed %s") % f) for f in removed])
+edittext.extend([hgprefix(_(b"removed %s") % f) for f in removed])
 if not added and not modified and not removed:
-edittext.append(hgprefix(_("no files changed")))
+edittext.append(hgprefix(_(b"no files changed")))
-edittext.append("")
+edittext.append(b"")
-return "\n".join(edittext)
+return b"\n".join(edittext)
 def commitstatus(repo, node, branch, bheads=None, opts=None):
 if opts is None:
 opts = {}
 ctx = repo[node]
 parents = ctx.parents()
 if (
-not opts.get('amend')
+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(_('created new head\n'))
+repo.ui.status(_(b'created new head\n'))
 # The message is not printed for initial roots. For the other
 # changesets, it is printed in the following situations:
 #
 # Par column: for the 2 parents with ...
 #   N: null or no parent
 # C C  y  additional head from merge
 # C H  n  merge with a head
 #
 # H H  n  head merge: head count decreases
-if not opts.get('close_branch'):
+if not opts.get(b'close_branch'):
 for r in parents:
 if r.closesbranch() and r.branch() == branch:
-repo.ui.status(_('reopening closed branch head %d\n') % r.rev())
+repo.ui.status(
+_(b'reopening closed branch head %d\n') % r.rev()
+)
 if repo.ui.debugflag:
-repo.ui.write(_('committed changeset %d:%s\n') % (ctx.rev(), ctx.hex()))
+repo.ui.write(
+_(b'committed changeset %d:%s\n') % (ctx.rev(), ctx.hex())
+)
 elif repo.ui.verbose:
-repo.ui.write(_('committed changeset %d:%s\n') % (ctx.rev(), ctx))
+repo.ui.write(_(b'committed changeset %d:%s\n') % (ctx.rev(), ctx))
 def postcommitstatus(repo, pats, opts):
 return repo.status(match=scmutil.match(repo[None], pats, opts))
 with repo.wlock():
 ## filling of the `names` mapping
 # walk dirstate to fill `names`
-interactive = opts.get('interactive', False)
+interactive = opts.get(b'interactive', False)
 wctx = repo[None]
 m = scmutil.match(wctx, pats, opts)
 # we'll need this later
 targetsubs = sorted(s for s in wctx.substate if m(s))
 def badfn(path, msg):
 if path in names:
 return
 if path in ctx.substate:
 return
-path_ = path + '/'
+path_ = path + b'/'
 for f in names:
 if f.startswith(path_):
 return
-ui.warn("%s: %s\n" % (uipathfn(path), msg))
+ui.warn(b"%s: %s\n" % (uipathfn(path), msg))
 for abs in ctx.walk(matchmod.badmatch(m, badfn)):
 if abs not in names:
 names[abs] = m.exact(abs)
 # if f is a rename, update `names` to also revert the source
 for f in localchanges:
 src = repo.dirstate.copied(f)
 # XXX should we check for rename down to target node?
-if src and src not in names and repo.dirstate[src] == 'r':
+if src and src not in names and repo.dirstate[src] == b'r':
 dsremoved.add(src)
 names[src] = True
 # determine the exact nature of the deleted changesets
 deladded = set(_deleted)
 deleted = _deleted - deladded
 # distinguish between file to forget and the other
 added = set()
 for abs in dsadded:
-if repo.dirstate[abs] != 'a':
+if repo.dirstate[abs] != b'a':
 added.add(abs)
 dsadded -= added
 for abs in deladded:
-if repo.dirstate[abs] == 'a':
+if repo.dirstate[abs] == b'a':
 dsadded.add(abs)
 deladded -= dsadded
 # For files marked as removed, we check if an unknown file is present at
 # the same path. If a such file exists it may need to be backed up.
 dsremoved -= dsremovunk
 # action to be actually performed by revert
 # (<list of file>, message>) tuple
 actions = {
-'revert': ([], _('reverting %s\n')),
+b'revert': ([], _(b'reverting %s\n')),
-'add': ([], _('adding %s\n')),
+b'add': ([], _(b'adding %s\n')),
-'remove': ([], _('removing %s\n')),
+b'remove': ([], _(b'removing %s\n')),
-'drop': ([], _('removing %s\n')),
+b'drop': ([], _(b'removing %s\n')),
-'forget': ([], _('forgetting %s\n')),
+b'forget': ([], _(b'forgetting %s\n')),
-'undelete': ([], _('undeleting %s\n')),
+b'undelete': ([], _(b'undeleting %s\n')),
-'noop': (None, _('no changes needed to %s\n')),
+b'noop': (None, _(b'no changes needed to %s\n')),
-'unknown': (None, _('file not managed: %s\n')),
+b'unknown': (None, _(b'file not managed: %s\n')),
 }
 # "constant" that convey the backup strategy.
 # All set to `discard` if `no-backup` is set do avoid checking
 # no_backup lower in the code.
 # These values are ordered for comparison purposes
 backupinteractive = 3  # do backup if interactively modified
 backup = 2  # unconditionally do backup
 check = 1  # check if the existing file differs from target
 discard = 0  # never do backup
-if opts.get('no_backup'):
+if opts.get(b'no_backup'):
 backupinteractive = backup = check = discard
 if interactive:
 dsmodifiedbackup = backupinteractive
 else:
 dsmodifiedbackup = backup
 tobackup = set()
-backupanddel = actions['remove']
+backupanddel = actions[b'remove']
-if not opts.get('no_backup'):
+if not opts.get(b'no_backup'):
-backupanddel = actions['drop']
+backupanddel = actions[b'drop']
 disptable = (
 # dispatch table:
 #   file state
 #   action
 #   make backup
 ## Sets that results that will change file on disk
 # Modified compared to target, no local change
-(modified, actions['revert'], discard),
+(modified, actions[b'revert'], discard),
 # Modified compared to target, but local file is deleted
-(deleted, actions['revert'], discard),
+(deleted, actions[b'revert'], discard),
 # Modified compared to target, local change
-(dsmodified, actions['revert'], dsmodifiedbackup),
+(dsmodified, actions[b'revert'], dsmodifiedbackup),
 # Added since target
-(added, actions['remove'], discard),
+(added, actions[b'remove'], discard),
 # Added in working directory
-(dsadded, actions['forget'], discard),
+(dsadded, actions[b'forget'], discard),
 # Added since target, have local modification
 (modadded, backupanddel, backup),
 # Added since target but file is missing in working directory
-(deladded, actions['drop'], discard),
+(deladded, actions[b'drop'], discard),
 # Removed since  target, before working copy parent
-(removed, actions['add'], discard),
+(removed, actions[b'add'], discard),
 # Same as `removed` but an unknown file exists at the same path
-(removunk, actions['add'], check),
+(removunk, actions[b'add'], check),
 # Removed since targe, marked as such in working copy parent
-(dsremoved, actions['undelete'], discard),
+(dsremoved, actions[b'undelete'], discard),
 # Same as `dsremoved` but an unknown file exists at the same path
-(dsremovunk, actions['undelete'], check),
+(dsremovunk, actions[b'undelete'], check),
 ## the following sets does not result in any file changes
 # File with no modification
-(clean, actions['noop'], discard),
+(clean, actions[b'noop'], discard),
 # Existing file, not tracked anywhere
-(unknown, actions['unknown'], discard),
+(unknown, actions[b'unknown'], discard),
 )
 for abs, exact in sorted(names.items()):
 # target file to be touch on disk (relative to cwd)
 target = repo.wjoin(abs)
 absbakname = scmutil.backuppath(ui, repo, abs)
 bakname = os.path.relpath(
 absbakname, start=repo.root
 )
 ui.note(
-_('saving current version of %s as %s\n')
+_(b'saving current version of %s as %s\n')
 % (uipathfn(abs), uipathfn(bakname))
 )
-if not opts.get('dry_run'):
+if not opts.get(b'dry_run'):
 if interactive:
 util.copyfile(target, absbakname)
 else:
 util.rename(target, absbakname)
-if opts.get('dry_run'):
+if opts.get(b'dry_run'):
 if ui.verbose or not exact:
 ui.status(msg % uipathfn(abs))
 elif exact:
 ui.warn(msg % uipathfn(abs))
 break
-if not opts.get('dry_run'):
+if not opts.get(b'dry_run'):
-needdata = ('revert', 'add', 'undelete')
+needdata = (b'revert', b'add', b'undelete')
 oplist = [actions[name][0] for name in needdata]
 prefetch = scmutil.prefetchfiles
 matchfiles = scmutil.matchfiles
 prefetch(
 repo,
 wctx.sub(sub).revert(
 ctx.substate[sub], *pats, **pycompat.strkwargs(opts)
 )
 except KeyError:
 raise error.Abort(
-"subrepository '%s' does not exist in %s!"
+b"subrepository '%s' does not exist in %s!"
 % (sub, short(ctx.node()))
 )
 def _performrevert(
 fc = ctx[f]
 repo.wwrite(f, fc.data(), fc.flags())
 def doremove(f):
 try:
-rmdir = repo.ui.configbool('experimental', 'removeemptydirs')
+rmdir = repo.ui.configbool(b'experimental', b'removeemptydirs')
 repo.wvfs.unlinkpath(f, rmdir=rmdir)
 except OSError:
 pass
 repo.dirstate.remove(f)
 exact = names[f]
 if repo.ui.verbose or not exact:
 repo.ui.status(actions[action][1] % uipathfn(f))
 audit_path = pathutil.pathauditor(repo.root, cached=True)
-for f in actions['forget'][0]:
+for f in actions[b'forget'][0]:
 if interactive:
 choice = repo.ui.promptchoice(
-_("forget added file %s (Yn)?$$ &Yes $$ &No") % uipathfn(f)
+_(b"forget added file %s (Yn)?$$ &Yes $$ &No") % uipathfn(f)
 )
 if choice == 0:
-prntstatusmsg('forget', f)
+prntstatusmsg(b'forget', f)
 repo.dirstate.drop(f)
 else:
 excluded_files.append(f)
 else:
-prntstatusmsg('forget', f)
+prntstatusmsg(b'forget', f)
 repo.dirstate.drop(f)
-for f in actions['remove'][0]:
+for f in actions[b'remove'][0]:
 audit_path(f)
 if interactive:
 choice = repo.ui.promptchoice(
-_("remove added file %s (Yn)?$$ &Yes $$ &No") % uipathfn(f)
+_(b"remove added file %s (Yn)?$$ &Yes $$ &No") % uipathfn(f)
 )
 if choice == 0:
-prntstatusmsg('remove', f)
+prntstatusmsg(b'remove', f)
 doremove(f)
 else:
 excluded_files.append(f)
 else:
-prntstatusmsg('remove', f)
+prntstatusmsg(b'remove', f)
 doremove(f)
-for f in actions['drop'][0]:
+for f in actions[b'drop'][0]:
 audit_path(f)
-prntstatusmsg('drop', f)
+prntstatusmsg(b'drop', f)
 repo.dirstate.remove(f)
 normal = None
 if node == parent:
 # We're reverting to our parent. If possible, we'd like status
 normal = repo.dirstate.normal
 newlyaddedandmodifiedfiles = set()
 if interactive:
 # Prompt the user for changes to revert
-torevert = [f for f in actions['revert'][0] if f not in excluded_files]
+torevert = [f for f in actions[b'revert'][0] if f not in excluded_files]
 m = scmutil.matchfiles(repo, torevert)
 diffopts = patch.difffeatureopts(
 repo.ui,
 whitespace=True,
-section='commands',
+section=b'commands',
-configprefix='revert.interactive.',
+configprefix=b'revert.interactive.',
 )
 diffopts.nodates = True
 diffopts.git = True
-operation = 'apply'
+operation = b'apply'
 if node == parent:
 if repo.ui.configbool(
-'experimental', 'revert.interactive.select-to-keep'
+b'experimental', b'revert.interactive.select-to-keep'
 ):
-operation = 'keep'
+operation = b'keep'
 else:
-operation = 'discard'
+operation = b'discard'
-if operation == 'apply':
+if operation == b'apply':
 diff = patch.diff(repo, None, ctx.node(), m, opts=diffopts)
 else:
 diff = patch.diff(repo, ctx.node(), None, m, opts=diffopts)
 originalchunks = patch.parsepatch(diff)
 try:
 chunks, opts = recordfilter(
 repo.ui, originalchunks, match, operation=operation
 )
-if operation == 'discard':
+if operation == b'discard':
 chunks = patch.reversehunks(chunks)
 except error.PatchError as err:
-raise error.Abort(_('error parsing patch: %s') % err)
+raise error.Abort(_(b'error parsing patch: %s') % err)
 # FIXME: when doing an interactive revert of a copy, there's no way of
 # performing a partial revert of the added file, the only option is
 # "remove added file <name> (Yn)?", so we don't need to worry about the
 # alsorestore value. Ideally we'd be able to partially revert
 tobackup = set()
 # Apply changes
 fp = stringio()
 # chunks are serialized per file, but files aren't sorted
 for f in sorted(set(c.header.filename() for c in chunks if ishunk(c))):
-prntstatusmsg('revert', f)
+prntstatusmsg(b'revert', f)
 files = set()
 for c in chunks:
 if ishunk(c):
 abs = c.header.filename()
 # Create a backup file only if this hunk should be backed up
 bakname = scmutil.backuppath(repo.ui, repo, abs)
 util.copyfile(target, bakname)
 tobackup.remove(abs)
 if abs not in files:
 files.add(abs)
-if operation == 'keep':
+if operation == b'keep':
 checkout(abs)
 c.write(fp)
 dopatch = fp.tell()
 fp.seek(0)
 if dopatch:
 patch.internalpatch(repo.ui, repo, fp, 1, eolmode=None)
 except error.PatchError as err:
 raise error.Abort(pycompat.bytestr(err))
 del fp
 else:
-for f in actions['revert'][0]:
+for f in actions[b'revert'][0]:
-prntstatusmsg('revert', f)
+prntstatusmsg(b'revert', f)
 checkout(f)
 if normal:
 normal(f)
-for f in actions['add'][0]:
+for f in actions[b'add'][0]:
 # Don't checkout modified files, they are already created by the diff
 if f not in newlyaddedandmodifiedfiles:
-prntstatusmsg('add', f)
+prntstatusmsg(b'add', f)
 checkout(f)
 repo.dirstate.add(f)
 normal = repo.dirstate.normallookup
 if node == parent and p2 == nullid:
 normal = repo.dirstate.normal
-for f in actions['undelete'][0]:
+for f in actions[b'undelete'][0]:
 if interactive:
 choice = repo.ui.promptchoice(
-_("add back removed file %s (Yn)?$$ &Yes $$ &No") % f
+_(b"add back removed file %s (Yn)?$$ &Yes $$ &No") % f
 )
 if choice == 0:
-prntstatusmsg('undelete', f)
+prntstatusmsg(b'undelete', f)
 checkout(f)
 normal(f)
 else:
 excluded_files.append(f)
 else:
-prntstatusmsg('undelete', f)
+prntstatusmsg(b'undelete', f)
 checkout(f)
 normal(f)
 copied = copies.pathcopies(repo[parent], ctx)
-for f in actions['add'][0] + actions['undelete'][0] + actions['revert'][0]:
+for f in (
+actions[b'add'][0] + actions[b'undelete'][0] + actions[b'revert'][0]
+):
 if f in copied:
 repo.dirstate.copy(copied[f], f)
 # a list of (ui, repo, otherpeer, opts, missing) functions called by
 for s in statemod._unfinishedstates:
 if (
 not s._clearable
 or (commit and s._allowcommit)
-or (s._opname == 'merge' and skipmerge)
+or (s._opname == b'merge' and skipmerge)
 or s._reportonly
 ):
 continue
 if s.isunfinished(repo):
 raise error.Abort(s.msg(), hint=s.hint())
 continue
 if not state._clearable and state.isunfinished(repo):
 raise error.Abort(state.msg(), hint=state.hint())
 for s in statemod._unfinishedstates:
-if s._opname == 'merge' or state._reportonly:
+if s._opname == b'merge' or state._reportonly:
 continue
 if s._clearable and s.isunfinished(repo):
 util.unlink(repo.vfs.join(s._fname))
 continue is supported by the operation.
 Returns a (msg, warning) tuple. 'msg' is a string and 'warning' is
 a boolean.
 '''
-contmsg = _("continue: %s")
+contmsg = _(b"continue: %s")
 for state in statemod._unfinishedstates:
 if not state._continueflag:
 continue
 if state.isunfinished(repo):
 return contmsg % state.continuemsg(), True
 if repo[None].dirty(missing=True, merge=False, branch=False):
-return contmsg % _("hg commit"), False
+return contmsg % _(b"hg commit"), False
 return None, None
 def checkafterresolved(repo):
 '''Inform the user about the next action after completing hg resolve
 Otherwise, it will yield repo.ui.note.
 '''
 msg, warning = howtocontinue(repo)
 if msg is not None:
 if warning:
-repo.ui.warn("%s\n" % msg)
+repo.ui.warn(b"%s\n" % msg)
 else:
-repo.ui.note("%s\n" % msg)
+repo.ui.note(b"%s\n" % msg)
 def wrongtooltocontinue(repo, task):
 '''Raise an abort suggesting how to properly continue if there is an
 active task.
 '''
 after = howtocontinue(repo)
 hint = None
 if after[1]:
 hint = after[0]
-raise error.Abort(_('no %s in progress') % task, hint=hint)
+raise error.Abort(_(b'no %s in progress') % task, hint=hint)
 def abortgraft(ui, repo, graftstate):
 """abort the interrupted graft and rollbacks to the state before interrupted
 graft"""
 if not graftstate.exists():
-raise error.Abort(_("no interrupted graft to abort"))
+raise error.Abort(_(b"no interrupted graft to abort"))
 statedata = readgraftstate(repo, graftstate)
-newnodes = statedata.get('newnodes')
+newnodes = statedata.get(b'newnodes')
 if newnodes is None:
 # and old graft state which does not have all the data required to abort
 # the graft
-raise error.Abort(_("cannot abort using an old graftstate"))
+raise error.Abort(_(b"cannot abort using an old graftstate"))
 # changeset from which graft operation was started
 if len(newnodes) > 0:
 startctx = repo[newnodes[0]].p1()
 else:
-startctx = repo['.']
+startctx = repo[b'.']
 # whether to strip or not
 cleanup = False
 from . import hg
 if newnodes:
 cleanup = True
 # checking that none of the newnodes turned public or is public
 immutable = [c for c in newnodes if not repo[c].mutable()]
 if immutable:
 repo.ui.warn(
-_("cannot clean up public changesets %s\n")
+_(b"cannot clean up public changesets %s\n")
-% ', '.join(bytes(repo[r]) for r in immutable),
+% b', '.join(bytes(repo[r]) for r in immutable),
-hint=_("see 'hg help phases' for details"),
+hint=_(b"see 'hg help phases' for details"),
 )
 cleanup = False
 # checking that no new nodes are created on top of grafted revs
 desc = set(repo.changelog.descendants(newnodes))
 if desc - set(newnodes):
 repo.ui.warn(
 _(
-"new changesets detected on destination "
+b"new changesets detected on destination "
-"branch, can't strip\n"
+b"branch, can't strip\n"
 )
 )
 cleanup = False
 if cleanup:
 with repo.wlock(), repo.lock():
 hg.updaterepo(repo, startctx.node(), overwrite=True)
 # stripping the new nodes created
 strippoints = [
-c.node() for c in repo.set("roots(%ld)", newnodes)
+c.node() for c in repo.set(b"roots(%ld)", newnodes)
 ]
 repair.strip(repo.ui, repo, strippoints, backup=False)
 if not cleanup:
 # we don't update to the startnode if we can't strip
-startctx = repo['.']
+startctx = repo[b'.']
 hg.updaterepo(repo, startctx.node(), overwrite=True)
-ui.status(_("graft aborted\n"))
+ui.status(_(b"graft aborted\n"))
-ui.status(_("working directory is now at %s\n") % startctx.hex()[:12])
+ui.status(_(b"working directory is now at %s\n") % startctx.hex()[:12])
 graftstate.delete()
 return 0
 def readgraftstate(repo, graftstate):
 """read the graft state file and return a dict of the data stored in it"""
 try:
 return graftstate.read()
 except error.CorruptedState:
-nodes = repo.vfs.read('graftstate').splitlines()
+nodes = repo.vfs.read(b'graftstate').splitlines()
-return {'nodes': nodes}
+return {b'nodes': nodes}
 def hgabortgraft(ui, repo):
 """ abort logic for aborting graft using 'hg abort'"""
 with repo.wlock():
-graftstate = statemod.cmdstate(repo, 'graftstate')
+graftstate = statemod.cmdstate(repo, b'graftstate')
 return abortgraft(ui, repo, graftstate)

Mercurial > public > mercurial-scm > hg

comparison mercurial/cmdutil.py @ 43077:687b865b95ad