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

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 stringio = util.stringio
 # templates of common command options
 dryrunopts = [
-('n', 'dry-run', None,
+('n', 'dry-run', None, _('do not perform actions, just print output')),
-_('do not perform actions, just print output')),
 ]
 confirmopts = [
-('', 'confirm', None,
+('', 'confirm', None, _('ask before applying actions')),
-_('ask before applying actions')),
 ]
 remoteopts = [
-('e', 'ssh', '',
+('e', 'ssh', '', _('specify ssh command to use'), _('CMD')),
-_('specify ssh command to use'), _('CMD')),
+(
-('', 'remotecmd', '',
+'',
-_('specify hg command to run on the remote side'), _('CMD')),
+'remotecmd',
-('', 'insecure', None,
+'',
-_('do not verify server certificate (ignoring web.cacerts config)')),
+_('specify hg command to run on the remote side'),
+_('CMD'),
+),
+(
+'',
+'insecure',
+None,
+_('do not verify server certificate (ignoring web.cacerts config)'),
+),
 ]
 walkopts = [
-('I', 'include', [],
+(
-_('include names matching the given patterns'), _('PATTERN')),
+'I',
-('X', 'exclude', [],
+'include',
-_('exclude names matching the given patterns'), _('PATTERN')),
+[],
+_('include names matching the given patterns'),
+_('PATTERN'),
+),
+(
+'X',
+'exclude',
+[],
+_('exclude names matching the given patterns'),
+_('PATTERN'),
+),
 ]
 commitopts = [
-('m', 'message', '',
+('m', 'message', '', _('use text as commit message'), _('TEXT')),
-_('use text as commit message'), _('TEXT')),
+('l', 'logfile', '', _('read commit message from file'), _('FILE')),
-('l', 'logfile', '',
-_('read commit message from file'), _('FILE')),
 ]
 commitopts2 = [
-('d', 'date', '',
+('d', 'date', '', _('record the specified date as commit date'), _('DATE')),
-_('record the specified date as commit date'), _('DATE')),
+('u', 'user', '', _('record the specified user as committer'), _('USER')),
-('u', 'user', '',
-_('record the specified user as committer'), _('USER')),
 ]
 commitopts3 = [
-(b'D', b'currentdate', None,
+(b'D', b'currentdate', None, _(b'record the current date as commit date')),
-_(b'record the current date as commit date')),
+(b'U', b'currentuser', None, _(b'record the current user as committer')),
-(b'U', b'currentuser', None,
-_(b'record the current user as committer')),
 ]
 formatteropts = [
-('T', 'template', '',
+('T', 'template', '', _('display with template'), _('TEMPLATE')),
-_('display with template'), _('TEMPLATE')),
 ]
 templateopts = [
-('', 'style', '',
+(
-_('display using template map file (DEPRECATED)'), _('STYLE')),
+'',
-('T', 'template', '',
+'style',
-_('display with template'), _('TEMPLATE')),
+'',
+_('display using template map file (DEPRECATED)'),
+_('STYLE'),
+),
+('T', 'template', '', _('display with template'), _('TEMPLATE')),
 ]
 logopts = [
 ('p', 'patch', None, _('show patch')),
 ('g', 'git', None, _('use git extended diff format')),
-('l', 'limit', '',
+('l', 'limit', '', _('limit number of changes displayed'), _('NUM')),
-_('limit number of changes displayed'), _('NUM')),
 ('M', 'no-merges', None, _('do not show merges')),
 ('', 'stat', None, _('output diffstat-style summary of changes')),
 ('G', 'graph', None, _("show the revision DAG")),
 ] + templateopts
 diffopts = [
 ('a', 'text', None, _('treat all files as text')),
 ('g', 'git', None, _('use git extended diff format')),
 ('', 'binary', None, _('generate binary diffs in git mode (default)')),
-('', 'nodates', None, _('omit dates from diff headers'))
+('', 'nodates', None, _('omit dates from diff headers')),
 ]
 diffwsopts = [
-('w', 'ignore-all-space', None,
+(
-_('ignore white space when comparing lines')),
+'w',
-('b', 'ignore-space-change', None,
+'ignore-all-space',
-_('ignore changes in the amount of white space')),
+None,
-('B', 'ignore-blank-lines', None,
+_('ignore white space when comparing lines'),
-_('ignore changes whose lines are all blank')),
+),
-('Z', 'ignore-space-at-eol', None,
+(
-_('ignore changes in whitespace at EOL')),
+'b',
+'ignore-space-change',
+None,
+_('ignore changes in the amount of white space'),
+),
+(
+'B',
+'ignore-blank-lines',
+None,
+_('ignore changes whose lines are all blank'),
+),
+(
+'Z',
+'ignore-space-at-eol',
+None,
+_('ignore changes in whitespace at EOL'),
+),
 ]
-diffopts2 = [
+diffopts2 = (
-('', 'noprefix', None, _('omit a/ and b/ prefixes from filenames')),
+[
-('p', 'show-function', None, _('show which function each change is in')),
+('', 'noprefix', None, _('omit a/ and b/ prefixes from filenames')),
-('', 'reverse', None, _('produce a diff that undoes the changes')),
+(
-] + diffwsopts + [
+'p',
-('U', 'unified', '',
+'show-function',
-_('number of lines of context to show'), _('NUM')),
+None,
-('', 'stat', None, _('output diffstat-style summary of changes')),
+_('show which function each change is in'),
-('', 'root', '', _('produce diffs relative to subdirectory'), _('DIR')),
+),
-]
+('', 'reverse', None, _('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')),
+('', 'root', '', _('produce diffs relative to subdirectory'), _('DIR')),
+]
+)
 mergetoolopts = [
 ('t', 'tool', '', _('specify merge tool'), _('TOOL')),
 ]
 similarityopts = [
-('s', 'similarity', '',
+(
-_('guess renamed files by similarity (0<=s<=100)'), _('SIMILARITY'))
+'s',
+'similarity',
+'',
+_('guess renamed files by similarity (0<=s<=100)'),
+_('SIMILARITY'),
+)
 ]
-subrepoopts = [
+subrepoopts = [('S', 'subrepos', None, _('recurse into subrepositories'))]
-('S', 'subrepos', None,
-_('recurse into subrepositories'))
-]
 debugrevlogopts = [
 ('c', 'changelog', False, _('open changelog')),
 ('m', 'manifest', False, _('open manifest')),
 ('', 'dir', '', _('open directory manifest')),
 # special string such that everything below this line will be ingored in the
 # editor text
 _linebelow = "^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'):
-raise error.Abort(_('--date and --currentdate are mutually '
+raise error.Abort(
-'exclusive'))
+_('--date and --currentdate are mutually ' 'exclusive')
+)
 if opts.get(b'user') and opts.get(b'currentuser'):
-raise error.Abort(_('--user and --currentuser are mutually '
+raise error.Abort(
-'exclusive'))
+_('--user and --currentuser are mutually ' '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')
+elif (
-and ui.configbool('rewrite', 'update-timestamp')
+not opts.get('date')
-and opts.get('currentdate') is None):
+and ui.configbool('rewrite', 'update-timestamp')
+and opts.get('currentdate') is None
+):
 opts[b'date'] = b'%d %d' % dateutil.makedate()
 datemaydiffer = True
 if opts.get(b'currentuser'):
 opts[b'user'] = ui.username()
 return datemaydiffer
 def checknotesize(ui, opts):
 """ make sure note is of valid format """
 note = opts.get('note')
 if len(note) > 255:
 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 ishunk(x):
 hunkclasses = (crecordmod.uihunk, patch.recordhunk)
 return isinstance(x, hunkclasses)
 def newandmodified(chunks, originalchunks):
 newlyaddedandmodifiedfiles = set()
 alsorestore = set()
 for chunk in chunks:
-if (ishunk(chunk) and chunk.header.isnewfile() and chunk not in
+if (
-originalchunks):
+ishunk(chunk)
+and chunk.header.isnewfile()
+and chunk not in originalchunks
+):
 newlyaddedandmodifiedfiles.add(chunk.header.filename())
-alsorestore.update(set(chunk.header.files()) -
+alsorestore.update(
-{chunk.header.filename()})
+set(chunk.header.files()) - {chunk.header.filename()}
+)
 return newlyaddedandmodifiedfiles, alsorestore
 def parsealiases(cmd):
 return cmd.split("|")
 def setupwrapcolorwrite(ui):
 # wrap ui.write so diff output can be labeled/colorized
 def wrapwrite(orig, *args, **kw):
 label = kw.pop(r'label', '')
 for chunk, l in patch.difflabel(lambda: args):
 orig(chunk, label=label + l)
 oldwrite = ui.write
 def wrap(*args, **kwargs):
 return wrapwrite(oldwrite, *args, **kwargs)
 setattr(ui, 'write', wrap)
 return oldwrite
-def filterchunks(ui, originalhunks, usecurses, testfile, match,
-operation=None):
+def filterchunks(ui, originalhunks, usecurses, testfile, match, operation=None):
 try:
 if usecurses:
 if testfile:
 recordfn = crecordmod.testdecorator(
-testfile, crecordmod.testchunkselector)
+testfile, crecordmod.testchunkselector
+)
 else:
 recordfn = crecordmod.chunkselector
-return crecordmod.filterpatch(ui, originalhunks, recordfn,
+return crecordmod.filterpatch(
-operation)
+ui, originalhunks, recordfn, operation
+)
 except crecordmod.fallbackerror as e:
 ui.warn('%s\n' % e.message)
 ui.warn(_('falling back to text mode\n'))
 return patch.filterpatch(ui, originalhunks, match, operation)
 def recordfilter(ui, originalhunks, match, operation=None):
 """ Prompts the user to filter the originalhunks and return a list of
 selected hunks.
 *operation* is used for to build ui messages to indicate the user what
 """
 usecurses = crecordmod.checkcurses(ui)
 testfile = ui.config('experimental', 'crecordtest')
 oldwrite = setupwrapcolorwrite(ui)
 try:
-newchunks, newopts = filterchunks(ui, originalhunks, usecurses,
+newchunks, newopts = filterchunks(
-testfile, match, operation)
+ui, originalhunks, usecurses, testfile, match, operation
+)
 finally:
 ui.write = oldwrite
 return newchunks, newopts
-def dorecord(ui, repo, commitfunc, cmdsuggest, backupall,
-filterfn, *pats, **opts):
+def dorecord(
+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
 else:
 msg = _('running non-interactively')
 raise error.Abort(msg)
 # make sure username is set before going interactive
 if not opts.get('user'):
-ui.username() # raise exception, username not provided
+ui.username()  # raise exception, username not provided
 def recordfunc(ui, repo, message, match, opts):
 """This is generic record driver.
 Its job is to interactively filter local changes, and
 if not opts.get('interactive-unshelve'):
 checkunfinished(repo, commit=True)
 wctx = repo[None]
 merge = len(wctx.parents()) > 1
 if merge:
-raise error.Abort(_('cannot partially commit a merge '
+raise error.Abort(
-'(use "hg commit" instead)'))
+_(
+'cannot partially commit a merge '
+'(use "hg commit" instead)'
+)
+)
 def fail(f, msg):
 raise error.Abort('%s: %s' % (f, msg))
 force = opts.get('force')
 overrides = {(b'ui', b'commitsubrepos'): True}
 with repo.ui.configoverride(overrides, b'record'):
 # subrepoutil.precommit() modifies the status
-tmpstatus = scmutil.status(copymod.copy(status[0]),
+tmpstatus = scmutil.status(
-copymod.copy(status[1]),
+copymod.copy(status[0]),
-copymod.copy(status[2]),
+copymod.copy(status[1]),
-copymod.copy(status[3]),
+copymod.copy(status[2]),
-copymod.copy(status[4]),
+copymod.copy(status[3]),
-copymod.copy(status[5]),
+copymod.copy(status[4]),
-copymod.copy(status[6]))
+copymod.copy(status[5]),
+copymod.copy(status[6]),
+)
 # Force allows -X subrepo to skip the subrepo.
 subs, commitsubs, newstate = subrepoutil.precommit(
-repo.ui, wctx, tmpstatus, match, force=True)
+repo.ui, wctx, tmpstatus, match, force=True
+)
 for s in subs:
 if s in commitsubs:
 dirtyreason = wctx.sub(s).dirtyreason(True)
 raise error.Abort(dirtyreason)
 if not force:
 repo.checkcommitpatterns(wctx, vdirs, match, status, fail)
-diffopts = patch.difffeatureopts(ui, opts=opts, whitespace=True,
+diffopts = patch.difffeatureopts(
-section='commands',
+ui,
-configprefix='commit.interactive.')
+opts=opts,
+whitespace=True,
+section='commands',
+configprefix='commit.interactive.',
+)
 diffopts.nodates = True
 diffopts.git = True
 diffopts.showfunc = True
 originaldiff = patch.diff(repo, changes=status, opts=diffopts)
 originalchunks = patch.parsepatch(originaldiff)
 # 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
 # files that were the sources of renames so that the patch application
 # works.
-newlyaddedandmodifiedfiles, alsorestore = newandmodified(chunks,
+newlyaddedandmodifiedfiles, alsorestore = newandmodified(
-originalchunks)
+chunks, originalchunks
+)
 contenders = set()
 for h in chunks:
 try:
 contenders.update(set(h.files()))
 except AttributeError:
 # 2. backup changed files, so we can restore them in the end
 if backupall:
 tobackup = changed
 else:
-tobackup = [f for f in newfiles if f in modified or f in
+tobackup = [
-newlyaddedandmodifiedfiles]
+f
+for f in newfiles
+if f in modified or f in newlyaddedandmodifiedfiles
+]
 backups = {}
 if tobackup:
 backupdir = repo.vfs.join('record-backups')
 try:
 os.mkdir(backupdir)
 if err.errno != errno.EEXIST:
 raise
 try:
 # backup continues
 for f in tobackup:
-fd, tmpname = pycompat.mkstemp(prefix=f.replace('/', '_') + '.',
+fd, tmpname = pycompat.mkstemp(
-dir=backupdir)
+prefix=f.replace('/', '_') + '.', dir=backupdir
+)
 os.close(fd)
 ui.debug('backup %r as %r\n' % (f, tmpname))
 util.copyfile(repo.wjoin(f), tmpname, copystat=True)
 backups[f] = tmpname
 dopatch = fp.tell()
 fp.seek(0)
 # 2.5 optionally review / modify patch in text editor
 if opts.get('review', False):
-patchtext = (crecordmod.diffhelptext
+patchtext = (
-+ crecordmod.patchhelptext
+crecordmod.diffhelptext
-+ fp.read())
++ crecordmod.patchhelptext
-reviewedpatch = ui.edit(patchtext, "",
++ fp.read()
-action="diff",
+)
-repopath=repo.path)
+reviewedpatch = ui.edit(
+patchtext, "", action="diff", repopath=repo.path
+)
 fp.truncate(0)
 fp.write(reviewedpatch)
 fp.seek(0)
 [os.unlink(repo.wjoin(c)) for c in newlyaddedandmodifiedfiles]
 # 3a. apply filtered patch to clean repo  (clean)
 if backups:
 # Equivalent to hg.revert
 m = scmutil.matchfiles(repo, set(backups.keys()) | alsorestore)
-mergemod.update(repo, repo.dirstate.p1(), branchmerge=False,
+mergemod.update(
-force=True, matcher=m)
+repo,
+repo.dirstate.p1(),
+branchmerge=False,
+force=True,
+matcher=m,
+)
 # 3b. (apply)
 if dopatch:
 try:
 ui.debug('applying patch\n')
 with repo.wlock():
 return recordfunc(ui, repo, message, match, opts)
 return commit(ui, repo, recordinwlock, pats, opts)
 class dirnode(object):
 """
 Represent a directory in user working copy with information required for
 the purpose of tersing its status.
 # add the files to status list
 for st, fpath in self.iterfilepaths():
 yield st, fpath
-#recurse on the subdirs
+# recurse on the subdirs
 for dirobj in self.subdirs.values():
 for st, fpath in dirobj.tersewalk(terseargs):
 yield st, fpath
 def tersedir(statuslist, terseargs):
 """
 Terse the status if all the files in a directory shares the same status.
 if s not in allst:
 raise error.Abort(_("'%s' not recognized") % s)
 # creating a dirnode object for the root of the repo
 rootobj = dirnode('')
-pstatus = ('modified', 'added', 'deleted', 'clean', 'unknown',
+pstatus = (
-'ignored', 'removed')
+'modified',
+'added',
+'deleted',
+'clean',
+'unknown',
+'ignored',
+'removed',
+)
 tersedict = {}
 for attrname in pstatus:
 statuschar = attrname[0:1]
 for f in getattr(statuslist, attrname):
 tersedict[st].sort()
 tersedlist.append(tersedict[st])
 return tersedlist
 def _commentlines(raw):
 '''Surround lineswith a comment char and a new line'''
 lines = raw.splitlines()
 commentedlines = ['# %s' % line for line in lines]
 return '\n'.join(commentedlines) + '\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(
-['    %s' % util.pathto(repo.root, encoding.getcwd(), path)
+[
-for path in sorted(unresolvedlist)])
+'    %s' % util.pathto(repo.root, encoding.getcwd(), path)
-msg = _('''Unresolved merge conflicts:
+for path in sorted(unresolvedlist)
+]
+)
+msg = (
+_(
+'''Unresolved merge conflicts:
 %s
-To mark files as resolved:  hg resolve --mark FILE''') % mergeliststr
+To mark files as resolved:  hg resolve --mark FILE'''
+)
+% mergeliststr
+)
 else:
 msg = _('No unresolved merge conflicts.')
 return _commentlines(msg)
 def morestatus(repo, fm):
 statetuple = statemod.getrepostate(repo)
 label = 'status.morestatus'
 if statetuple:
 conmsg = _conflictsmsg(repo)
 if conmsg:
 fm.plain('%s\n' % conmsg, label=label)
 if helpfulmsg:
 fm.plain('%s\n' % _commentlines(helpfulmsg), label=label)
 def findpossible(cmd, table, strict=False):
 """
 Return cmd -> (aliases, command table entry)
 for each matching command.
 if not choice and debugchoice:
 choice = debugchoice
 return choice, allcmds
 def findcmd(cmd, table, strict=True):
 """Return (aliases, command table entry) for command string."""
 choice, allcmds = findpossible(cmd, table, strict)
 if cmd in choice:
 if choice:
 return list(choice.values())[0]
 raise error.UnknownCommand(cmd, allcmds)
 def changebranch(ui, repo, revs, label):
 """ Change the branch name of given revs to label """
 with repo.wlock(), repo.lock(), repo.transaction('branches'):
 replacements = {}
 # avoid import cycle mercurial.cmdutil -> mercurial.context ->
 # mercurial.subrepo -> mercurial.cmdutil
 from . import context
 for rev in revs:
 ctx = repo[rev]
 oldbranch = ctx.branch()
 # check if ctx has same branch
 if oldbranch == label:
 try:
 return ctx[path]
 except error.ManifestLookupError:
 return None
-ui.debug("changing branch of '%s' from '%s' to '%s'\n"
+ui.debug(
-% (hex(ctx.node()), oldbranch, label))
+"changing branch of '%s' from '%s' to '%s'\n"
+% (hex(ctx.node()), oldbranch, label)
+)
 extra = ctx.extra()
 extra['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
 if p1 in replacements:
 p1 = replacements[p1][0]
 if p2 in replacements:
 p2 = replacements[p2][0]
-mc = context.memctx(repo, (p1, p2),
+mc = context.memctx(
-ctx.description(),
+repo,
-ctx.files(),
+(p1, p2),
-filectxfn,
+ctx.description(),
-user=ctx.user(),
+ctx.files(),
-date=ctx.date(),
+filectxfn,
-extra=extra,
+user=ctx.user(),
-branch=label)
+date=ctx.date(),
+extra=extra,
+branch=label,
+)
 newnode = repo.commitctx(mc)
 replacements[ctx.node()] = (newnode,)
 ui.debug('new node id is %s\n' % hex(newnode))
 newid = replacements.get(wctx.p1().node())
 if newid is not None:
 # avoid import cycle mercurial.cmdutil -> mercurial.hg ->
 # mercurial.cmdutil
 from . import hg
 hg.update(repo, newid[0], quietempty=True)
 ui.status(_("changed branch on %d changesets\n") % len(replacements))
 def findrepo(p):
 while not os.path.isdir(os.path.join(p, ".hg")):
 oldp, p = p, os.path.dirname(p)
 if p == oldp:
 return None
 return p
 def bailifchanged(repo, merge=True, hint=None):
 """ enforce the precondition that working directory must be clean.
 'merge' can be set to false if a pending uncommitted merge should be
 raise error.Abort(_('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')
 logfile = opts.get('logfile')
 if message and logfile:
-raise error.Abort(_('options --message and --logfile are mutually '
+raise error.Abort(
-'exclusive'))
+_('options --message and --logfile are mutually ' 'exclusive')
+)
 if not message and logfile:
 try:
 if isstdiofilename(logfile):
 message = ui.fin.read()
 else:
 message = '\n'.join(util.readfile(logfile).splitlines())
 except IOError as inst:
-raise error.Abort(_("can't read commit message '%s': %s") %
+raise error.Abort(
-(logfile, encoding.strtolocal(inst.strerror)))
+_("can't read commit message '%s': %s")
+% (logfile, encoding.strtolocal(inst.strerror))
+)
 return message
 def mergeeditform(ctxorbool, baseformname):
 """return appropriate editform name (referencing a committemplate)
 'ctxorbool' is either a ctx to be committed, or a bool indicating whether
 elif len(ctxorbool.parents()) > 1:
 return baseformname + ".merge"
 return baseformname + ".normal"
-def getcommiteditor(edit=False, finishdesc=None, extramsg=None,
-editform='', **opts):
+def getcommiteditor(
+edit=False, finishdesc=None, extramsg=None, editform='', **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
 before checking empty-ness. It should return actual text to be
 'getcommiteditor' returns 'commitforceeditor' regardless of
 'edit', if one of 'finishdesc' or 'extramsg' is specified, because
 they are specific for usage in MQ.
 """
 if edit or finishdesc or extramsg:
-return lambda r, c, s: commitforceeditor(r, c, s,
+return lambda r, c, s: commitforceeditor(
-finishdesc=finishdesc,
+r, c, s, finishdesc=finishdesc, extramsg=extramsg, editform=editform
-extramsg=extramsg,
+)
-editform=editform)
 elif editform:
 return lambda r, c, s: commiteditor(r, c, s, editform=editform)
 else:
 return commiteditor
 def _escapecommandtemplate(tmpl):
 parts = []
 for typ, start, end in templater.scantemplate(tmpl, raw=True):
 if typ == b'string':
 parts.append(stringutil.escapestr(tmpl[start:end]))
 else:
 parts.append(tmpl[start:end])
 return b''.join(parts)
 def rendercommandtemplate(ui, tmpl, props):
 r"""Expand a literal template 'tmpl' in a way suitable for command line
 '\' in outermost string is not taken as an escape character because it
 if not tmpl:
 return tmpl
 t = formatter.maketemplater(ui, _escapecommandtemplate(tmpl))
 return t.renderdefault(props)
 def rendertemplate(ctx, tmpl, props=None):
 """Expand a literal template 'tmpl' byte-string against one changeset
 Each props item must be a stringify-able value or a callable returning
 such value, i.e. no bare list nor dict should be passed.
 """
 repo = ctx.repo()
 tres = formatter.templateresources(repo.ui, repo)
-t = formatter.maketemplater(repo.ui, tmpl, defaults=templatekw.keywords,
+t = formatter.maketemplater(
-resources=tres)
+repo.ui, tmpl, defaults=templatekw.keywords, resources=tres
+)
 mapping = {'ctx': ctx}
 if props:
 mapping.update(props)
 return t.renderdefault(mapping)
 def _buildfntemplate(pat, total=None, seqno=None, revwidth=None, pathname=None):
 r"""Convert old-style filename format string to template string
 >>> _buildfntemplate(b'foo-%b-%n.patch', seqno=0)
 if n < 0:
 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 "
+raise error.Abort(
-"filename"))
+_("incomplete format spec in output " "filename")
-c = pat[n + 1:n + 2]
+)
+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 "
+raise error.Abort(
-"filename") % c)
+_("invalid format spec '%%%s' in output " "filename") % c
+)
 return ''.join(newname)
 def makefilename(ctx, pat, **props):
 if not pat:
 return pat
 tmpl = _buildfntemplate(pat, **props)
 # BUG: alias expansion shouldn't be made against template fragments
 # rewritten from %-format strings, but we have no easy way to partially
 # disable the expansion.
 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 == '-'
 class _unclosablefile(object):
 def __init__(self, fp):
 self._fp = fp
 def close(self):
 def __enter__(self):
 return self
 def __exit__(self, exc_type, exc_value, exc_tb):
 pass
 def makefileobj(ctx, pat, mode='wb', **props):
 writable = mode not in ('r', 'rb')
 if isstdiofilename(pat):
 else:
 fp = repo.ui.fin
 return _unclosablefile(fp)
 fn = makefilename(ctx, pat, **props)
 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']
 mf = opts['manifest']
 msg = _('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')
 elif not repo:
-msg = _('cannot specify --changelog or --manifest or --dir '
+msg = _(
-'without a repository')
+'cannot specify --changelog or --manifest or --dir '
+'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:
-raise error.Abort(_("--dir can only be used on repos with "
+raise error.Abort(
-"treemanifest enabled"))
+_(
+"--dir can only be used on repos with "
+"treemanifest enabled"
+)
+)
 if not dir.endswith('/'):
 dir = dir + '/'
 dirlog = repo.manifestlog.getstorage(dir)
 if len(dirlog):
 r = dirlog
 if not file_:
 raise error.CommandError(cmd, _('invalid arguments'))
 if not os.path.isfile(file_):
 raise error.Abort(_("revlog '%s' not found") % file_)
-r = revlog.revlog(vfsmod.vfs(encoding.getcwd(), audit=False),
+r = revlog.revlog(
-file_[:-2] + ".i")
+vfsmod.vfs(encoding.getcwd(), audit=False), file_[:-2] + ".i"
+)
 return r
 def openrevlog(repo, cmd, file_, opts):
 """Obtain a revlog backing storage of an item.
 This is similar to ``openstorage()`` except it always returns a revlog.
 revlog backing it. Therefore, this function should only be used by code
 that needs to examine low-level revlog implementation details. e.g. debug
 commands.
 """
 return openstorage(repo, cmd, file_, opts, returnrevlog=True)
 def copy(ui, repo, pats, opts, rename=False):
 # called with the repo lock held
 #
 # hgsep => pathname that uses "/" to separate directories
 after = opts.get("after")
 dryrun = opts.get("dry_run")
 wctx = repo[None]
 uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=True)
 def walkpat(pat):
 srcs = []
 if after:
 badstates = '?'
 else:
 exact = m.exact(abs)
 if state in badstates:
 if exact and state == '?':
 ui.warn(_('%s: not copying - file is not managed\n') % rel)
 if exact and state == 'r':
-ui.warn(_('%s: not copying - file has been marked for'
+ui.warn(
-' remove\n') % rel)
+_(
+'%s: not copying - file has been marked for'
+' remove\n'
+)
+% rel
+)
 continue
 # abs: hgsep
 # rel: ossep
 srcs.append((abs, rel, exact))
 return srcs
 scmutil.checkportable(ui, abstarget)
 # check for collisions
 prevsrc = targets.get(abstarget)
 if prevsrc is not None:
-ui.warn(_('%s: not overwriting - %s collides with %s\n') %
+ui.warn(
-(reltarget, repo.pathto(abssrc, cwd),
+_('%s: not overwriting - %s collides with %s\n')
-repo.pathto(prevsrc, cwd)))
+% (
-return True # report a failure
+reltarget,
+repo.pathto(abssrc, cwd),
+repo.pathto(prevsrc, cwd),
+)
+)
+return True  # report a failure
 # check for overwrites
 exists = os.path.lexists(target)
 samefile = False
 if exists and abssrc != abstarget:
-if (repo.dirstate.normalize(abssrc) ==
+if repo.dirstate.normalize(abssrc) == repo.dirstate.normalize(
-repo.dirstate.normalize(abstarget)):
+abstarget
+):
 if not rename:
 ui.warn(_("%s: can't copy - same file\n") % reltarget)
-return True # report a failure
+return True  # report a failure
 exists = False
 samefile = True
 if not after and exists or after and state in 'mn':
 if not opts['force']:
 if after:
 flags = '--after --force'
 else:
 flags = '--force'
 if rename:
-hint = _("('hg rename %s' to replace the file by "
+hint = (
-'recording a rename)\n') % flags
+_(
+"('hg rename %s' to replace the file by "
+'recording a rename)\n'
+)
+% flags
+)
 else:
-hint = _("('hg copy %s' to replace the file by "
+hint = (
-'recording a copy)\n') % flags
+_(
+"('hg copy %s' to replace the file by "
+'recording a copy)\n'
+)
+% flags
+)
 else:
 msg = _('%s: not overwriting - file exists\n')
 if rename:
 hint = _("('hg rename --after' to record the rename)\n")
 else:
 hint = _("('hg copy --after' to record the copy)\n")
 ui.warn(msg % reltarget)
 ui.warn(hint)
-return True # report a failure
+return True  # report a failure
 if after:
 if not exists:
 if rename:
-ui.warn(_('%s: not recording move - %s does not exist\n') %
+ui.warn(
-(relsrc, reltarget))
+_('%s: not recording move - %s does not exist\n')
+% (relsrc, reltarget)
+)
 else:
-ui.warn(_('%s: not recording copy - %s does not exist\n') %
+ui.warn(
-(relsrc, reltarget))
+_('%s: not recording copy - %s does not exist\n')
-return True # report a failure
+% (relsrc, reltarget)
+)
+return True  # report a failure
 elif not dryrun:
 try:
 if exists:
 os.unlink(target)
 targetdir = os.path.dirname(target) or '.'
 except IOError as inst:
 if inst.errno == errno.ENOENT:
 ui.warn(_('%s: deleted in working directory\n') % relsrc)
 srcexists = False
 else:
-ui.warn(_('%s: cannot copy - %s\n') %
+ui.warn(
-(relsrc, encoding.strtolocal(inst.strerror)))
+_('%s: cannot copy - %s\n')
-return True # report a failure
+% (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))
 else:
 ui.status(_('copying %s to %s\n') % (relsrc, reltarget))
 targets[abstarget] = abssrc
 # fix up dirstate
-scmutil.dirstatecopy(ui, repo, wctx, abssrc, abstarget,
+scmutil.dirstatecopy(
-dryrun=dryrun, cwd=cwd)
+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')
 repo.wvfs.unlinkpath(abssrc, rmdir=rmdir)
 wctx.forget([abssrc])
 striplen = len(abspfx)
 if striplen:
 striplen += len(pycompat.ossep)
 res = lambda p: os.path.join(dest, util.localpath(p)[striplen:])
 elif destdirexists:
-res = lambda p: os.path.join(dest,
+res = lambda p: os.path.join(
-os.path.basename(util.localpath(p)))
+dest, os.path.basename(util.localpath(p))
+)
 else:
 res = lambda p: dest
 return res
 # pat: ossep
 # srcs: list of (hgsep, hgsep, ossep, bool)
 # return: function that takes hgsep and returns ossep
 def targetpathafterfn(pat, dest, srcs):
 if matchmod.patkind(pat):
 # a mercurial pattern
-res = lambda p: os.path.join(dest,
+res = lambda p: os.path.join(
-os.path.basename(util.localpath(p)))
+dest, os.path.basename(util.localpath(p))
+)
 else:
 abspfx = pathutil.canonpath(repo.root, cwd, pat)
 if len(abspfx) < len(srcs[0][0]):
 # A directory. Either the target path contains the last
 # component of the source path or it does not.
 striplen1 = len(os.path.split(abspfx)[0])
 if striplen1:
 striplen1 += len(pycompat.ossep)
 if evalpath(striplen1) > score:
 striplen = striplen1
-res = lambda p: os.path.join(dest,
+res = lambda p: os.path.join(dest, util.localpath(p)[striplen:])
-util.localpath(p)[striplen:])
 else:
 # a file
 if destdirexists:
-res = lambda p: os.path.join(dest,
+res = lambda p: os.path.join(
-os.path.basename(util.localpath(p)))
+dest, os.path.basename(util.localpath(p))
+)
 else:
 res = lambda p: dest
 return res
 pats = scmutil.expandpats(pats)
 raise error.Abort(_('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 '
+raise error.Abort(
-'existing directory'))
+_(
+'with multiple sources, destination must be an '
+'existing directory'
+)
+)
 if util.endswithsep(dest):
 raise error.Abort(_('destination %s is not a directory') % dest)
 tfn = targetpathfn
 if after:
 if copyfile(abssrc, relsrc, targetpath(abssrc), exact):
 errors += 1
 return errors != 0
 ## facility to let extension process additional data into an import patch
 # list of identifier to be executed in order
 extrapreimport = []  # run before commit
-extrapostimport = [] # run after commit
+extrapostimport = []  # run after commit
 # mapping from identifier to actual import function
 #
 # 'preimport' are run before the commit is made and are provided the following
 # arguments:
 # - repo: the localrepository instance,
 extrapreimportmap = {}
 # 'postimport' are run after the commit is made and are provided the following
 # argument:
 # - ctx: the changectx created by import.
 extrapostimportmap = {}
 def tryimportone(ui, repo, patchdata, parents, opts, msgs, updatefunc):
 """Utility function used by commands.import to import a single patch
 This function is explicitly defined here to help the evolve extension to
 p1 = parents[0]
 p2 = repo[nullid]
 except error.RepoError:
 p1, p2 = parents
 if p2.node() == nullid:
-ui.warn(_("warning: import the patch as a normal revision\n"
+ui.warn(
-"(use --exact to import the patch as a merge)\n"))
+_(
+"warning: import the patch as a normal revision\n"
+"(use --exact to import the patch as a merge)\n"
+)
+)
 else:
 p1, p2 = parents
 n = None
 if update:
 repo.dirstate.setbranch(branch or 'default')
 partial = opts.get('partial', False)
 files = set()
 try:
-patch.patch(ui, repo, tmpname, strip=strip, prefix=prefix,
+patch.patch(
-files=files, eolmode=None, similarity=sim / 100.0)
+ui,
+repo,
+tmpname,
+strip=strip,
+prefix=prefix,
+files=files,
+eolmode=None,
+similarity=sim / 100.0,
+)
 except error.PatchError as e:
 if not partial:
 raise error.Abort(pycompat.bytestr(e))
 if partial:
 rejects = True
 m = scmutil.matchfiles(repo, files or [])
 editform = mergeeditform(repo[None], 'import.normal')
 if opts.get('exact'):
 editor = None
 else:
-editor = getcommiteditor(editform=editform,
+editor = getcommiteditor(
-**pycompat.strkwargs(opts))
+editform=editform, **pycompat.strkwargs(opts)
+)
 extra = {}
 for idfunc in extrapreimport:
 extrapreimportmap[idfunc](repo, patchdata, extra, opts)
 overrides = {}
 if partial:
 overrides[('ui', 'allowemptycommit')] = True
 with repo.ui.configoverride(overrides, 'import'):
-n = repo.commit(message, user,
+n = repo.commit(
-date, match=m,
+message, user, date, match=m, editor=editor, extra=extra
-editor=editor, extra=extra)
+)
 for idfunc in extrapostimport:
 extrapostimportmap[idfunc](repo[n])
 else:
 if opts.get('exact') or importbranch:
 branch = branch or 'default'
 branch = p1.branch()
 store = patch.filestore()
 try:
 files = set()
 try:
-patch.patchrepo(ui, repo, p1, store, tmpname, strip, prefix,
+patch.patchrepo(
-files, eolmode=None)
+ui,
+repo,
+p1,
+store,
+tmpname,
+strip,
+prefix,
+files,
+eolmode=None,
+)
 except error.PatchError as e:
 raise error.Abort(stringutil.forcebytestr(e))
 if opts.get('exact'):
 editor = None
 else:
 editor = getcommiteditor(editform='import.bypass')
-memctx = context.memctx(repo, (p1.node(), p2.node()),
+memctx = context.memctx(
-message,
+repo,
-files=files,
+(p1.node(), p2.node()),
-filectxfn=store,
+message,
-user=user,
+files=files,
-date=date,
+filectxfn=store,
-branch=branch,
+user=user,
-editor=editor)
+date=date,
+branch=branch,
+editor=editor,
+)
 n = memctx.commit()
 finally:
 store.close()
 if opts.get('exact') and nocommit:
 # --exact with --no-commit is still useful in that it does merge
 if n:
 # i18n: refers to a short changeset id
 msg = _('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
 extraexport = []
 # mapping from identifier to actual export function
 # function as to return a string to be added to the header or None
 # it is given two arguments (sequencenumber, changectx)
 extraexportmap = {}
 def _exportsingle(repo, ctx, fm, match, switch_parent, seqno, diffopts):
 node = scmutil.binnode(ctx)
 parents = [p.node() for p in ctx.parents() if p]
 branch = ctx.branch()
 if switch_parent:
 fm.context(ctx=ctx)
 fm.plain('# HG changeset patch\n')
 fm.write('user', '# User %s\n', ctx.user())
 fm.plain('# Date %d %d\n' % ctx.date())
 fm.write('date', '#      %s\n', fm.formatdate(ctx.date()))
-fm.condwrite(branch and branch != 'default',
+fm.condwrite(
-'branch', '# Branch %s\n', branch)
+branch and branch != 'default', 'branch', '# Branch %s\n', branch
+)
 fm.write('node', '# Node ID %s\n', hex(node))
 fm.plain('# Parent  %s\n' % hex(prev))
 if len(parents) > 1:
 fm.plain('# Parent  %s\n' % hex(parents[1]))
 fm.data(parents=fm.formatlist(pycompat.maplist(hex, parents), name='node'))
 else:
 chunkiter = patch.diff(repo, prev, node, match, opts=diffopts)
 # TODO: make it structured?
 fm.data(diff=b''.join(chunkiter))
 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('<'):
 repo.ui.note("%s\n" % dest)
 fm.startitem()
 _exportsingle(repo, ctx, fm, match, switch_parent, seqno, diffopts)
-def _exportfntemplate(repo, revs, basefm, fntemplate, switch_parent, diffopts,
-match):
+def _exportfntemplate(
+repo, revs, basefm, fntemplate, switch_parent, diffopts, match
+):
 """Export changesets to possibly multiple files"""
 total = len(revs)
 revwidth = max(len(str(rev)) for rev in revs)
 filemap = util.sortdict()  # filename: [(seqno, rev), ...]
 for seqno, rev in enumerate(revs, 1):
 ctx = repo[rev]
-dest = makefilename(ctx, fntemplate,
+dest = makefilename(
-total=total, seqno=seqno, revwidth=revwidth)
+ctx, fntemplate, total=total, seqno=seqno, revwidth=revwidth
+)
 filemap.setdefault(dest, []).append((seqno, rev))
 for dest in filemap:
 with formatter.maybereopen(basefm, dest) as fm:
 repo.ui.note("%s\n" % dest)
 for seqno, rev in filemap[dest]:
 fm.startitem()
 ctx = repo[rev]
-_exportsingle(repo, ctx, fm, match, switch_parent, seqno,
+_exportsingle(
-diffopts)
+repo, ctx, fm, match, switch_parent, seqno, diffopts
+)
 def _prefetchchangedfiles(repo, revs, match):
 allfiles = set()
 for rev in revs:
 for file in repo[rev].files():
 if not match or match(file):
 allfiles.add(file)
 scmutil.prefetchfiles(repo, revs, scmutil.matchfiles(repo, allfiles))
-def export(repo, revs, basefm, fntemplate='hg-%h.patch', switch_parent=False,
-opts=None, match=None):
+def export(
+repo,
+revs,
+basefm,
+fntemplate='hg-%h.patch',
+switch_parent=False,
+opts=None,
+match=None,
+):
 '''export changesets as hg patches
 Args:
 repo: The repository from which we're exporting revisions.
 revs: A list of revisions to export as revision numbers.
 _prefetchchangedfiles(repo, revs, match)
 if not fntemplate:
 _exportfile(repo, revs, basefm, '<unnamed>', switch_parent, opts, match)
 else:
-_exportfntemplate(repo, revs, basefm, fntemplate, switch_parent, opts,
+_exportfntemplate(
-match)
+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>')
 with formatter.formatter(repo.ui, fp, '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('prednode', '%s ', hex(marker.prednode()))
 succs = marker.succnodes()
-fm.condwrite(succs, 'succnodes', '%s ',
+fm.condwrite(
-fm.formatlist(map(hex, succs), name='node'))
+succs, 'succnodes', '%s ', fm.formatlist(map(hex, succs), name='node')
+)
 fm.write('flag', '%X ', marker.flags())
 parents = marker.parentnodes()
 if parents is not None:
-fm.write('parentnodes', '{%s} ',
+fm.write(
-fm.formatlist(map(hex, parents), name='node', sep=', '))
+'parentnodes',
+'{%s} ',
+fm.formatlist(map(hex, parents), name='node', sep=', '),
+)
 fm.write('date', '(%s) ', fm.formatdate(marker.date()))
 meta = marker.metadata().copy()
 meta.pop('date', None)
 smeta = pycompat.rapply(pycompat.maybebytestr, meta)
 fm.write('metadata', '{%s}', fm.formatdict(smeta, fmt='%r: %r', sep=', '))
 fm.plain('\n')
 def finddate(ui, repo, date):
 """Find the tipmost changeset that matches the given date spec"""
 df = dateutil.matchdate(date)
 m = scmutil.matchall(repo)
 results[ctx.rev()] = d
 for ctx in walkchangerevs(repo, m, {'rev': None}, prep):
 rev = ctx.rev()
 if rev in results:
-ui.status(_("found revision %s from %s\n") %
+ui.status(
-(rev, dateutil.datestr(results[rev])))
+_("found revision %s from %s\n")
+% (rev, dateutil.datestr(results[rev]))
+)
 return '%d' % rev
 raise error.Abort(_("revision matching date not found"))
 def increasingwindows(windowsize=8, sizelimit=512):
 while True:
 yield windowsize
 if windowsize < sizelimit:
 windowsize *= 2
 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')
 else:
 revs = smartset.spanset(repo)
 revs.reverse()
 return revs
 class FileWalkError(Exception):
 pass
 def walkfilerevs(repo, match, follow, revs, fncache):
 '''Walks the file history for the matched files.
 Returns the changeset revs that are involved in the file history.
 filelogs alone.
 '''
 wanted = set()
 copies = []
 minrev, maxrev = min(revs), max(revs)
 def filerevs(filelog, last):
 """
 Only files, no patterns.  Check the history of each file.
 Examines filelog entries within minrev, maxrev linkrev range
 parentlinkrevs = []
 for p in filelog.parentrevs(j):
 if p != nullrev:
 parentlinkrevs.append(filelog.linkrev(p))
 n = filelog.node(j)
-revs.append((linkrev, parentlinkrevs,
+revs.append(
-follow and filelog.renamed(n)))
+(linkrev, parentlinkrevs, follow and filelog.renamed(n))
+)
 return reversed(revs)
 def iterfiles():
 pctx = repo['.']
 for filename in match.files():
 if follow:
 if filename not in pctx:
-raise error.Abort(_('cannot follow file not in parent '
+raise error.Abort(
-'revision: "%s"') % filename)
+_('cannot follow file not in parent ' 'revision: "%s"')
+% filename
+)
 yield filename, pctx[filename].filenode()
 else:
 yield filename, None
 for filename_node in copies:
 yield filename_node
 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_)
+_('cannot follow nonexistent file: "%s"') % file_
+)
 raise FileWalkError("Cannot walk via filelog")
 else:
 continue
 if node is None:
 if copied:
 copies.append(copied)
 return wanted
 class _followfilter(object):
 def __init__(self, repo, onlyfirst=False):
 self.repo = repo
 self.startrev = nullrev
 self.roots = set()
 def match(self, rev):
 def realparents(rev):
 if self.onlyfirst:
 return self.repo.changelog.parentrevs(rev)[0:1]
 else:
-return filter(lambda x: x != nullrev,
+return filter(
-self.repo.changelog.parentrevs(rev))
+lambda x: x != nullrev, self.repo.changelog.parentrevs(rev)
+)
 if self.startrev == nullrev:
 self.startrev = rev
 return True
 self.roots.update(realparents(rev))
 return True
 return False
 def walkchangerevs(repo, match, opts, prepare):
 '''Iterate over files and the revs in which they changed.
 Callers most commonly need to iterate backwards over the history
 in which they are interested. Doing so has awful (quadratic-looking)
 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 '
+raise error.Abort(
-'filenames'))
+_('can only follow copies/renames for explicit ' '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):
 def __init__(self):
 # 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'))
 def want(rev):
 return ff.match(rev) and rev in wanted
 else:
 def want(rev):
 return rev in wanted
 it = iter(revs)
 stopiteration = False
 nrevs.append(rev)
 for rev in sorted(nrevs):
 fns = fncache.get(rev)
 ctx = change(rev)
 if not fns:
 def fns_generator():
 if allfiles:
 fiter = iter(ctx)
 else:
 fiter = ctx.files()
 for f in fiter:
 if match(f):
 yield f
 fns = fns_generator()
 prepare(ctx, fns)
 for rev in nrevs:
 yield change(rev)
 if stopiteration:
 break
 return iterate()
 def add(ui, repo, match, prefix, uipathfn, explicitonly, **opts):
 bad = []
 badfn = lambda x, y: bad.append(x) or match.bad(x, y)
 match = repo.narrowmatch(match, includeexact=True)
 badmatch = matchmod.badmatch(match, badfn)
 dirstate = repo.dirstate
 # We don't want to just call wctx.walk here, since it would return a lot of
 # clean files, which we aren't interested in and takes time.
-for f in sorted(dirstate.walk(badmatch, subrepos=sorted(wctx.substate),
+for f in sorted(
-unknown=True, ignored=False, full=False)):
+dirstate.walk(
+badmatch,
+subrepos=sorted(wctx.substate),
+unknown=True,
+ignored=False,
+full=False,
+)
+):
 exact = match.exact(f)
 if exact or not explicitonly and f not in wctx and repo.wvfs.lexists(f):
 if cca:
 cca(f)
 names.append(f)
 if ui.verbose or not exact:
-ui.status(_('adding %s\n') % uipathfn(f),
+ui.status(
-label='ui.addremove.added')
+_('adding %s\n') % uipathfn(f), label='ui.addremove.added'
+)
 for subpath in sorted(wctx.substate):
 sub = wctx.sub(subpath)
 try:
 submatch = matchmod.subdirmatcher(subpath, match)
 subprefix = repo.wvfs.reljoin(prefix, subpath)
 subuipathfn = scmutil.subdiruipathfn(subpath, uipathfn)
 if opts.get(r'subrepos'):
-bad.extend(sub.add(ui, submatch, subprefix, subuipathfn, False,
+bad.extend(
-**opts))
+sub.add(ui, submatch, subprefix, subuipathfn, False, **opts)
+)
 else:
-bad.extend(sub.add(ui, submatch, subprefix, subuipathfn, True,
+bad.extend(
-**opts))
+sub.add(ui, submatch, subprefix, subuipathfn, True, **opts)
+)
 except error.LookupError:
-ui.status(_("skipping missing subrepository: %s\n")
+ui.status(
-% uipathfn(subpath))
+_("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))
 for r in repo.revs('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):
+def forget(
+ui, repo, match, prefix, uipathfn, explicitonly, dryrun, interactive
+):
 if dryrun and interactive:
 raise error.Abort(_("cannot specify both --dry-run and --interactive"))
 bad = []
 badfn = lambda x, y: bad.append(x) or match.bad(x, y)
 wctx = repo[None]
 sub = wctx.sub(subpath)
 submatch = matchmod.subdirmatcher(subpath, match)
 subprefix = repo.wvfs.reljoin(prefix, subpath)
 subuipathfn = scmutil.subdiruipathfn(subpath, uipathfn)
 try:
-subbad, subforgot = sub.forget(submatch, subprefix, subuipathfn,
+subbad, subforgot = sub.forget(
-dryrun=dryrun,
+submatch,
-interactive=interactive)
+subprefix,
+subuipathfn,
+dryrun=dryrun,
+interactive=interactive,
+)
 bad.extend([subpath + '/' + f for f in subbad])
 forgot.extend([subpath + '/' + f for f in subforgot])
 except error.LookupError:
-ui.status(_("skipping missing subrepository: %s\n")
+ui.status(
-% uipathfn(subpath))
+_("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):
 if f not in forgot:
 # But don't do this until after checking 'forgot', so
 # 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: '
+ui.warn(
-'file is already untracked\n')
+_('not removing %s: ' 'file is already untracked\n')
-% uipathfn(f))
+% uipathfn(f)
+)
 bad.append(f)
 if interactive:
-responses = _('[Ynsa?]'
+responses = _(
-'$$ &Yes, forget this file'
+'[Ynsa?]'
-'$$ &No, skip this file'
+'$$ &Yes, forget this file'
-'$$ &Skip remaining files'
+'$$ &No, skip this file'
-'$$ Include &all remaining files'
+'$$ &Skip remaining files'
-'$$ &? (display help)')
+'$$ Include &all remaining files'
+'$$ &? (display help)'
+)
 for filename in forget[:]:
-r = ui.promptchoice(_('forget %s %s') %
+r = ui.promptchoice(
-(uipathfn(filename), responses))
+_('forget %s %s') % (uipathfn(filename), responses)
-if r == 4: # ?
+)
+if r == 4:  # ?
 while r == 4:
 for c, t in ui.extractchoices(responses)[1]:
 ui.write('%s - %s\n' % (c, encoding.lower(t)))
-r = ui.promptchoice(_('forget %s %s') %
+r = ui.promptchoice(
-(uipathfn(filename), responses))
+_('forget %s %s') % (uipathfn(filename), responses)
-if r == 0: # yes
+)
+if r == 0:  # yes
 continue
-elif r == 1: # no
+elif r == 1:  # no
 forget.remove(filename)
-elif r == 2: # Skip
+elif r == 2:  # Skip
 fnindex = forget.index(filename)
 del forget[fnindex:]
 break
-elif r == 3: # All
+elif r == 3:  # All
 break
 for f in forget:
 if ui.verbose or not match.exact(f) or interactive:
-ui.status(_('removing %s\n') % uipathfn(f),
+ui.status(
-label='ui.addremove.removed')
+_('removing %s\n') % uipathfn(f), label='ui.addremove.removed'
+)
 if not dryrun:
 rejected = wctx.forget(forget, prefix)
 bad.extend(f for f in rejected if f in match.files())
 forgot.extend(f for f in forget if f not in rejected)
 return bad, forgot
 def files(ui, ctx, m, uipathfn, fm, fmt, subrepos):
 ret = 1
 needsfctx = ui.verbose or {'size', 'flags'} & fm.datahint()
 ret = 0
 for subpath in sorted(ctx.substate):
 submatch = matchmod.subdirmatcher(subpath, m)
 subuipathfn = scmutil.subdiruipathfn(subpath, uipathfn)
-if (subrepos or m.exact(subpath) or any(submatch.files())):
+if subrepos or m.exact(subpath) or any(submatch.files()):
 sub = ctx.sub(subpath)
 try:
 recurse = m.exact(subpath) or subrepos
-if sub.printfiles(ui, submatch, subuipathfn, fm, fmt,
+if (
-recurse) == 0:
+sub.printfiles(ui, submatch, subuipathfn, fm, fmt, recurse)
+== 0
+):
 ret = 0
 except error.LookupError:
-ui.status(_("skipping missing subrepository: %s\n")
+ui.status(
-% uipathfn(subpath))
+_("skipping missing subrepository: %s\n")
+% uipathfn(subpath)
+)
 return ret
-def remove(ui, repo, m, prefix, uipathfn, after, force, subrepos, dryrun,
-warnings=None):
+def remove(
+ui, repo, m, prefix, uipathfn, after, force, subrepos, dryrun, warnings=None
+):
 ret = 0
 s = repo.status(match=m, clean=True)
 modified, added, deleted, clean = s[0], s[1], s[3], s[6]
 wctx = repo[None]
 warn = True
 else:
 warn = False
 subs = sorted(wctx.substate)
-progress = ui.makeprogress(_('searching'), total=len(subs),
+progress = ui.makeprogress(
-unit=_('subrepos'))
+_('searching'), total=len(subs), unit=_('subrepos')
+)
 for subpath in subs:
 submatch = matchmod.subdirmatcher(subpath, m)
 subprefix = repo.wvfs.reljoin(prefix, subpath)
 subuipathfn = scmutil.subdiruipathfn(subpath, uipathfn)
 if subrepos or m.exact(subpath) or any(submatch.files()):
 progress.increment()
 sub = wctx.sub(subpath)
 try:
-if sub.removefiles(submatch, subprefix, subuipathfn, after,
+if sub.removefiles(
-force, subrepos, dryrun, warnings):
+submatch,
+subprefix,
+subuipathfn,
+after,
+force,
+subrepos,
+dryrun,
+warnings,
+):
 ret = 1
 except error.LookupError:
-warnings.append(_("skipping missing subrepository: %s\n")
+warnings.append(
-% uipathfn(subpath))
+_("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),
+progress = ui.makeprogress(_('deleting'), total=len(files), unit=_('files'))
-unit=_('files'))
 for f in files:
 def insubrepo():
 for subpath in wctx.substate:
 if f.startswith(subpath + '/'):
 return True
 return False
 progress.increment()
 isdir = f in deleteddirs or wctx.hasdir(f)
-if (f in repo.dirstate or isdir or f == '.'
+if f in repo.dirstate or isdir or f == '.' or insubrepo() or f in subs:
-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')
+warnings.append(
-% uipathfn(f))
+_('not removing %s: no tracked files\n') % uipathfn(f)
+)
 else:
-warnings.append(_('not removing %s: file is untracked\n')
+warnings.append(
-% uipathfn(f))
+_('not removing %s: file is untracked\n') % uipathfn(f)
+)
 # missing files will generate a warning elsewhere
 ret = 1
 progress.complete()
 if force:
 list = modified + deleted + clean + added
 elif after:
 list = deleted
 remaining = modified + added + clean
-progress = ui.makeprogress(_('skipping'), total=len(remaining),
+progress = ui.makeprogress(
-unit=_('files'))
+_('skipping'), total=len(remaining), unit=_('files')
+)
 for f in remaining:
 progress.increment()
 if ui.verbose or (f in files):
-warnings.append(_('not removing %s: file still exists\n')
+warnings.append(
-% uipathfn(f))
+_('not removing %s: file still exists\n') % uipathfn(f)
+)
 ret = 1
 progress.complete()
 else:
 list = deleted + clean
-progress = ui.makeprogress(_('skipping'),
+progress = ui.makeprogress(
-total=(len(modified) + len(added)),
+_('skipping'), total=(len(modified) + len(added)), unit=_('files')
-unit=_('files'))
+)
 for f in modified:
 progress.increment()
-warnings.append(_('not removing %s: file is modified (use -f'
+warnings.append(
-' to force removal)\n') % uipathfn(f))
+_(
+'not removing %s: file is modified (use -f'
+' 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"
+warnings.append(
-" (use 'hg forget' to undo add)\n") % uipathfn(f))
+_(
+"not removing %s: file has been marked for add"
+" (use 'hg forget' to undo add)\n"
+)
+% uipathfn(f)
+)
 ret = 1
 progress.complete()
 list = sorted(list)
-progress = ui.makeprogress(_('deleting'), total=len(list),
+progress = ui.makeprogress(_('deleting'), total=len(list), unit=_('files'))
-unit=_('files'))
 for f in list:
 if ui.verbose or not m.exact(f):
 progress.increment()
-ui.status(_('removing %s\n') % uipathfn(f),
+ui.status(
-label='ui.addremove.removed')
+_('removing %s\n') % uipathfn(f), label='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
+continue  # we never unlink added files on remove
-rmdir = repo.ui.configbool('experimental',
+rmdir = repo.ui.configbool(
-'removeemptydirs')
+'experimental', 'removeemptydirs'
+)
 repo.wvfs.unlinkpath(f, ignoremissing=True, rmdir=rmdir)
 repo[None].forget(list)
 if warn:
 for warning in warnings:
 ui.warn(warning)
 return ret
 def _catfmtneedsdata(fm):
 return not fm.datahint() or 'data' in fm.datahint()
 def _updatecatformatter(fm, ctx, matcher, path, decode):
 """Hook for adding data to the formatter used by ``hg cat``.
 Extensions (e.g., lfs) can wrap this to inject keywords/data, but must call
 fm.startitem()
 fm.context(ctx=ctx)
 fm.write('data', '%s', data)
 fm.data(path=path)
 def cat(ui, repo, ctx, matcher, basefm, fntemplate, prefix, **opts):
 err = 1
 opts = pycompat.byteskwargs(opts)
 def write(path):
 filename = None
 if fntemplate:
-filename = makefilename(ctx, fntemplate,
+filename = makefilename(
-pathname=os.path.join(prefix, path))
+ctx, fntemplate, pathname=os.path.join(prefix, path)
+)
 # attempt to create the directory if it does not already exist
 try:
 os.makedirs(os.path.dirname(filename))
 except OSError:
 pass
 for subpath in sorted(ctx.substate):
 sub = ctx.sub(subpath)
 try:
 submatch = matchmod.subdirmatcher(subpath, matcher)
 subprefix = os.path.join(prefix, subpath)
-if not sub.cat(submatch, basefm, fntemplate, subprefix,
+if not sub.cat(
-**pycompat.strkwargs(opts)):
+submatch,
+basefm,
+fntemplate,
+subprefix,
+**pycompat.strkwargs(opts)
+):
 err = 0
 except error.RepoLookupError:
-ui.status(_("skipping missing subrepository: %s\n") %
+ui.status(
-uipathfn(subpath))
+_("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')
 if date:
 if dsguard:
 relative = scmutil.anypats(pats, opts)
 uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=relative)
 if scmutil.addremove(repo, matcher, "", uipathfn, opts) != 0:
 raise error.Abort(
-_("failed to mark all new/missing files as added/removed"))
+_("failed to mark all new/missing files as added/removed")
+)
 return commitfunc(ui, repo, message, matcher, opts)
 def samefile(f, ctx1, ctx2):
 if f in ctx1.manifest():
 a = ctx1.filectx(f)
 if f in ctx2.manifest():
 b = ctx2.filectx(f)
-return (not a.cmp(b)
+return not a.cmp(b) and a.flags() == b.flags()
-and a.flags() == b.flags())
 else:
 return False
 else:
 return f not in ctx2.manifest()
 def amend(ui, repo, old, extra, pats, opts):
 # avoid cycle context -> subrepo -> cmdutil
 from . import context
 # 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.username()  # raise exception if username not set
 ui.note(_('amending changeset %s\n') % old)
 base = old.p1()
 with repo.wlock(), repo.lock(), repo.transaction('amend'):
 # 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')
+if opts.get('addremove') and scmutil.addremove(
-and scmutil.addremove(repo, matcher, "", uipathfn, opts)):
+repo, matcher, "", uipathfn, opts
+):
 raise error.Abort(
-_("failed to mark all new/missing files as added/removed"))
+_("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:
 subs, commitsubs, newsubstate = subrepoutil.precommit(
-ui, wctx, wctx._status, matcher)
+ui, wctx, wctx._status, matcher
+)
 # amend should abort if commitsubrepos is enabled
 assert not commitsubs
 if subs:
 subrepoutil.writestate(repo, newsubstate)
 ms = mergemod.mergestate.read(repo)
 mergeutil.checkunresolved(ms)
 filestoamend = set(f for f in wctx.files() if matcher(f))
-changes = (len(filestoamend) > 0)
+changes = len(filestoamend) > 0
 if changes:
 # Recompute copies (avoid recording a -> b -> a)
 copied = copies.pathcopies(base, wctx, matcher)
 if old.p2:
 copied.update(copies.pathcopies(old.p2(), wctx, matcher))
 # copy, then those two files are the same and
 # we can discard X from our list of files. Likewise if X
 # was removed, it's no longer relevant. If X is missing (aka
 # deleted), old X must be preserved.
 files.update(filestoamend)
-files = [f for f in files if (f not in filestoamend
+files = [
-or not samefile(f, wctx, base))]
+f
+for f in files
+if (f not in filestoamend or not samefile(f, wctx, base))
+]
 def filectxfn(repo, ctx_, path):
 try:
 # If the file being considered is not amongst the files
 # to be amended, we should return the file context from the
 if path in wctx.removed():
 return None
 fctx = wctx[path]
 flags = fctx.flags()
-mctx = context.memfilectx(repo, ctx_,
+mctx = context.memfilectx(
-fctx.path(), fctx.data(),
+repo,
-islink='l' in flags,
+ctx_,
-isexec='x' in flags,
+fctx.path(),
-copysource=copied.get(path))
+fctx.data(),
+islink='l' in flags,
+isexec='x' in flags,
+copysource=copied.get(path),
+)
 return mctx
 except KeyError:
 return None
 else:
 ui.note(_('copying changeset %s to %s\n') % (old, base))
 # Use version of files as in the old cset
 def filectxfn(repo, ctx_, path):
 editor = getcommiteditor(edit=doedit, editform=editform)
 pureextra = extra.copy()
 extra['amend_source'] = old.hex()
-new = context.memctx(repo,
+new = context.memctx(
-parents=[base.node(), old.p2().node()],
+repo,
-text=message,
+parents=[base.node(), old.p2().node()],
-files=files,
+text=message,
-filectxfn=filectxfn,
+files=files,
-user=user,
+filectxfn=filectxfn,
-date=date,
+user=user,
-extra=extra,
+date=date,
-editor=editor)
+extra=extra,
+editor=editor,
+)
 newdesc = changelog.stripdesc(new.description())
-if ((not changes)
+if (
+(not changes)
 and newdesc == old.description()
 and user == old.user()
 and (date == old.date() or datemaydiffer)
-and pureextra == old.extra()):
+and pureextra == old.extra()
+):
 # nothing changed. continuing here would create a new node
 # anyway because of the amend_source noise.
 #
 # This not what we expect from amend.
 return old.node()
 mapping = {old.node(): (newid,)}
 obsmetadata = None
 if opts.get('note'):
 obsmetadata = {'note': encoding.fromlocal(opts['note'])}
 backup = ui.configbool('rewrite', 'backup-bundle')
-scmutil.cleanupnodes(repo, mapping, 'amend', metadata=obsmetadata,
+scmutil.cleanupnodes(
-fixphase=True, targetphase=commitphase,
+repo,
-backup=backup)
+mapping,
+'amend',
+metadata=obsmetadata,
+fixphase=True,
+targetphase=commitphase,
+backup=backup,
+)
 # Fixing the dirstate because localrepo.commitctx does not update
 # it. This is rather convenient because we did not need to update
 # the dirstate for all the files in the new commit which commitctx
 # could have done if it updated the dirstate. Now, we can
 for f in removedfiles:
 dirstate.drop(f)
 return newid
 def commiteditor(repo, ctx, subs, editform=''):
 if ctx.description():
 return ctx.description()
-return commitforceeditor(repo, ctx, subs, editform=editform,
+return commitforceeditor(
-unchangedmessagedetection=True)
+repo, ctx, subs, editform=editform, unchangedmessagedetection=True
+)
-def commitforceeditor(repo, ctx, subs, finishdesc=None, extramsg=None,
-editform='', unchangedmessagedetection=False):
+def commitforceeditor(
+repo,
+ctx,
+subs,
+finishdesc=None,
+extramsg=None,
+editform='',
+unchangedmessagedetection=False,
+):
 if not extramsg:
 extramsg = _("Leave message empty to abort commit.")
 forms = [e for e in editform.split('.') if e]
 forms.insert(0, 'changeset')
 templatetext = None
 while forms:
 ref = '.'.join(forms)
 if repo.ui.config('committemplate', ref):
 templatetext = committext = buildcommittemplate(
-repo, ctx, subs, extramsg, ref)
+repo, ctx, subs, extramsg, ref
+)
 break
 forms.pop()
 else:
 committext = buildcommittext(repo, ctx, subs, extramsg)
 # make in-memory changes visible to external process
 tr = repo.currenttransaction()
 repo.dirstate.write(tr)
 pending = tr and tr.writepending() and repo.root
-editortext = repo.ui.edit(committext, ctx.user(), ctx.extra(),
+editortext = repo.ui.edit(
-editform=editform, pending=pending,
+committext,
-repopath=repo.path, action='commit')
+ctx.user(),
+ctx.extra(),
+editform=editform,
+pending=pending,
+repopath=repo.path,
+action='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 = text[: stripbelow.start()]
 text = re.sub("(?m)^HG:.*(\n|$)", "", text)
 os.chdir(olddir)
 if finishdesc:
 if unchangedmessagedetection and editortext == templatetext:
 raise error.Abort(_("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))
+t.t.cache.update(
-for k, v in repo.ui.configitems('committemplate'))
+(k, templater.unquotestring(v))
+for k, v in repo.ui.configitems('committemplate')
+)
 if not extramsg:
-extramsg = '' # ensure that extramsg is string
+extramsg = ''  # 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])
 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("") # Empty line between message and comments.
+edittext.append("")  # Empty line between message and comments.
-edittext.append(hgprefix(_("Enter commit message."
+edittext.append(
-"  Lines beginning with 'HG:' are removed.")))
+hgprefix(
+_(
+"Enter commit message."
+"  Lines beginning with 'HG:' are removed."
+)
+)
+)
 edittext.append(hgprefix(extramsg))
 edittext.append("HG: --")
 edittext.append(hgprefix(_("user: %s") % ctx.user()))
 if ctx.p2():
 edittext.append(hgprefix(_("branch merge")))
 edittext.append(hgprefix(_("no files changed")))
 edittext.append("")
 return "\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') and bheads and node not in bheads and not
+if (
-[x for x in parents if x.node() in bheads and x.branch() == branch]):
+not opts.get('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'))
 # 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 ...
 if repo.ui.debugflag:
 repo.ui.write(_('committed changeset %d:%s\n') % (ctx.rev(), ctx.hex()))
 elif repo.ui.verbose:
 repo.ui.write(_('committed changeset %d:%s\n') % (ctx.rev(), ctx))
 def postcommitstatus(repo, pats, opts):
 return repo.status(match=scmutil.match(repo[None], pats, opts))
 def revert(ui, repo, ctx, parents, *pats, **opts):
 opts = pycompat.byteskwargs(opts)
 parent, p2 = parents
 node = ctx.node()
 names[abs] = m.exact(abs)
 # Find status of all file in `names`.
 m = scmutil.matchfiles(repo, names)
-changes = repo.status(node1=node, match=m,
+changes = repo.status(
-unknown=True, ignored=True, clean=True)
+node1=node, match=m, unknown=True, ignored=True, clean=True
+)
 else:
 changes = repo.status(node1=node, match=m)
 for kind in changes:
 for abs in kind:
 names[abs] = m.exact(abs)
 m = scmutil.matchfiles(repo, names)
 modified = set(changes.modified)
-added    = set(changes.added)
+added = set(changes.added)
-removed  = set(changes.removed)
+removed = set(changes.removed)
 _deleted = set(changes.deleted)
-unknown  = set(changes.unknown)
+unknown = set(changes.unknown)
 unknown.update(changes.ignored)
-clean    = set(changes.clean)
+clean = set(changes.clean)
 modadded = set()
 # We need to account for the state of the file in the dirstate,
 # even when we revert against something else than parent. This will
 # slightly alter the behavior of revert (doing back up or not, delete
 localchanges = dsmodified | dsadded
 modified, added, removed = set(), set(), set()
 else:
 changes = repo.status(node1=parent, match=m)
 dsmodified = set(changes.modified)
-dsadded    = set(changes.added)
+dsadded = set(changes.added)
-dsremoved  = set(changes.removed)
+dsremoved = set(changes.removed)
 # store all local modifications, useful later for rename detection
 localchanges = dsmodified | dsadded
 # only take into account for removes between wc and target
 clean |= dsremoved - removed
 modadded = added & dsmodified
 added -= modadded
 # tell newly modified apart.
 dsmodified &= modified
-dsmodified |= modified & dsadded # dirstate added may need backup
+dsmodified |= modified & dsadded  # dirstate added may need backup
 modified -= dsmodified
 # We need to wait for some post-processing to update this set
 # before making the distinction. The dirstate will be used for
 # that purpose.
 dsremovunk.add(abs)
 dsremoved -= dsremovunk
 # action to be actually performed by revert
 # (<list of file>, message>) tuple
-actions = {'revert': ([], _('reverting %s\n')),
+actions = {
-'add': ([], _('adding %s\n')),
+'revert': ([], _('reverting %s\n')),
-'remove': ([], _('removing %s\n')),
+'add': ([], _('adding %s\n')),
-'drop': ([], _('removing %s\n')),
+'remove': ([], _('removing %s\n')),
-'forget': ([], _('forgetting %s\n')),
+'drop': ([], _('removing %s\n')),
-'undelete': ([], _('undeleting %s\n')),
+'forget': ([], _('forgetting %s\n')),
-'noop': (None, _('no changes needed to %s\n')),
+'undelete': ([], _('undeleting %s\n')),
-'unknown': (None, _('file not managed: %s\n')),
+'noop': (None, _('no changes needed to %s\n')),
-}
+'unknown': (None, _('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
+backupinteractive = 3  # do backup if interactively modified
 backup = 2  # unconditionally do backup
-check = 1   # check if the existing file differs from target
+check = 1  # check if the existing file differs from target
-discard = 0 # never do backup
+discard = 0  # never do backup
 if opts.get('no_backup'):
 backupinteractive = backup = check = discard
 if interactive:
 dsmodifiedbackup = backupinteractive
 else:
 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['revert'], discard),
 # Modified compared to target, but local file is deleted
-(deleted,       actions['revert'],   discard),
+(deleted, actions['revert'], discard),
 # Modified compared to target, local change
-(dsmodified,    actions['revert'],   dsmodifiedbackup),
+(dsmodified, actions['revert'], dsmodifiedbackup),
 # Added since target
-(added,         actions['remove'],   discard),
+(added, actions['remove'], discard),
 # Added in working directory
-(dsadded,       actions['forget'],   discard),
+(dsadded, actions['forget'], discard),
 # Added since target, have local modification
-(modadded,      backupanddel,        backup),
+(modadded, backupanddel, backup),
 # Added since target but file is missing in working directory
-(deladded,      actions['drop'],   discard),
+(deladded, actions['drop'], discard),
 # Removed since  target, before working copy parent
-(removed,       actions['add'],      discard),
+(removed, actions['add'], discard),
 # Same as `removed` but an unknown file exists at the same path
-(removunk,      actions['add'],      check),
+(removunk, actions['add'], check),
 # Removed since targe, marked as such in working copy parent
-(dsremoved,     actions['undelete'], discard),
+(dsremoved, actions['undelete'], discard),
 # Same as `dsremoved` but an unknown file exists at the same path
-(dsremovunk,    actions['undelete'], check),
+(dsremovunk, actions['undelete'], check),
 ## the following sets does not result in any file changes
 # File with no modification
-(clean,         actions['noop'],     discard),
+(clean, actions['noop'], discard),
 # Existing file, not tracked anywhere
-(unknown,       actions['unknown'],  discard),
+(unknown, actions['unknown'], discard),
 )
 for abs, exact in sorted(names.items()):
 # target file to be touch on disk (relative to cwd)
 target = repo.wjoin(abs)
 # search the entry in the dispatch table.
 if dobackup:
 # If in interactive mode, don't automatically create
 # .orig files (issue4793)
 if dobackup == backupinteractive:
 tobackup.add(abs)
-elif (backup <= dobackup or wctx[abs].cmp(ctx[abs])):
+elif backup <= dobackup or wctx[abs].cmp(ctx[abs]):
 absbakname = scmutil.backuppath(ui, repo, abs)
-bakname = os.path.relpath(absbakname,
+bakname = os.path.relpath(
-start=repo.root)
+absbakname, start=repo.root
-ui.note(_('saving current version of %s as %s\n') %
+)
-(uipathfn(abs), uipathfn(bakname)))
+ui.note(
+_('saving current version of %s as %s\n')
+% (uipathfn(abs), uipathfn(bakname))
+)
 if not opts.get('dry_run'):
 if interactive:
 util.copyfile(target, absbakname)
 else:
 util.rename(target, absbakname)
 if not opts.get('dry_run'):
 needdata = ('revert', 'add', 'undelete')
 oplist = [actions[name][0] for name in needdata]
 prefetch = scmutil.prefetchfiles
 matchfiles = scmutil.matchfiles
-prefetch(repo, [ctx.rev()],
+prefetch(
-matchfiles(repo,
+repo,
-[f for sublist in oplist for f in sublist]))
+[ctx.rev()],
+matchfiles(repo, [f for sublist in oplist for f in sublist]),
+)
 match = scmutil.match(repo[None], pats)
-_performrevert(repo, parents, ctx, names, uipathfn, actions,
+_performrevert(
-match, interactive, tobackup)
+repo,
+parents,
+ctx,
+names,
+uipathfn,
+actions,
+match,
+interactive,
+tobackup,
+)
 if targetsubs:
 # Revert the subrepos on the revert list
 for sub in targetsubs:
 try:
-wctx.sub(sub).revert(ctx.substate[sub], *pats,
+wctx.sub(sub).revert(
-**pycompat.strkwargs(opts))
+ctx.substate[sub], *pats, **pycompat.strkwargs(opts)
+)
 except KeyError:
-raise error.Abort("subrepository '%s' does not exist in %s!"
+raise error.Abort(
-% (sub, short(ctx.node())))
+"subrepository '%s' does not exist in %s!"
+% (sub, short(ctx.node()))
-def _performrevert(repo, parents, ctx, names, uipathfn, actions,
+)
-match, interactive=False, tobackup=None):
+def _performrevert(
+repo,
+parents,
+ctx,
+names,
+uipathfn,
+actions,
+match,
+interactive=False,
+tobackup=None,
+):
 """function that actually perform all the actions computed for revert
 This is an independent function to let extension to plug in and react to
 the imminent revert.
 audit_path = pathutil.pathauditor(repo.root, cached=True)
 for f in actions['forget'][0]:
 if interactive:
 choice = repo.ui.promptchoice(
-_("forget added file %s (Yn)?$$ &Yes $$ &No") % uipathfn(f))
+_("forget added file %s (Yn)?$$ &Yes $$ &No") % uipathfn(f)
+)
 if choice == 0:
 prntstatusmsg('forget', f)
 repo.dirstate.drop(f)
 else:
 excluded_files.append(f)
 repo.dirstate.drop(f)
 for f in actions['remove'][0]:
 audit_path(f)
 if interactive:
 choice = repo.ui.promptchoice(
-_("remove added file %s (Yn)?$$ &Yes $$ &No") % uipathfn(f))
+_("remove added file %s (Yn)?$$ &Yes $$ &No") % uipathfn(f)
+)
 if choice == 0:
 prntstatusmsg('remove', f)
 doremove(f)
 else:
 excluded_files.append(f)
 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]
 m = scmutil.matchfiles(repo, torevert)
-diffopts = patch.difffeatureopts(repo.ui, whitespace=True,
+diffopts = patch.difffeatureopts(
-section='commands',
+repo.ui,
-configprefix='revert.interactive.')
+whitespace=True,
+section='commands',
+configprefix='revert.interactive.',
+)
 diffopts.nodates = True
 diffopts.git = True
 operation = 'apply'
 if node == parent:
-if repo.ui.configbool('experimental',
+if repo.ui.configbool(
-'revert.interactive.select-to-keep'):
+'experimental', 'revert.interactive.select-to-keep'
+):
 operation = 'keep'
 else:
 operation = 'discard'
 if operation == 'apply':
 diff = patch.diff(repo, ctx.node(), None, m, opts=diffopts)
 originalchunks = patch.parsepatch(diff)
 try:
-chunks, opts = recordfilter(repo.ui, originalchunks, match,
+chunks, opts = recordfilter(
-operation=operation)
+repo.ui, originalchunks, match, operation=operation
+)
 if operation == 'discard':
 chunks = patch.reversehunks(chunks)
 except error.PatchError as err:
 raise error.Abort(_('error parsing patch: %s') % err)
 # 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
 # copied/renamed files.
 newlyaddedandmodifiedfiles, unusedalsorestore = newandmodified(
-chunks, originalchunks)
+chunks, originalchunks
+)
 if tobackup is None:
 tobackup = set()
 # Apply changes
 fp = stringio()
 # chunks are serialized per file, but files aren't sorted
 if node == parent and p2 == nullid:
 normal = repo.dirstate.normal
 for f in actions['undelete'][0]:
 if interactive:
 choice = repo.ui.promptchoice(
-_("add back removed file %s (Yn)?$$ &Yes $$ &No") % f)
+_("add back removed file %s (Yn)?$$ &Yes $$ &No") % f
+)
 if choice == 0:
 prntstatusmsg('undelete', f)
 checkout(f)
 normal(f)
 else:
 for f in actions['add'][0] + actions['undelete'][0] + actions['revert'][0]:
 if f in copied:
 repo.dirstate.copy(copied[f], f)
 # a list of (ui, repo, otherpeer, opts, missing) functions called by
 # commands.outgoing.  "missing" is "missing" of the result of
 # "findcommonoutgoing()"
 outgoinghooks = util.hooks()
 bailifchanged().
 '''
 # Check for non-clearable states first, so things like rebase will take
 # precedence over update.
 for state in statemod._unfinishedstates:
-if (state._clearable or (commit and state._allowcommit) or
+if (
-state._reportonly):
+state._clearable
+or (commit and state._allowcommit)
+or state._reportonly
+):
 continue
 if state.isunfinished(repo):
 raise error.Abort(state.msg(), hint=state.hint())
 for s in statemod._unfinishedstates:
-if (not s._clearable or (commit and s._allowcommit) or
+if (
-(s._opname == 'merge' and skipmerge) or s._reportonly):
+not s._clearable
+or (commit and s._allowcommit)
+or (s._opname == 'merge' and skipmerge)
+or s._reportonly
+):
 continue
 if s.isunfinished(repo):
 raise error.Abort(s.msg(), hint=s.hint())
 def clearunfinished(repo):
 '''Check for unfinished operations (as above), and clear the ones
 that are clearable.
 '''
 if s._opname == 'merge' or state._reportonly:
 continue
 if s._clearable and s.isunfinished(repo):
 util.unlink(repo.vfs.join(s._fname))
 def getunfinishedstate(repo):
 ''' Checks for unfinished operations and returns statecheck object
 for it'''
 for state in statemod._unfinishedstates:
 if state.isunfinished(repo):
 return state
 return None
 def howtocontinue(repo):
 '''Check for an unfinished operation and return the command to finish
 it.
 return contmsg % state.continuemsg(), True
 if repo[None].dirty(missing=True, merge=False, branch=False):
 return contmsg % _("hg commit"), False
 return None, None
 def checkafterresolved(repo):
 '''Inform the user about the next action after completing hg resolve
 If there's a an unfinished operation that supports continue flag,
 howtocontinue will yield repo.ui.warn as the reporter.
 if warning:
 repo.ui.warn("%s\n" % msg)
 else:
 repo.ui.note("%s\n" % msg)
 def wrongtooltocontinue(repo, task):
 '''Raise an abort suggesting how to properly continue if there is an
 active task.
 Uses howtocontinue() to find the active task.
 after = howtocontinue(repo)
 hint = None
 if after[1]:
 hint = after[0]
 raise error.Abort(_('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():
 else:
 startctx = repo['.']
 # whether to strip or not
 cleanup = False
 from . import hg
 if newnodes:
 newnodes = [repo[r].rev() for r in 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")
+repo.ui.warn(
-% ', '.join(bytes(repo[r]) for r in immutable),
+_("cannot clean up public changesets %s\n")
-hint=_("see 'hg help phases' for details"))
+% ', '.join(bytes(repo[r]) for r in immutable),
+hint=_("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 "
+repo.ui.warn(
-"branch, can't strip\n"))
+_(
+"new changesets detected on destination "
+"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)",
+strippoints = [
-newnodes)]
+c.node() for c in repo.set("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['.']
 ui.status(_("graft aborted\n"))
 ui.status(_("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()
 return {'nodes': nodes}
 def hgabortgraft(ui, repo):
 """ abort logic for aborting graft using 'hg abort'"""
 with repo.wlock():
 graftstate = statemod.cmdstate(repo, 'graftstate')
 return abortgraft(ui, repo, graftstate)

changeset 43076	2372284d9457
parent 42933	7e9997041781
child 43077	687b865b95ad