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

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 stringutil,
 )
 propertycache = util.propertycache
 class basectx(object):
 """A basectx object represents the common logic for its children:
 changectx: read-only context that is already present in the repo,
 workingctx: a context that represents the working directory and can
 be committed,
 """This internal method provides a way for child objects to override the
 match operator.
 """
 return match
-def _buildstatus(self, other, s, match, listignored, listclean,
+def _buildstatus(
-listunknown):
+self, other, s, match, listignored, listclean, listunknown
+):
 """build a status with respect to another context"""
 # Load earliest manifest first for caching reasons. More specifically,
 # if you have revisions 1000 and 1001, 1001 is probably stored as a
 # delta against 1000. Thus, if you read 1000 first, we'll reconstruct
 # 1000 and cache it so that when you read 1001, we just need to apply a
 else:
 clean.append(fn)
 if removed:
 # need to filter files if they are already reported as removed
-unknown = [fn for fn in unknown if fn not in mf1 and
+unknown = [
-(not match or match(fn))]
+fn
-ignored = [fn for fn in ignored if fn not in mf1 and
+for fn in unknown
-(not match or match(fn))]
+if fn not in mf1 and (not match or match(fn))
+]
+ignored = [
+fn
+for fn in ignored
+if fn not in mf1 and (not match or match(fn))
+]
 # if they're deleted, don't report them as removed
 removed = [fn for fn in removed if fn not in deletedset]
-return scmutil.status(modified, added, removed, deleted, unknown,
+return scmutil.status(
-ignored, clean)
+modified, added, removed, deleted, unknown, ignored, clean
+)
 @propertycache
 def substate(self):
 return subrepoutil.state(self, self._repo.ui)
 def subrev(self, subpath):
 return self.substate[subpath][1]
 def rev(self):
 return self._rev
 def node(self):
 return self._node
 def hex(self):
 return hex(self.node())
 def manifest(self):
 return self._manifest
 def manifestctx(self):
 return self._manifestctx
 def repo(self):
 return self._repo
 def phasestr(self):
 return phases.phasenames[self.phase()]
 def mutable(self):
 return self.phase() > phases.public
 def matchfileset(self, expr, badfn=None):
 return fileset.match(self, expr, badfn=badfn)
 def _fileinfo(self, path):
 if r'_manifest' in self.__dict__:
 try:
 return self._manifest[path], self._manifest.flags(path)
 except KeyError:
-raise error.ManifestLookupError(self._node, path,
+raise error.ManifestLookupError(
-_('not found in manifest'))
+self._node, path, _('not found in manifest')
+)
 if r'_manifestdelta' in self.__dict__ or path in self.files():
 if path in self._manifestdelta:
-return (self._manifestdelta[path],
+return (
-self._manifestdelta.flags(path))
+self._manifestdelta[path],
+self._manifestdelta.flags(path),
+)
 mfl = self._repo.manifestlog
 try:
 node, flag = mfl[self._changeset.manifest].find(path)
 except KeyError:
-raise error.ManifestLookupError(self._node, path,
+raise error.ManifestLookupError(
-_('not found in manifest'))
+self._node, path, _('not found in manifest')
+)
 return node, flag
 def filenode(self, path):
 return self._fileinfo(path)[0]
 return ''
 @propertycache
 def _copies(self):
 return copies.computechangesetcopies(self)
 def p1copies(self):
 return self._copies[0]
 def p2copies(self):
 return self._copies[1]
 def sub(self, path, allowcreate=True):
 '''return a subrepo for the stored revision of path, never wdir()'''
 '''return a subrepo for the stored revision, or wdir if this is a wdir
 context.
 '''
 return subrepo.subrepo(self, path, allowwdir=True)
-def match(self, pats=None, include=None, exclude=None, default='glob',
+def match(
-listsubrepos=False, badfn=None):
+self,
+pats=None,
+include=None,
+exclude=None,
+default='glob',
+listsubrepos=False,
+badfn=None,
+):
 r = self._repo
-return matchmod.match(r.root, r.getcwd(), pats,
+return matchmod.match(
-include, exclude, default,
+r.root,
-auditor=r.nofsauditor, ctx=self,
+r.getcwd(),
-listsubrepos=listsubrepos, badfn=badfn)
+pats,
+include,
-def diff(self, ctx2=None, match=None, changes=None, opts=None,
+exclude,
-losedatafn=None, pathfn=None, copy=None,
+default,
-copysourcematch=None, hunksfilterfn=None):
+auditor=r.nofsauditor,
+ctx=self,
+listsubrepos=listsubrepos,
+badfn=badfn,
+)
+def diff(
+self,
+ctx2=None,
+match=None,
+changes=None,
+opts=None,
+losedatafn=None,
+pathfn=None,
+copy=None,
+copysourcematch=None,
+hunksfilterfn=None,
+):
 """Returns a diff generator for the given contexts and matcher"""
 if ctx2 is None:
 ctx2 = self.p1()
 if ctx2 is not None:
 ctx2 = self._repo[ctx2]
-return patch.diff(self._repo, ctx2, self, match=match, changes=changes,
+return patch.diff(
-opts=opts, losedatafn=losedatafn, pathfn=pathfn,
+self._repo,
-copy=copy, copysourcematch=copysourcematch,
+ctx2,
-hunksfilterfn=hunksfilterfn)
+self,
+match=match,
+changes=changes,
+opts=opts,
+losedatafn=losedatafn,
+pathfn=pathfn,
+copy=copy,
+copysourcematch=copysourcematch,
+hunksfilterfn=hunksfilterfn,
+)
 def dirs(self):
 return self._manifest.dirs()
 def hasdir(self, dir):
 return self._manifest.hasdir(dir)
-def status(self, other=None, match=None, listignored=False,
+def status(
-listclean=False, listunknown=False, listsubrepos=False):
+self,
+other=None,
+match=None,
+listignored=False,
+listclean=False,
+listunknown=False,
+listsubrepos=False,
+):
 """return status of files between two nodes or node and working
 directory.
 If other is None, compare this node with working directory.
 #
 # If we always built the manifest for each context and compared those,
 # then we'd be done. But the special case of the above call means we
 # just copy the manifest of the parent.
 reversed = False
-if (not isinstance(ctx1, changectx)
+if not isinstance(ctx1, changectx) and isinstance(ctx2, changectx):
-and isinstance(ctx2, changectx)):
 reversed = True
 ctx1, ctx2 = ctx2, ctx1
 match = self._repo.narrowmatch(match)
 match = ctx2._matchstatus(ctx1, match)
 r = scmutil.status([], [], [], [], [], [], [])
-r = ctx2._buildstatus(ctx1, r, match, listignored, listclean,
+r = ctx2._buildstatus(
-listunknown)
+ctx1, r, match, listignored, listclean, listunknown
+)
 if reversed:
 # Reverse added and removed. Clear deleted, unknown and ignored as
 # these make no sense to reverse.
-r = scmutil.status(r.modified, r.removed, r.added, [], [], [],
+r = scmutil.status(
-r.clean)
+r.modified, r.removed, r.added, [], [], [], r.clean
+)
 if listsubrepos:
 for subpath, sub in scmutil.itersubrepos(ctx1, ctx2):
 try:
 rev2 = ctx2.subrev(subpath)
 # A subrepo that existed in node1 was deleted between
 # node1 and node2 (inclusive). Thus, ctx2's substate
 # won't contain that subpath. The best we can do ignore it.
 rev2 = None
 submatch = matchmod.subdirmatcher(subpath, match)
-s = sub.status(rev2, match=submatch, ignored=listignored,
+s = sub.status(
-clean=listclean, unknown=listunknown,
+rev2,
-listsubrepos=True)
+match=submatch,
+ignored=listignored,
+clean=listclean,
+unknown=listunknown,
+listsubrepos=True,
+)
 for rfiles, sfiles in zip(r, s):
 rfiles.extend("%s/%s" % (subpath, f) for f in sfiles)
 for l in r:
 l.sort()
 return r
 class changectx(basectx):
 """A changecontext object makes access to data related to a particular
 changeset convenient. It represents a read-only context already present in
 the repo."""
 def __init__(self, repo, rev, node):
 super(changectx, self).__init__(repo)
 self._rev = rev
 self._node = node
 c.date,
 c.files,
 c.description,
 c.extra,
 )
 def manifestnode(self):
 return self._changeset.manifest
 def user(self):
 return self._changeset.user
 def date(self):
 return self._changeset.date
 def files(self):
 return self._changeset.files
 def filesmodified(self):
 modified = set(self.files())
 modified.difference_update(self.filesadded())
 modified.difference_update(self.filesremoved())
 return sorted(modified)
 p1copies, p2copies = super(changectx, self)._copies
 return p1copies, p2copies
 def description(self):
 return self._changeset.description
 def branch(self):
 return encoding.tolocal(self._changeset.extra.get("branch"))
 def closesbranch(self):
 return 'close' in self._changeset.extra
 def extra(self):
 """Return a dict of extra information."""
 return self._changeset.extra
 def tags(self):
 """Return a list of byte tag names"""
 return self._repo.nodetags(self._node)
 def bookmarks(self):
 """Return a list of byte bookmark names."""
 return self._repo.nodebookmarks(self._node)
 def phase(self):
 return self._repo._phasecache.phase(self._repo, self._rev)
 def hidden(self):
 return self._rev in repoview.filterrevs(self._repo, 'visible')
 def isinmemory(self):
 return False
 def filectx(self, path, fileid=None, filelog=None):
 """get a file context from this changeset"""
 if fileid is None:
 fileid = self.filenode(path)
-return filectx(self._repo, path, fileid=fileid,
+return filectx(
-changectx=self, filelog=filelog)
+self._repo, path, fileid=fileid, changectx=self, filelog=filelog
+)
 def ancestor(self, c2, warn=False):
 """return the "best" ancestor context of self and c2
 If there are multiple candidates, it will show a message and check
 break
 else:
 anc = self._repo.changelog.ancestor(self._node, n2)
 if warn:
 self._repo.ui.status(
-(_("note: using %s as ancestor of %s and %s\n") %
+(
-(short(anc), short(self._node), short(n2))) +
+_("note: using %s as ancestor of %s and %s\n")
-''.join(_("      alternatively, use --config "
+% (short(anc), short(self._node), short(n2))
-"merge.preferancestor=%s\n") %
+)
-short(n) for n in sorted(cahs) if n != anc))
++ ''.join(
+_(
+"      alternatively, use --config "
+"merge.preferancestor=%s\n"
+)
+% short(n)
+for n in sorted(cahs)
+if n != anc
+)
+)
 return self._repo[anc]
 def isancestorof(self, other):
 """True if this changeset is an ancestor of other"""
 return self._repo.changelog.isancestorrev(self._rev, other._rev)
 # Wrap match.bad method to have message with nodeid
 def bad(fn, msg):
 # The manifest doesn't know about subrepos, so don't complain about
 # paths into valid subrepos.
-if any(fn == s or fn.startswith(s + '/')
+if any(fn == s or fn.startswith(s + '/') for s in self.substate):
-for s in self.substate):
 return
 match.bad(fn, _('no such file in rev %s') % self)
 m = matchmod.badmatch(self._repo.narrowmatch(match), bad)
 return self._manifest.walk(m)
 def matches(self, match):
 return self.walk(match)
 class basefilectx(object):
 """A filecontext object represents the common logic for its children:
 filectx: read-only access to a filerevision that is already present
 in the repo,
 workingfilectx: a filecontext that represents files from the working
 directory,
 memfilectx: a filecontext that represents files in-memory,
 """
 @propertycache
 def _filelog(self):
 return self._repo.file(self._path)
 @propertycache
 except AttributeError:
 return id(self)
 def __eq__(self, other):
 try:
-return (type(self) == type(other) and self._path == other._path
+return (
-and self._filenode == other._filenode)
+type(self) == type(other)
+and self._path == other._path
+and self._filenode == other._filenode
+)
 except AttributeError:
 return False
 def __ne__(self, other):
 return not (self == other)
 def filerev(self):
 return self._filerev
 def filenode(self):
 return self._filenode
 @propertycache
 def _flags(self):
 return self._changectx.flags(self._path)
 def flags(self):
 return self._flags
 def filelog(self):
 return self._filelog
 def rev(self):
 return self._changeid
 def linkrev(self):
 return self._filelog.linkrev(self._filerev)
 def node(self):
 return self._changectx.node()
 def hex(self):
 return self._changectx.hex()
 def user(self):
 return self._changectx.user()
 def date(self):
 return self._changectx.date()
 def files(self):
 return self._changectx.files()
 def description(self):
 return self._changectx.description()
 def branch(self):
 return self._changectx.branch()
 def extra(self):
 return self._changectx.extra()
 def phase(self):
 return self._changectx.phase()
 def phasestr(self):
 return self._changectx.phasestr()
 def obsolete(self):
 return self._changectx.obsolete()
 def instabilities(self):
 return self._changectx.instabilities()
 def manifest(self):
 return self._changectx.manifest()
 def changectx(self):
 return self._changectx
 def renamed(self):
 return self._copied
 def copysource(self):
 return self._copied and self._copied[0]
 def repo(self):
 return self._repo
 def size(self):
 return len(self.data())
 def path(self):
 return self._path
 def isbinary(self):
 try:
 return stringutil.binary(self.data())
 except IOError:
 return False
 def isexec(self):
 return 'x' in self.flags()
 def islink(self):
 return 'l' in self.flags()
 def isabsent(self):
 """whether this filectx represents a file not in self._changectx
 This is mainly for merge code to detect change/delete conflicts. This is
 expected to be True for all subclasses of basectx."""
 return False
 _customcmp = False
 def cmp(self, fctx):
 """compare with other file context
 returns True if different than fctx.
 """
 if fctx._customcmp:
 return fctx.cmp(self)
 if self._filenode is None:
 raise error.ProgrammingError(
-'filectx.cmp() must be reimplemented if not backed by revlog')
+'filectx.cmp() must be reimplemented if not backed by revlog'
+)
 if fctx._filenode is None:
 if self._repo._encodefilterpats:
 # can't rely on size() because wdir content may be decoded
 return self._filelog.cmp(self._filenode, fctx.data())
 memberanc = getattr(self, '_ancestrycontext', None)
 iteranc = None
 if srcrev is None:
 # wctx case, used by workingfilectx during mergecopy
 revs = [p.rev() for p in self._repo[None].parents()]
-inclusive = True # we skipped the real (revless) source
+inclusive = True  # we skipped the real (revless) source
 else:
 revs = [srcrev]
 if memberanc is None:
-memberanc = iteranc = cl.ancestors(revs, lkr,
+memberanc = iteranc = cl.ancestors(revs, lkr, inclusive=inclusive)
-inclusive=inclusive)
 # check if this linkrev is an ancestor of srcrev
 if lkr not in memberanc:
 if iteranc is None:
 iteranc = cl.ancestors(revs, lkr, inclusive=inclusive)
 fnode = self._filenode
 path = self._path
 for a in iteranc:
 if stoprev is not None and a < stoprev:
 return None
-ac = cl.read(a) # get changeset data (we avoid object creation)
+ac = cl.read(a)  # get changeset data (we avoid object creation)
-if path in ac[3]: # checking the 'files' field.
+if path in ac[3]:  # checking the 'files' field.
 # The file has been touched, check if the content is
 # similar to the one we search for.
 if fnode == mfl[ac[0]].readfast().get(path):
 return a
 # In theory, we should never get out of that loop without a result.
 if getattr(base, '_ancestrycontext', None) is None:
 cl = self._repo.changelog
 if base.rev() is None:
 # wctx is not inclusive, but works because _ancestrycontext
 # is used to test filelog revisions
-ac = cl.ancestors([p.rev() for p in base.parents()],
+ac = cl.ancestors(
-inclusive=True)
+[p.rev() for p in base.parents()], inclusive=True
+)
 else:
 ac = cl.ancestors([base.rev()], inclusive=True)
 base._ancestrycontext = ac
-return dagop.annotate(base, parents, skiprevs=skiprevs,
+return dagop.annotate(
-diffopts=diffopts)
+base, parents, skiprevs=skiprevs, diffopts=diffopts
+)
 def ancestors(self, followfirst=False):
 visit = {}
 c = self
 if followfirst:
 This is often equivalent to how the data would be expressed on disk.
 """
 return self._repo.wwritedata(self.path(), self.data())
 class filectx(basefilectx):
 """A filecontext object makes access to data related to a particular
 filerevision convenient."""
-def __init__(self, repo, path, changeid=None, fileid=None,
-filelog=None, changectx=None):
+def __init__(
+self,
+repo,
+path,
+changeid=None,
+fileid=None,
+filelog=None,
+changectx=None,
+):
 """changeid must be a revision number, if specified.
 fileid can be a file revision or node."""
 self._repo = repo
 self._path = path
-assert (changeid is not None
+assert (
-or fileid is not None
+changeid is not None or fileid is not None or changectx is not None
-or changectx is not None), (
+), "bad args: changeid=%r, fileid=%r, changectx=%r" % (
-"bad args: changeid=%r, fileid=%r, changectx=%r"
+changeid,
-% (changeid, fileid, changectx))
+fileid,
+changectx,
+)
 if filelog is not None:
 self._filelog = filelog
 if changeid is not None:
 return self._repo.unfiltered()[self._changeid]
 def filectx(self, fileid, changeid=None):
 '''opens an arbitrary revision of the file without
 opening a new filelog'''
-return filectx(self._repo, self._path, fileid=fileid,
+return filectx(
-filelog=self._filelog, changeid=changeid)
+self._repo,
+self._path,
+fileid=fileid,
+filelog=self._filelog,
+changeid=changeid,
+)
 def rawdata(self):
 return self._filelog.rawdata(self._filenode)
 def rawflags(self):
 try:
 return self._filelog.read(self._filenode)
 except error.CensoredNodeError:
 if self._repo.ui.config("censor", "policy") == "ignore":
 return ""
-raise error.Abort(_("censored node: %s") % short(self._filenode),
+raise error.Abort(
-hint=_("set censor.policy to ignore errors"))
+_("censored node: %s") % short(self._filenode),
+hint=_("set censor.policy to ignore errors"),
+)
 def size(self):
 return self._filelog.size(self._filerev)
 @propertycache
 return renamed
 def children(self):
 # hard for renames
 c = self._filelog.children(self._filenode)
-return [filectx(self._repo, self._path, fileid=x,
+return [
-filelog=self._filelog) for x in c]
+filectx(self._repo, self._path, fileid=x, filelog=self._filelog)
+for x in c
+]
 class committablectx(basectx):
 """A committablectx object provides common functionality for a context that
 wants the ability to commit, e.g. workingctx or memctx."""
-def __init__(self, repo, text="", user=None, date=None, extra=None,
-changes=None, branch=None):
+def __init__(
+self,
+repo,
+text="",
+user=None,
+date=None,
+extra=None,
+changes=None,
+branch=None,
+):
 super(committablectx, self).__init__(repo)
 self._rev = None
 self._node = None
 self._text = text
 if date:
 def subrev(self, subpath):
 return None
 def manifestnode(self):
 return None
 def user(self):
 return self._user or self._repo.ui.username()
 def date(self):
 return self._date
 def description(self):
 return self._text
 def files(self):
-return sorted(self._status.modified + self._status.added +
+return sorted(
-self._status.removed)
+self._status.modified + self._status.added + self._status.removed
+)
 def modified(self):
 return self._status.modified
 def added(self):
 return self._status.added
 def removed(self):
 return self._status.removed
 def deleted(self):
 return self._status.deleted
 filesmodified = modified
 filesadded = added
 filesremoved = removed
 def branch(self):
 return encoding.tolocal(self._extra['branch'])
 def closesbranch(self):
 return 'close' in self._extra
 def extra(self):
 return self._extra
 def isinmemory(self):
 return False
 for p in self.parents():
 b.extend(p.bookmarks())
 return b
 def phase(self):
-phase = phases.draft # default phase to draft
+phase = phases.draft  # default phase to draft
 for p in self.parents():
 phase = max(phase, p.phase())
 return phase
 def hidden(self):
 def children(self):
 return []
 def ancestor(self, c2):
 """return the "best" ancestor context of self and c2"""
-return self._parents[0].ancestor(c2) # punt on two parents for now
+return self._parents[0].ancestor(c2)  # punt on two parents for now
 def ancestors(self):
 for p in self._parents:
 yield p
 for a in self._repo.changelog.ancestors(
-[p.rev() for p in self._parents]):
+[p.rev() for p in self._parents]
+):
 yield self._repo[a]
 def markcommitted(self, node):
 """Perform post-commit cleanup necessary after committing this ctx
 """
 def dirty(self, missing=False, merge=True, branch=True):
 return False
 class workingctx(committablectx):
 """A workingctx object makes access to data related to
 the current working directory convenient.
 date - any valid date string or (unixtime, offset), or None.
 user - username string, or None.
 extra - a dictionary of extra values, or None.
 changes - a list of file lists as returned by localrepo.status()
 or None to use the repository status.
 """
-def __init__(self, repo, text="", user=None, date=None, extra=None,
-changes=None):
+def __init__(
+self, repo, text="", user=None, date=None, extra=None, changes=None
+):
 branch = None
 if not extra or 'branch' not in extra:
 try:
 branch = repo.dirstate.branch()
 except UnicodeDecodeError:
 raise error.Abort(_('branch name not in UTF-8!'))
-super(workingctx, self).__init__(repo, text, user, date, extra, changes,
+super(workingctx, self).__init__(
-branch=branch)
+repo, text, user, date, extra, changes, branch=branch
+)
 def __iter__(self):
 d = self._repo.dirstate
 for f in d:
 if d[f] != 'r':
 copiesget = self._repo.dirstate.copies().get
 parents = self.parents()
 if len(parents) < 2:
 # when we have one parent, it's easy: copy from parent
 man = parents[0].manifest()
 def func(f):
 f = copiesget(f, f)
 return man.flags(f)
 else:
 # merges are tricky: we try to reconstruct the unstored
 # result from the merge (issue1802)
 p1, p2 = parents
 pa = p1.ancestor(p2)
 m1, m2, ma = p1.manifest(), p2.manifest(), pa.manifest()
 def func(f):
-f = copiesget(f, f) # may be wrong for merges with copies
+f = copiesget(f, f)  # may be wrong for merges with copies
 fl1, fl2, fla = m1.flags(f), m2.flags(f), ma.flags(f)
 if fl1 == fl2:
 return fl1
 if fl1 == fla:
 return fl2
 if fl2 == fla:
 return fl1
-return '' # punt for conflicts
+return ''  # punt for conflicts
 return func
 @propertycache
 def _flagfunc(self):
 except OSError:
 return ''
 def filectx(self, path, filelog=None):
 """get a file context from the working directory"""
-return workingfilectx(self._repo, path, workingctx=self,
+return workingfilectx(
-filelog=filelog)
+self._repo, path, workingctx=self, filelog=filelog
+)
 def dirty(self, missing=False, merge=True, branch=True):
 "check whether a working directory is modified"
 # check subrepos first
 for s in sorted(self.substate):
 if self.sub(s).dirty(missing=missing):
 return True
 # check current working dir
-return ((merge and self.p2()) or
+return (
-(branch and self.branch() != self.p1().branch()) or
+(merge and self.p2())
-self.modified() or self.added() or self.removed() or
+or (branch and self.branch() != self.p1().branch())
-(missing and self.deleted()))
+or self.modified()
+or self.added()
+or self.removed()
+or (missing and self.deleted())
+)
 def add(self, list, prefix=""):
 with self._repo.wlock():
 ui, ds = self._repo.ui, self._repo.dirstate
 uipath = lambda f: ds.pathto(pathutil.join(prefix, f))
 ui.warn(_("%s does not exist!\n") % uipath(f))
 rejected.append(f)
 continue
 limit = ui.configbytes('ui', 'large-file-limit')
 if limit != 0 and st.st_size > limit:
-ui.warn(_("%s: up to %d MB of RAM may be required "
+ui.warn(
-"to manage this file\n"
+_(
-"(use 'hg revert %s' to cancel the "
+"%s: up to %d MB of RAM may be required "
-"pending addition)\n")
+"to manage this file\n"
-% (f, 3 * st.st_size // 1000000, uipath(f)))
+"(use 'hg revert %s' to cancel the "
+"pending addition)\n"
+)
+% (f, 3 * st.st_size // 1000000, uipath(f))
+)
 if not (stat.S_ISREG(st.st_mode) or stat.S_ISLNK(st.st_mode)):
-ui.warn(_("%s not added: only files and symlinks "
+ui.warn(
-"supported currently\n") % uipath(f))
+_(
+"%s not added: only files and symlinks "
+"supported currently\n"
+)
+% uipath(f)
+)
 rejected.append(f)
 elif ds[f] in 'amn':
 ui.warn(_("%s already tracked!\n") % uipath(f))
 elif ds[f] == 'r':
 ds.normallookup(f)
 try:
 st = self._repo.wvfs.lstat(dest)
 except OSError as err:
 if err.errno != errno.ENOENT:
 raise
-self._repo.ui.warn(_("%s does not exist!\n")
+self._repo.ui.warn(
-% self._repo.dirstate.pathto(dest))
+_("%s does not exist!\n") % self._repo.dirstate.pathto(dest)
+)
 return
 if not (stat.S_ISREG(st.st_mode) or stat.S_ISLNK(st.st_mode)):
-self._repo.ui.warn(_("copy failed: %s is not a file or a "
+self._repo.ui.warn(
-"symbolic link\n")
+_("copy failed: %s is not a file or a " "symbolic link\n")
-% self._repo.dirstate.pathto(dest))
+% self._repo.dirstate.pathto(dest)
+)
 else:
 with self._repo.wlock():
 ds = self._repo.dirstate
 if ds[dest] in '?':
 ds.add(dest)
 elif ds[dest] in 'r':
 ds.normallookup(dest)
 ds.copy(source, dest)
-def match(self, pats=None, include=None, exclude=None, default='glob',
+def match(
-listsubrepos=False, badfn=None):
+self,
+pats=None,
+include=None,
+exclude=None,
+default='glob',
+listsubrepos=False,
+badfn=None,
+):
 r = self._repo
 # Only a case insensitive filesystem needs magic to translate user input
 # to actual case in the filesystem.
 icasefs = not util.fscasesensitive(r.root)
-return matchmod.match(r.root, r.getcwd(), pats, include, exclude,
+return matchmod.match(
-default, auditor=r.auditor, ctx=self,
+r.root,
-listsubrepos=listsubrepos, badfn=badfn,
+r.getcwd(),
-icasefs=icasefs)
+pats,
+include,
+exclude,
+default,
+auditor=r.auditor,
+ctx=self,
+listsubrepos=listsubrepos,
+badfn=badfn,
+icasefs=icasefs,
+)
 def _filtersuspectsymlink(self, files):
 if not files or self._repo.dirstate._checklink:
 return files
 # symlink
 sane = []
 for f in files:
 if self.flags(f) == 'l':
 d = self[f].data()
-if (d == '' or len(d) >= 1024 or '\n' in d
+if (
-or stringutil.binary(d)):
+d == ''
-self._repo.ui.debug('ignoring suspect symlink placeholder'
+or len(d) >= 1024
-' "%s"\n' % f)
+or '\n' in d
+or stringutil.binary(d)
+):
+self._repo.ui.debug(
+'ignoring suspect symlink placeholder' ' "%s"\n' % f
+)
 continue
 sane.append(f)
 return sane
 def _checklookup(self, files):
 # do a full compare of any files that might have changed
 for f in sorted(files):
 try:
 # This will return True for a file that got replaced by a
 # directory in the interim, but fixing that is pretty hard.
-if (f not in pctx or self.flags(f) != pctx.flags(f)
+if (
-or pctx[f].cmp(self[f])):
+f not in pctx
+or self.flags(f) != pctx.flags(f)
+or pctx[f].cmp(self[f])
+):
 modified.append(f)
 else:
 fixup.append(f)
 except (IOError, OSError):
 # A file become inaccessible in between? Mark it as deleted,
 else:
 # in this case, writing changes out breaks
 # consistency, because .hg/dirstate was
 # already changed simultaneously after last
 # caching (see also issue5584 for detail)
-self._repo.ui.debug('skip updating dirstate: '
+self._repo.ui.debug(
-'identity mismatch\n')
+'skip updating dirstate: ' 'identity mismatch\n'
+)
 except error.LockError:
 pass
 finally:
 # Even if the wlock couldn't be grabbed, clear out the list.
 self._repo.clearpostdsstatus()
 def _dirstatestatus(self, match, ignored=False, clean=False, unknown=False):
 '''Gets the status from the dirstate -- internal use only.'''
 subrepos = []
 if '.hgsub' in self:
 subrepos = sorted(self.substate)
-cmp, s = self._repo.dirstate.status(match, subrepos, ignored=ignored,
+cmp, s = self._repo.dirstate.status(
-clean=clean, unknown=unknown)
+match, subrepos, ignored=ignored, clean=clean, unknown=unknown
+)
 # check for any possibly clean files
 fixup = []
 if cmp:
 modified2, deleted2, fixup = self._checklookup(cmp)
 if match.always():
 # cache for performance
 if s.unknown or s.ignored or s.clean:
 # "_status" is cached with list*=False in the normal route
-self._status = scmutil.status(s.modified, s.added, s.removed,
+self._status = scmutil.status(
-s.deleted, [], [], [])
+s.modified, s.added, s.removed, s.deleted, [], [], []
+)
 else:
 self._status = s
 return s
 parents = self.parents()
 man = parents[0].manifest().copy()
 ff = self._flagfunc
-for i, l in ((addednodeid, status.added),
+for i, l in (
-(modifiednodeid, status.modified)):
+(addednodeid, status.added),
+(modifiednodeid, status.modified),
+):
 for f in l:
 man[f] = i
 try:
 man.setflag(f, ff(f))
 except OSError:
 if f in man:
 del man[f]
 return man
-def _buildstatus(self, other, s, match, listignored, listclean,
+def _buildstatus(
-listunknown):
+self, other, s, match, listignored, listclean, listunknown
+):
 """build a status with respect to another context
 This includes logic for maintaining the fast path of status when
 comparing the working directory against its parent, which is to skip
 building a new manifest if self (working directory) is not comparing
 # Filter out symlinks that, in the case of FAT32 and NTFS filesystems,
 # might have accidentally ended up with the entire contents of the file
 # they are supposed to be linking to.
 s.modified[:] = self._filtersuspectsymlink(s.modified)
 if other != self._repo['.']:
-s = super(workingctx, self)._buildstatus(other, s, match,
+s = super(workingctx, self)._buildstatus(
-listignored, listclean,
+other, s, match, listignored, listclean, listunknown
-listunknown)
+)
 return s
 def _matchstatus(self, other, match):
 """override the match method with a filter for directory patterns
 If we aren't comparing against the working directory's parent, then we
 just use the default match object sent to us.
 """
 if other != self._repo['.']:
 def bad(f, msg):
 # 'f' may be a directory pattern from 'match.files()',
 # so 'f not in ctx1' is not enough
 if f not in other and not other.hasdir(f):
-self._repo.ui.warn('%s: %s\n' %
+self._repo.ui.warn(
-(self._repo.dirstate.pathto(f), msg))
+'%s: %s\n' % (self._repo.dirstate.pathto(f), msg)
+)
 match.bad = bad
 return match
 def walk(self, match):
 '''Generates matching file names.'''
-return sorted(self._repo.dirstate.walk(self._repo.narrowmatch(match),
+return sorted(
-subrepos=sorted(self.substate),
+self._repo.dirstate.walk(
-unknown=True, ignored=False))
+self._repo.narrowmatch(match),
+subrepos=sorted(self.substate),
+unknown=True,
+ignored=False,
+)
+)
 def matches(self, match):
 match = self._repo.narrowmatch(match)
 ds = self._repo.dirstate
 return sorted(f for f in ds.matches(match) if ds[f] != 'r')
 # from immediately doing so for subsequent changing files
 self._repo.dirstate.write(self._repo.currenttransaction())
 sparse.aftercommit(self._repo, node)
 class committablefilectx(basefilectx):
 """A committablefilectx provides common functionality for a file context
 that wants the ability to commit, e.g. workingfilectx or memfilectx."""
 def __init__(self, repo, path, filelog=None, ctx=None):
 self._repo = repo
 self._path = path
 self._changeid = None
 self._filerev = self._filenode = None
 return None
 return path, self._changectx._parents[0]._manifest.get(path, nullid)
 def parents(self):
 '''return parent filectxs, following copies if necessary'''
 def filenode(ctx, path):
 return ctx._manifest.get(path, nullid)
 path = self._path
 fl = self._filelog
 pl = [(path, filenode(pcl[0], path), fl)]
 for pc in pcl[1:]:
 pl.append((path, filenode(pc, path), fl))
-return [self._parentfilectx(p, fileid=n, filelog=l)
+return [
-for p, n, l in pl if n != nullid]
+self._parentfilectx(p, fileid=n, filelog=l)
+for p, n, l in pl
+if n != nullid
+]
 def children(self):
 return []
 class workingfilectx(committablefilectx):
 """A workingfilectx object makes access to data related to a particular
 file in the working directory convenient."""
 def __init__(self, repo, path, filelog=None, workingctx=None):
 super(workingfilectx, self).__init__(repo, path, filelog, workingctx)
 @propertycache
 def _changectx(self):
 return workingctx(self._repo)
 def data(self):
 return self._repo.wread(self._path)
 def copysource(self):
 return self._repo.dirstate.copied(self._path)
 def size(self):
 return self._repo.wvfs.lstat(self._path).st_size
 def lstat(self):
 return self._repo.wvfs.lstat(self._path)
 def date(self):
 t, tz = self._changectx.date()
 try:
 return (self._repo.wvfs.lstat(self._path)[stat.ST_MTIME], tz)
 except OSError as err:
 return fctx.cmp(self)
 def remove(self, ignoremissing=False):
 """wraps unlink for a repo's working directory"""
 rmdir = self._repo.ui.configbool('experimental', 'removeemptydirs')
-self._repo.wvfs.unlinkpath(self._path, ignoremissing=ignoremissing,
+self._repo.wvfs.unlinkpath(
-rmdir=rmdir)
+self._path, ignoremissing=ignoremissing, rmdir=rmdir
+)
 def write(self, data, flags, backgroundclose=False, **kwargs):
 """wraps repo.wwrite"""
-return self._repo.wwrite(self._path, data, flags,
+return self._repo.wwrite(
-backgroundclose=backgroundclose,
+self._path, data, flags, backgroundclose=backgroundclose, **kwargs
-**kwargs)
+)
 def markcopied(self, src):
 """marks this file a copy of `src`"""
 self._repo.dirstate.copy(src, self._path)
 wvfs.removedirs(f)
 def setflags(self, l, x):
 self._repo.wvfs.setflags(self._path, l, x)
 class overlayworkingctx(committablectx):
 """Wraps another mutable context with a write-back cache that can be
 converted into a commit context.
 self._cache[path] maps to a dict with keys: {
 return self._cache[path]['data']
 else:
 # Must fallback here, too, because we only set flags.
 return self._wrappedctx[path].data()
 else:
-raise error.ProgrammingError("No such file or directory: %s" %
+raise error.ProgrammingError(
-path)
+"No such file or directory: %s" % path
+)
 else:
 return self._wrappedctx[path].data()
 @propertycache
 def _manifest(self):
 @propertycache
 def _flagfunc(self):
 def f(path):
 return self._cache[path]['flags']
 return f
 def files(self):
 return sorted(self.added() + self.modified() + self.removed())
 def modified(self):
-return [f for f in self._cache.keys() if self._cache[f]['exists'] and
+return [
-self._existsinparent(f)]
+f
+for f in self._cache.keys()
+if self._cache[f]['exists'] and self._existsinparent(f)
+]
 def added(self):
-return [f for f in self._cache.keys() if self._cache[f]['exists'] and
+return [
-not self._existsinparent(f)]
+f
+for f in self._cache.keys()
+if self._cache[f]['exists'] and not self._existsinparent(f)
+]
 def removed(self):
-return [f for f in self._cache.keys() if
+return [
-not self._cache[f]['exists'] and self._existsinparent(f)]
+f
+for f in self._cache.keys()
+if not self._cache[f]['exists'] and self._existsinparent(f)
+]
 def p1copies(self):
 copies = self._repo._wrappedctx.p1copies().copy()
 narrowmatch = self._repo.narrowmatch()
 for f in self._cache.keys():
 if not narrowmatch(f):
 continue
-copies.pop(f, None) # delete if it exists
+copies.pop(f, None)  # delete if it exists
 source = self._cache[f]['copied']
 if source:
 copies[f] = source
 return copies
 copies = self._repo._wrappedctx.p2copies().copy()
 narrowmatch = self._repo.narrowmatch()
 for f in self._cache.keys():
 if not narrowmatch(f):
 continue
-copies.pop(f, None) # delete if it exists
+copies.pop(f, None)  # delete if it exists
 source = self._cache[f]['copied']
 if source:
 copies[f] = source
 return copies
 return self._cache[path]['date']
 else:
 return self._wrappedctx[path].date()
 def markcopied(self, path, origin):
-self._markdirty(path, exists=True, date=self.filedate(path),
+self._markdirty(
-flags=self.flags(path), copied=origin)
+path,
+exists=True,
+date=self.filedate(path),
+flags=self.flags(path),
+copied=origin,
+)
 def copydata(self, path):
 if self.isdirty(path):
 return self._cache[path]['copied']
 else:
 def flags(self, path):
 if self.isdirty(path):
 if self._cache[path]['exists']:
 return self._cache[path]['flags']
 else:
-raise error.ProgrammingError("No such file or directory: %s" %
+raise error.ProgrammingError(
-self._path)
+"No such file or directory: %s" % self._path
+)
 else:
 return self._wrappedctx[path].flags()
 def __contains__(self, key):
 if key in self._cache:
 Since we never write to the filesystem and never call `applyupdates` in
 IMM, we'll never check that a path is actually writable -- e.g., because
 it adds `a/foo`, but `a` is actually a file in the other commit.
 """
 def fail(path, component):
 # p1() is the base and we're receiving "writes" for p2()'s
 # files.
 if 'l' in self.p1()[component].flags():
-raise error.Abort("error: %s conflicts with symlink %s "
+raise error.Abort(
-"in %d." % (path, component,
+"error: %s conflicts with symlink %s "
-self.p1().rev()))
+"in %d." % (path, component, self.p1().rev())
+)
 else:
-raise error.Abort("error: '%s' conflicts with file '%s' in "
+raise error.Abort(
-"%d." % (path, component,
+"error: '%s' conflicts with file '%s' in "
-self.p1().rev()))
+"%d." % (path, component, self.p1().rev())
+)
 # Test that each new directory to be created to write this path from p2
 # is not a file in p1.
 components = path.split('/')
 for i in pycompat.xrange(len(components)):
 return
 # omit the files which are deleted in current IMM wctx
 mfiles = [m for m in mfiles if m in self]
 if not mfiles:
 return
-raise error.Abort("error: file '%s' cannot be written because "
+raise error.Abort(
-" '%s/' is a directory in %s (containing %d "
+"error: file '%s' cannot be written because "
-"entries: %s)"
+" '%s/' is a directory in %s (containing %d "
-% (path, path, self.p1(), len(mfiles),
+"entries: %s)"
-', '.join(mfiles)))
+% (path, path, self.p1(), len(mfiles), ', '.join(mfiles))
+)
 def write(self, path, data, flags='', **kwargs):
 if data is None:
 raise error.ProgrammingError("data must be non-None")
 self._auditconflicts(path)
-self._markdirty(path, exists=True, data=data, date=dateutil.makedate(),
+self._markdirty(
-flags=flags)
+path, exists=True, data=data, date=dateutil.makedate(), flags=flags
+)
 def setflags(self, path, l, x):
 flag = ''
 if l:
 flag = 'l'
 elif x:
 flag = 'x'
-self._markdirty(path, exists=True, date=dateutil.makedate(),
+self._markdirty(path, exists=True, date=dateutil.makedate(), flags=flag)
-flags=flag)
 def remove(self, path):
 self._markdirty(path, exists=False)
 def exists(self, path):
 return False if they are broken.
 """
 if self.isdirty(path):
 # If this path exists and is a symlink, "follow" it by calling
 # exists on the destination path.
-if (self._cache[path]['exists'] and
+if (
-'l' in self._cache[path]['flags']):
+self._cache[path]['exists']
+and 'l' in self._cache[path]['flags']
+):
 return self.exists(self._cache[path]['data'].strip())
 else:
 return self._cache[path]['exists']
 return self._existsinparent(path)
 def size(self, path):
 if self.isdirty(path):
 if self._cache[path]['exists']:
 return len(self._cache[path]['data'])
 else:
-raise error.ProgrammingError("No such file or directory: %s" %
+raise error.ProgrammingError(
-self._path)
+"No such file or directory: %s" % self._path
+)
 return self._wrappedctx[path].size()
-def tomemctx(self, text, branch=None, extra=None, date=None, parents=None,
+def tomemctx(
-user=None, editor=None):
+self,
+text,
+branch=None,
+extra=None,
+date=None,
+parents=None,
+user=None,
+editor=None,
+):
 """Converts this ``overlayworkingctx`` into a ``memctx`` ready to be
 committed.
 ``text`` is the commit message.
 ``parents`` (optional) are rev numbers.
 parents = (self._repo[parents[0]], None)
 else:
 parents = (self._repo[parents[0]], self._repo[parents[1]])
 files = self.files()
 def getfile(repo, memctx, path):
 if self._cache[path]['exists']:
-return memfilectx(repo, memctx, path,
+return memfilectx(
-self._cache[path]['data'],
+repo,
-'l' in self._cache[path]['flags'],
+memctx,
-'x' in self._cache[path]['flags'],
+path,
-self._cache[path]['copied'])
+self._cache[path]['data'],
+'l' in self._cache[path]['flags'],
+'x' in self._cache[path]['flags'],
+self._cache[path]['copied'],
+)
 else:
 # Returning None, but including the path in `files`, is
 # necessary for memctx to register a deletion.
 return None
-return memctx(self._repo, parents, text, files, getfile, date=date,
-extra=extra, user=user, branch=branch, editor=editor)
+return memctx(
+self._repo,
+parents,
+text,
+files,
+getfile,
+date=date,
+extra=extra,
+user=user,
+branch=branch,
+editor=editor,
+)
 def isdirty(self, path):
 return path in self._cache
 def isempty(self):
 """
 keys = []
 # This won't be perfect, but can help performance significantly when
 # using things like remotefilelog.
 scmutil.prefetchfiles(
-self.repo(), [self.p1().rev()],
+self.repo(),
-scmutil.matchfiles(self.repo(), self._cache.keys()))
+[self.p1().rev()],
+scmutil.matchfiles(self.repo(), self._cache.keys()),
+)
 for path in self._cache.keys():
 cache = self._cache[path]
 try:
 underlying = self._wrappedctx[path]
-if (underlying.data() == cache['data'] and
+if (
-underlying.flags() == cache['flags']):
+underlying.data() == cache['data']
+and underlying.flags() == cache['flags']
+):
 keys.append(path)
 except error.ManifestLookupError:
 # Path not in the underlying manifest (created).
 continue
 for path in keys:
 del self._cache[path]
 return keys
-def _markdirty(self, path, exists, data=None, date=None, flags='',
+def _markdirty(
-copied=None):
+self, path, exists, data=None, date=None, flags='', copied=None
+):
 # data not provided, let's see if we already have some; if not, let's
 # grab it from our underlying context, so that we always have data if
 # the file is marked as existing.
 if exists and data is None:
 oldentry = self._cache.get(path) or {}
 'flags': flags,
 'copied': copied,
 }
 def filectx(self, path, filelog=None):
-return overlayworkingfilectx(self._repo, path, parent=self,
+return overlayworkingfilectx(
-filelog=filelog)
+self._repo, path, parent=self, filelog=filelog
+)
 class overlayworkingfilectx(committablefilectx):
 """Wrap a ``workingfilectx`` but intercepts all writes into an in-memory
 cache, which can be flushed through later by calling ``flush()``."""
 def __init__(self, repo, path, filelog=None, parent=None):
-super(overlayworkingfilectx, self).__init__(repo, path, filelog,
+super(overlayworkingfilectx, self).__init__(repo, path, filelog, parent)
-parent)
 self._repo = repo
 self._parent = parent
 self._path = path
 def cmp(self, fctx):
 return self._parent.remove(self._path)
 def clearunknown(self):
 pass
 class workingcommitctx(workingctx):
 """A workingcommitctx object makes access to data related to
 the revision being committed convenient.
 This hides changes in the working directory, if they aren't
 committed in this context.
 """
-def __init__(self, repo, changes,
-text="", user=None, date=None, extra=None):
+def __init__(
-super(workingcommitctx, self).__init__(repo, text, user, date, extra,
+self, repo, changes, text="", user=None, date=None, extra=None
-changes)
+):
+super(workingcommitctx, self).__init__(
+repo, text, user, date, extra, changes
+)
 def _dirstatestatus(self, match, ignored=False, clean=False, unknown=False):
 """Return matched files only in ``self._status``
 Uncommitted files appear "clean" via this context, even if
 """
 if clean:
 clean = [f for f in self._manifest if f not in self._changedset]
 else:
 clean = []
-return scmutil.status([f for f in self._status.modified if match(f)],
+return scmutil.status(
-[f for f in self._status.added if match(f)],
+[f for f in self._status.modified if match(f)],
-[f for f in self._status.removed if match(f)],
+[f for f in self._status.added if match(f)],
-[], [], [], clean)
+[f for f in self._status.removed if match(f)],
+[],
+[],
+[],
+clean,
+)
 @propertycache
 def _changedset(self):
 """Return the set of files changed in this context
 """
 changed = set(self._status.modified)
 changed.update(self._status.added)
 changed.update(self._status.removed)
 return changed
 def makecachingfilectxfn(func):
 """Create a filectxfn that caches based on the path.
 We can't use util.cachefunc because it uses all arguments as the cache
 cache[path] = func(repo, memctx, path)
 return cache[path]
 return getfilectx
 def memfilefromctx(ctx):
 """Given a context return a memfilectx for ctx[path]
 This is a convenience method for building a memctx based on another
 context.
 """
 def getfilectx(repo, memctx, path):
 fctx = ctx[path]
 copysource = fctx.copysource()
-return memfilectx(repo, memctx, path, fctx.data(),
+return memfilectx(
-islink=fctx.islink(), isexec=fctx.isexec(),
+repo,
-copysource=copysource)
+memctx,
+path,
+fctx.data(),
+islink=fctx.islink(),
+isexec=fctx.isexec(),
+copysource=copysource,
+)
 return getfilectx
 def memfilefrompatch(patchstore):
 """Given a patch (e.g. patchstore object) return a memfilectx
 This is a convenience method for building a memctx based on a patchstore.
 """
 def getfilectx(repo, memctx, path):
 data, mode, copysource = patchstore.getfile(path)
 if data is None:
 return None
 islink, isexec = mode
-return memfilectx(repo, memctx, path, data, islink=islink,
+return memfilectx(
-isexec=isexec, copysource=copysource)
+repo,
+memctx,
+path,
+data,
+islink=islink,
+isexec=isexec,
+copysource=copysource,
+)
 return getfilectx
 class memctx(committablectx):
 """Use memctx to perform in-memory commits via localrepo.commitctx().
 Revision information is supplied at initialization time while
 # Mercurial <= 3.1 expects the filectxfn to raise IOError for missing files.
 # Extensions that need to retain compatibility across Mercurial 3.1 can use
 # this field to determine what to do in filectxfn.
 _returnnoneformissingfiles = True
-def __init__(self, repo, parents, text, files, filectxfn, user=None,
+def __init__(
-date=None, extra=None, branch=None, editor=False):
+self,
-super(memctx, self).__init__(repo, text, user, date, extra,
+repo,
-branch=branch)
+parents,
+text,
+files,
+filectxfn,
+user=None,
+date=None,
+extra=None,
+branch=None,
+editor=False,
+):
+super(memctx, self).__init__(
+repo, text, user, date, extra, branch=branch
+)
 self._rev = None
 self._node = None
 parents = [(p or nullid) for p in parents]
 p1, p2 = parents
 self._parents = [self._repo[p] for p in (p1, p2)]
 else:
 removed.append(f)
 return scmutil.status(modified, added, removed, [], [], [], [])
 class memfilectx(committablefilectx):
 """memfilectx represents an in-memory file to commit.
 See memctx and committablefilectx for more details.
 """
-def __init__(self, repo, changectx, path, data, islink=False,
-isexec=False, copysource=None):
+def __init__(
+self,
+repo,
+changectx,
+path,
+data,
+islink=False,
+isexec=False,
+copysource=None,
+):
 """
 path is the normalized file path relative to repository root.
 data is the file content as a string.
 islink is True if the file is a symbolic link.
 isexec is True if the file is executable.
 user receives the committer name and defaults to current repository
 username, date is the commit date in any format supported by
 dateutil.parsedate() and defaults to current date, extra is a dictionary of
 metadata or is left empty.
 """
-def __init__(self, repo, originalctx, parents=None, text=None, user=None,
-date=None, extra=None, editor=False):
+def __init__(
+self,
+repo,
+originalctx,
+parents=None,
+text=None,
+user=None,
+date=None,
+extra=None,
+editor=False,
+):
 if text is None:
 text = originalctx.description()
 super(metadataonlyctx, self).__init__(repo, text, user, date, extra)
 self._rev = None
 self._node = None
 # sanity check to ensure that the reused manifest parents are
 # manifests of our commit parents
 mp1, mp2 = self.manifestctx().parents
 if p1 != nullid and p1.manifestnode() != mp1:
-raise RuntimeError(r"can't reuse the manifest: its p1 "
+raise RuntimeError(
-r"doesn't match the new ctx p1")
+r"can't reuse the manifest: its p1 "
+r"doesn't match the new ctx p1"
+)
 if p2 != nullid and p2.manifestnode() != mp2:
-raise RuntimeError(r"can't reuse the manifest: "
+raise RuntimeError(
-r"its p2 doesn't match the new ctx p2")
+r"can't reuse the manifest: "
+r"its p2 doesn't match the new ctx p2"
+)
 self._files = originalctx.files()
 self.substate = {}
 if editor:
 else:
 removed.append(f)
 return scmutil.status(modified, added, removed, [], [], [], [])
 class arbitraryfilectx(object):
 """Allows you to use filectx-like functions on a file in an arbitrary
 location on disk, possibly not in the working directory.
 """
 def __init__(self, path, repo=None):
 # Repo is optional because contrib/simplemerge uses this class.
 self._repo = repo
 self._path = path
 def cmp(self, fctx):
 # filecmp follows symlinks whereas `cmp` should not, so skip the fast
 # path if either side is a symlink.
-symlinks = ('l' in self.flags() or 'l' in fctx.flags())
+symlinks = 'l' in self.flags() or 'l' in fctx.flags()
 if not symlinks and isinstance(fctx, workingfilectx) and self._repo:
 # Add a fast-path for merge if both sides are disk-backed.
 # Note that filecmp uses the opposite return values (True if same)
 # from our cmp functions (True if different).
 return not filecmp.cmp(self.path(), self._repo.wjoin(fctx.path()))

changeset 43076	2372284d9457
parent 43023	8af909893188
child 43077	687b865b95ad