mercurial-scm/hg-stable: mercurial/revset.py comparison

comparison mercurial/revset.py @ 43076:2372284d9457

formatting: blacken the codebase This is using my patch to black (https://github.com/psf/black/pull/826) so we don't un-wrap collection literals. Done with: hg files 'set:**.py - mercurial/thirdparty/** - "contrib/python-zstandard/**"' | xargs black -S # skip-blame mass-reformatting only # no-check-commit reformats foo_bar functions Differential Revision: https://phab.mercurial-scm.org/D6971

author	Augie Fackler <augie@google.com>
date	Sun, 06 Oct 2019 09:45:02 -0400
parents	911e25dc9d8c
children	687b865b95ad

comparison

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 #           ^^^^^^
 #      For most revsets, 'define' means using the order this subset provides
 #
 # There are a few revsets that always redefine the order if 'define' is
 # specified: 'sort(X)', 'reverse(X)', 'x:y'.
-anyorder = 'any'        # don't care the order, could be even random-shuffled
+anyorder = 'any'  # don't care the order, could be even random-shuffled
 defineorder = 'define'  # ALWAYS redefine, or ALWAYS follow the current order
 followorder = 'follow'  # MUST follow the current order
 # helpers
 def getset(repo, subset, x, order=defineorder):
 if not x:
 raise error.ParseError(_("missing argument"))
 return methods[x[0]](repo, subset, *x[1:], order=order)
 def _getrevsource(repo, r):
 extra = repo[r].extra()
 for label in ('source', 'transplant_source', 'rebase_source'):
 if label in extra:
 return repo[extra[label]].rev()
 except error.RepoLookupError:
 pass
 return None
 def _sortedb(xs):
 return sorted(pycompat.rapply(pycompat.maybebytestr, xs))
 # operator methods
 def stringset(repo, subset, x, order):
 if not x:
 raise error.ParseError(_("empty string is not a valid revision"))
 x = scmutil.intrev(scmutil.revsymbol(repo, x))
 if x in subset or x in _virtualrevs and isinstance(subset, fullreposet):
 return baseset([x])
 return baseset()
 def rawsmartset(repo, subset, x, order):
 """argument is already a smartset, use that directly"""
 if order == followorder:
 return subset & x
 else:
 return x & subset
 def rangeset(repo, subset, x, y, order):
 m = getset(repo, fullreposet(repo), x)
 n = getset(repo, fullreposet(repo), y)
 if not m or not n:
 return baseset()
 return _makerangeset(repo, subset, m.first(), n.last(), order)
 def rangeall(repo, subset, x, order):
 assert x is None
 return _makerangeset(repo, subset, 0, repo.changelog.tiprev(), order)
 def rangepre(repo, subset, y, order):
 # ':y' can't be rewritten to '0:y' since '0' may be hidden
 n = getset(repo, fullreposet(repo), y)
 if not n:
 return baseset()
 return _makerangeset(repo, subset, 0, n.last(), order)
 def rangepost(repo, subset, x, order):
 m = getset(repo, fullreposet(repo), x)
 if not m:
 return baseset()
-return _makerangeset(repo, subset, m.first(), repo.changelog.tiprev(),
+return _makerangeset(
-order)
+repo, subset, m.first(), repo.changelog.tiprev(), order
+)
 def _makerangeset(repo, subset, m, n, order):
 if m == n:
 r = baseset([m])
 elif n == node.wdirrev:
 return r & subset
 else:
 # carrying the sorting over when possible would be more efficient
 return subset & r
 def dagrange(repo, subset, x, y, order):
 r = fullreposet(repo)
-xs = dagop.reachableroots(repo, getset(repo, r, x), getset(repo, r, y),
+xs = dagop.reachableroots(
-includepath=True)
+repo, getset(repo, r, x), getset(repo, r, y), includepath=True
+)
 return subset & xs
 def andset(repo, subset, x, y, order):
 if order == anyorder:
 yorder = anyorder
 else:
 yorder = followorder
 return getset(repo, getset(repo, subset, x, order), y, yorder)
 def andsmallyset(repo, subset, x, y, order):
 # 'andsmally(x, y)' is equivalent to 'and(x, y)', but faster when y is small
 if order == anyorder:
 yorder = anyorder
 else:
 yorder = followorder
 return getset(repo, getset(repo, subset, y, yorder), x, order)
 def differenceset(repo, subset, x, y, order):
 return getset(repo, subset, x, order) - getset(repo, subset, y, anyorder)
 def _orsetlist(repo, subset, xs, order):
 assert xs
 if len(xs) == 1:
 return getset(repo, subset, xs[0], order)
 p = len(xs) // 2
 a = _orsetlist(repo, subset, xs[:p], order)
 b = _orsetlist(repo, subset, xs[p:], order)
 return a + b
 def orset(repo, subset, x, order):
 xs = getlist(x)
 if not xs:
 return baseset()
 # slow path to take the subset order
 return subset & _orsetlist(repo, fullreposet(repo), xs, anyorder)
 else:
 return _orsetlist(repo, subset, xs, order)
 def notset(repo, subset, x, order):
 return subset - getset(repo, subset, x, anyorder)
 def relationset(repo, subset, x, y, order):
 raise error.ParseError(_("can't use a relation in this context"))
 def _splitrange(a, b):
 """Split range with bounds a and b into two ranges at 0 and return two
 tuples of numbers for use as startdepth and stopdepth arguments of
 revancestors and revdescendants.
 ancdepths = (-min(b, 0), -a + 1)
 if b > 0:
 descdepths = (max(a, 0), b + 1)
 return ancdepths, descdepths
 def generationsrel(repo, subset, x, rel, z, order):
 # TODO: rewrite tests, and drop startdepth argument from ancestors() and
 # descendants() predicates
-a, b = getintrange(z,
+a, b = getintrange(
-_('relation subscript must be an integer or a range'),
+z,
-_('relation subscript bounds must be integers'),
+_('relation subscript must be an integer or a range'),
-deffirst=-(dagop.maxlogdepth - 1),
+_('relation subscript bounds must be integers'),
-deflast=+(dagop.maxlogdepth - 1))
+deffirst=-(dagop.maxlogdepth - 1),
+deflast=+(dagop.maxlogdepth - 1),
+)
 (ancstart, ancstop), (descstart, descstop) = _splitrange(a, b)
 if ancstart is None and descstart is None:
 return baseset()
 elif descstart is not None:
 s = dagop.revdescendants(repo, revs, False, descstart, descstop)
 return subset & s
 def relsubscriptset(repo, subset, x, y, z, order):
 # this is pretty basic implementation of 'x#y[z]' operator, still
 # experimental so undocumented. see the wiki for further ideas.
 # https://www.mercurial-scm.org/wiki/RevsetOperatorPlan
 rel = getsymbol(y)
 return subscriptrelations[rel](repo, subset, x, rel, z, order)
 relnames = [r for r in subscriptrelations.keys() if len(r) > 1]
 raise error.UnknownIdentifier(rel, relnames)
 def subscriptset(repo, subset, x, y, order):
 raise error.ParseError(_("can't use a subscript in this context"))
 def listset(repo, subset, *xs, **opts):
-raise error.ParseError(_("can't use a list in this context"),
+raise error.ParseError(
-hint=_('see \'hg help "revsets.x or y"\''))
+_("can't use a list in this context"),
+hint=_('see \'hg help "revsets.x or y"\''),
+)
 def keyvaluepair(repo, subset, k, v, order):
 raise error.ParseError(_("can't use a key-value pair in this context"))
 def func(repo, subset, a, b, order):
 f = getsymbol(a)
 if f in symbols:
 func = symbols[f]
 keep = lambda fn: getattr(fn, '__doc__', None) is not None
 syms = [s for (s, fn) in symbols.items() if keep(fn)]
 raise error.UnknownIdentifier(f, syms)
 # functions
 # symbols are callables like:
 #   fn(repo, subset, x)
 # with:
 # functions that just return a lot of changesets (like all) don't count here
 safesymbols = set()
 predicate = registrar.revsetpredicate()
 @predicate('_destupdate')
 def _destupdate(repo, subset, x):
 # experimental revset for update destination
 args = getargsdict(x, 'limit', 'clean')
-return subset & baseset([destutil.destupdate(repo,
+return subset & baseset(
-**pycompat.strkwargs(args))[0]])
+[destutil.destupdate(repo, **pycompat.strkwargs(args))[0]]
+)
 @predicate('_destmerge')
 def _destmerge(repo, subset, x):
 # experimental revset for merge destination
 sourceset = None
 if x is not None:
 sourceset = getset(repo, fullreposet(repo), x)
 return subset & baseset([destutil.destmerge(repo, sourceset=sourceset)])
 @predicate('adds(pattern)', safe=True, weight=30)
 def adds(repo, subset, x):
 """Changesets that add a file matching pattern.
 The pattern without explicit kind like ``glob:`` is expected to be
 directory.
 """
 # i18n: "adds" is a keyword
 pat = getstring(x, _("adds requires a pattern"))
 return checkstatus(repo, subset, pat, 1)
 @predicate('ancestor(*changeset)', safe=True, weight=0.5)
 def ancestor(repo, subset, x):
 """A greatest common ancestor of the changesets.
 r = scmutil.intrev(anc)
 if r in subset:
 return baseset([r])
 return baseset()
-def _ancestors(repo, subset, x, followfirst=False, startdepth=None,
-stopdepth=None):
+def _ancestors(
+repo, subset, x, followfirst=False, startdepth=None, stopdepth=None
+):
 heads = getset(repo, fullreposet(repo), x)
 if not heads:
 return baseset()
 s = dagop.revancestors(repo, heads, followfirst, startdepth, stopdepth)
 return subset & s
 @predicate('ancestors(set[, depth])', safe=True)
 def ancestors(repo, subset, x):
 """Changesets that are ancestors of changesets in set, including the
 given changesets themselves.
 if 'set' not in args:
 # i18n: "ancestors" is a keyword
 raise error.ParseError(_('ancestors takes at least 1 argument'))
 startdepth = stopdepth = None
 if 'startdepth' in args:
-n = getinteger(args['startdepth'],
+n = getinteger(
-"ancestors expects an integer startdepth")
+args['startdepth'], "ancestors expects an integer startdepth"
+)
 if n < 0:
 raise error.ParseError("negative startdepth")
 startdepth = n
 if 'depth' in args:
 # i18n: "ancestors" is a keyword
 n = getinteger(args['depth'], _("ancestors expects an integer depth"))
 if n < 0:
 raise error.ParseError(_("negative depth"))
 stopdepth = n + 1
-return _ancestors(repo, subset, args['set'],
+return _ancestors(
-startdepth=startdepth, stopdepth=stopdepth)
+repo, subset, args['set'], startdepth=startdepth, stopdepth=stopdepth
+)
 @predicate('_firstancestors', safe=True)
 def _firstancestors(repo, subset, x):
 # ``_firstancestors(set)``
 # Like ``ancestors(set)`` but follows only the first parents.
 return _ancestors(repo, subset, x, followfirst=True)
 def _childrenspec(repo, subset, x, n, order):
 """Changesets that are the Nth child of a changeset
 in set.
 """
 c = repo[r].children()
 if len(c) == 0:
 break
 if len(c) > 1:
 raise error.RepoLookupError(
-_("revision in set has more than one child"))
+_("revision in set has more than one child")
+)
 r = c[0].rev()
 else:
 cs.add(r)
 return subset & cs
 def ancestorspec(repo, subset, x, n, order):
 """``set~n``
 Changesets that are the Nth ancestor (first parents only) of a changeset
 in set.
 except error.WdirUnsupported:
 r = repo[r].p1().rev()
 ps.add(r)
 return subset & ps
 @predicate('author(string)', safe=True, weight=10)
 def author(repo, subset, x):
 """Alias for ``user(string)``.
 """
 # i18n: "author" is a keyword
 n = getstring(x, _("author requires a string"))
 kind, pattern, matcher = _substringmatcher(n, casesensitive=False)
-return subset.filter(lambda x: matcher(repo[x].user()),
+return subset.filter(
-condrepr=('<user %r>', n))
+lambda x: matcher(repo[x].user()), condrepr=('<user %r>', n)
+)
 @predicate('bisect(string)', safe=True)
 def bisect(repo, subset, x):
 """Changesets marked in the specified bisect status:
 # i18n: "bisect" is a keyword
 status = getstring(x, _("bisect requires a string")).lower()
 state = set(hbisect.get(repo, status))
 return subset & state
 # Backward-compatibility
 # - no help entry so that we do not advertise it any more
 @predicate('bisected', safe=True)
 def bisected(repo, subset, x):
 return bisect(repo, subset, x)
 @predicate('bookmark([name])', safe=True)
 def bookmark(repo, subset, x):
 """The named bookmark or all bookmarks.
 Pattern matching is supported for `name`. See :hg:`help revisions.patterns`.
 """
 # i18n: "bookmark" is a keyword
 args = getargs(x, 0, 1, _('bookmark takes one or no arguments'))
 if args:
-bm = getstring(args[0],
+bm = getstring(
-# i18n: "bookmark" is a keyword
+args[0],
-_('the argument to bookmark must be a string'))
+# i18n: "bookmark" is a keyword
+_('the argument to bookmark must be a string'),
+)
 kind, pattern, matcher = stringutil.stringmatcher(bm)
 bms = set()
 if kind == 'literal':
 if bm == pattern:
 pattern = repo._bookmarks.expandname(pattern)
 bmrev = repo._bookmarks.get(pattern, None)
 if not bmrev:
-raise error.RepoLookupError(_("bookmark '%s' does not exist")
+raise error.RepoLookupError(
-% pattern)
+_("bookmark '%s' does not exist") % pattern
+)
 bms.add(repo[bmrev].rev())
 else:
 matchrevs = set()
 for name, bmrev in repo._bookmarks.iteritems():
 if matcher(name):
 else:
 bms = {repo[r].rev() for r in repo._bookmarks.values()}
 bms -= {node.nullrev}
 return subset & bms
 @predicate('branch(string or set)', safe=True, weight=10)
 def branch(repo, subset, x):
 """
 All changesets belonging to the given branch or the branches of the given
 changesets.
 Pattern matching is supported for `string`. See
 :hg:`help revisions.patterns`.
 """
 getbi = repo.revbranchcache().branchinfo
 def getbranch(r):
 try:
 return getbi(r)[0]
 except error.WdirUnsupported:
 return repo[r].branch()
 kind, pattern, matcher = stringutil.stringmatcher(b)
 if kind == 'literal':
 # note: falls through to the revspec case if no branch with
 # this name exists and pattern kind is not specified explicitly
 if repo.branchmap().hasbranch(pattern):
-return subset.filter(lambda r: matcher(getbranch(r)),
+return subset.filter(
-condrepr=('<branch %r>', b))
+lambda r: matcher(getbranch(r)), condrepr=('<branch %r>', b)
+)
 if b.startswith('literal:'):
-raise error.RepoLookupError(_("branch '%s' does not exist")
+raise error.RepoLookupError(
-% pattern)
+_("branch '%s' does not exist") % pattern
+)
 else:
-return subset.filter(lambda r: matcher(getbranch(r)),
+return subset.filter(
-condrepr=('<branch %r>', b))
+lambda r: matcher(getbranch(r)), condrepr=('<branch %r>', b)
+)
 s = getset(repo, fullreposet(repo), x)
 b = set()
 for r in s:
 b.add(getbranch(r))
 c = s.__contains__
-return subset.filter(lambda r: c(r) or getbranch(r) in b,
+return subset.filter(
-condrepr=lambda: '<branch %r>' % _sortedb(b))
+lambda r: c(r) or getbranch(r) in b,
+condrepr=lambda: '<branch %r>' % _sortedb(b),
+)
 @predicate('phasedivergent()', safe=True)
 def phasedivergent(repo, subset, x):
 """Mutable changesets marked as successors of public changesets.
 """
 # i18n: "phasedivergent" is a keyword
 getargs(x, 0, 0, _("phasedivergent takes no arguments"))
 phasedivergent = obsmod.getrevs(repo, 'phasedivergent')
 return subset & phasedivergent
 @predicate('bundle()', safe=True)
 def bundle(repo, subset, x):
 """Changesets in the bundle.
 try:
 bundlerevs = repo.changelog.bundlerevs
 except AttributeError:
 raise error.Abort(_("no bundle provided - specify with -R"))
 return subset & bundlerevs
 def checkstatus(repo, subset, pat, field):
 """Helper for status-related revsets (adds, removes, modifies).
 The field parameter says which kind is desired:
 0: modified
 2: removed
 """
 hasset = matchmod.patkind(pat) == 'set'
 mcache = [None]
 def matches(x):
 c = repo[x]
 if not mcache[0] or hasset:
 mcache[0] = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=c)
 m = mcache[0]
 if m(f):
 return True
 return subset.filter(matches, condrepr=('<status[%r] %r>', field, pat))
 def _children(repo, subset, parentset):
 if not parentset:
 return baseset()
 cs = set()
 pr = repo.changelog.parentrevs
 cs.add(r)
 if p2 != nullrev and p2 in parentset:
 cs.add(r)
 return baseset(cs)
 @predicate('children(set)', safe=True)
 def children(repo, subset, x):
 """Child changesets of changesets in set.
 """
 s = getset(repo, fullreposet(repo), x)
 cs = _children(repo, subset, s)
 return subset & cs
 @predicate('closed()', safe=True, weight=10)
 def closed(repo, subset, x):
 """Changeset is closed.
 """
 # i18n: "closed" is a keyword
 getargs(x, 0, 0, _("closed takes no arguments"))
-return subset.filter(lambda r: repo[r].closesbranch(),
+return subset.filter(
-condrepr='<branch closed>')
+lambda r: repo[r].closesbranch(), condrepr='<branch closed>'
+)
 # for internal use
 @predicate('_commonancestorheads(set)', safe=True)
 def _commonancestorheads(repo, subset, x):
 # This is an internal method is for quickly calculating "heads(::x and
 # merge will find.
 startrevs = getset(repo, fullreposet(repo), x, order=anyorder)
 ancs = repo.changelog._commonancestorsheads(*list(startrevs))
 return subset & baseset(ancs)
 @predicate('commonancestors(set)', safe=True)
 def commonancestors(repo, subset, x):
 """Changesets that are ancestors of every changeset in set.
 """
 if not startrevs:
 return baseset()
 for r in startrevs:
 subset &= dagop.revancestors(repo, baseset([r]))
 return subset
 @predicate('contains(pattern)', weight=100)
 def contains(repo, subset, x):
 """The revision's manifest contains a file matching pattern (but might not
 modify it). See :hg:`help patterns` for information about file patterns.
 return True
 return False
 return subset.filter(matches, condrepr=('<contains %r>', pat))
 @predicate('converted([id])', safe=True)
 def converted(repo, subset, x):
 """Changesets converted from the given identifier in the old repository if
 present, or all converted changesets if no identifier is specified.
 """
 def _matchvalue(r):
 source = repo[r].extra().get('convert_revision', None)
 return source is not None and (rev is None or source.startswith(rev))
-return subset.filter(lambda r: _matchvalue(r),
+return subset.filter(
-condrepr=('<converted %r>', rev))
+lambda r: _matchvalue(r), condrepr=('<converted %r>', rev)
+)
 @predicate('date(interval)', safe=True, weight=10)
 def date(repo, subset, x):
 """Changesets within the interval, see :hg:`help dates`.
 """
 # i18n: "date" is a keyword
 ds = getstring(x, _("date requires a string"))
 dm = dateutil.matchdate(ds)
-return subset.filter(lambda x: dm(repo[x].date()[0]),
+return subset.filter(
-condrepr=('<date %r>', ds))
+lambda x: dm(repo[x].date()[0]), condrepr=('<date %r>', ds)
+)
 @predicate('desc(string)', safe=True, weight=10)
 def desc(repo, subset, x):
 """Search commit message for string. The match is case-insensitive.
 # i18n: "desc" is a keyword
 ds = getstring(x, _("desc requires a string"))
 kind, pattern, matcher = _substringmatcher(ds, casesensitive=False)
-return subset.filter(lambda r: matcher(repo[r].description()),
+return subset.filter(
-condrepr=('<desc %r>', ds))
+lambda r: matcher(repo[r].description()), condrepr=('<desc %r>', ds)
+)
-def _descendants(repo, subset, x, followfirst=False, startdepth=None,
-stopdepth=None):
+def _descendants(
+repo, subset, x, followfirst=False, startdepth=None, stopdepth=None
+):
 roots = getset(repo, fullreposet(repo), x)
 if not roots:
 return baseset()
 s = dagop.revdescendants(repo, roots, followfirst, startdepth, stopdepth)
 return subset & s
 @predicate('descendants(set[, depth])', safe=True)
 def descendants(repo, subset, x):
 """Changesets which are descendants of changesets in set, including the
 given changesets themselves.
 if 'set' not in args:
 # i18n: "descendants" is a keyword
 raise error.ParseError(_('descendants takes at least 1 argument'))
 startdepth = stopdepth = None
 if 'startdepth' in args:
-n = getinteger(args['startdepth'],
+n = getinteger(
-"descendants expects an integer startdepth")
+args['startdepth'], "descendants expects an integer startdepth"
+)
 if n < 0:
 raise error.ParseError("negative startdepth")
 startdepth = n
 if 'depth' in args:
 # i18n: "descendants" is a keyword
 n = getinteger(args['depth'], _("descendants expects an integer depth"))
 if n < 0:
 raise error.ParseError(_("negative depth"))
 stopdepth = n + 1
-return _descendants(repo, subset, args['set'],
+return _descendants(
-startdepth=startdepth, stopdepth=stopdepth)
+repo, subset, args['set'], startdepth=startdepth, stopdepth=stopdepth
+)
 @predicate('_firstdescendants', safe=True)
 def _firstdescendants(repo, subset, x):
 # ``_firstdescendants(set)``
 # Like ``descendants(set)`` but follows only the first parents.
 return _descendants(repo, subset, x, followfirst=True)
 @predicate('destination([set])', safe=True, weight=10)
 def destination(repo, subset, x):
 """Changesets that were created by a graft, transplant or rebase operation,
 with the given revisions specified as the source.  Omitting the optional set
 break
 r = src
 src = _getrevsource(repo, r)
-return subset.filter(dests.__contains__,
+return subset.filter(
-condrepr=lambda: '<destination %r>' % _sortedb(dests))
+dests.__contains__,
+condrepr=lambda: '<destination %r>' % _sortedb(dests),
+)
 @predicate('contentdivergent()', safe=True)
 def contentdivergent(repo, subset, x):
 """
 Final successors of changesets with an alternative set of final
 """
 # i18n: "contentdivergent" is a keyword
 getargs(x, 0, 0, _("contentdivergent takes no arguments"))
 contentdivergent = obsmod.getrevs(repo, 'contentdivergent')
 return subset & contentdivergent
 @predicate('expectsize(set[, size])', safe=True, takeorder=True)
 def expectsize(repo, subset, x, order):
 """Return the given revset if size matches the revset size.
 Abort if the revset doesn't expect given size.
 minsize = 0
 maxsize = len(repo) + 1
 err = ''
 if 'size' not in args or 'set' not in args:
 raise error.ParseError(_('invalid set of arguments'))
-minsize, maxsize = getintrange(args['size'],
+minsize, maxsize = getintrange(
-_('expectsize requires a size range'
+args['size'],
-' or a positive integer'),
+_('expectsize requires a size range' ' or a positive integer'),
 _('size range bounds must be integers'),
-minsize, maxsize)
+minsize,
+maxsize,
+)
 if minsize < 0 or maxsize < 0:
 raise error.ParseError(_('negative size'))
 rev = getset(repo, fullreposet(repo), args['set'], order=order)
 if minsize != maxsize and (len(rev) < minsize or len(rev) > maxsize):
-err = _('revset size mismatch.'
+err = _(
-' expected between %d and %d, got %d') % (minsize, maxsize,
+'revset size mismatch.' ' expected between %d and %d, got %d'
-len(rev))
+) % (minsize, maxsize, len(rev))
 elif minsize == maxsize and len(rev) != minsize:
-err = _('revset size mismatch.'
+err = _('revset size mismatch.' ' expected %d, got %d') % (
-' expected %d, got %d') % (minsize, len(rev))
+minsize,
+len(rev),
+)
 if err:
 raise error.RepoLookupError(err)
 if order == followorder:
 return subset & rev
 else:
 return rev & subset
 @predicate('extdata(source)', safe=False, weight=100)
 def extdata(repo, subset, x):
 """Changesets in the specified extdata source. (EXPERIMENTAL)"""
 # i18n: "extdata" is a keyword
 args = getargsdict(x, 'extdata', 'source')
-source = getstring(args.get('source'),
+source = getstring(
-# i18n: "extdata" is a keyword
+args.get('source'),
-_('extdata takes at least 1 string argument'))
+# i18n: "extdata" is a keyword
+_('extdata takes at least 1 string argument'),
+)
 data = scmutil.extdatasource(repo, source)
 return subset & baseset(data)
 @predicate('extinct()', safe=True)
 def extinct(repo, subset, x):
 """Obsolete changesets with obsolete descendants only.
 """
 # i18n: "extinct" is a keyword
 getargs(x, 0, 0, _("extinct takes no arguments"))
 extincts = obsmod.getrevs(repo, 'extinct')
 return subset & extincts
 @predicate('extra(label, [value])', safe=True)
 def extra(repo, subset, x):
 """Changesets with the given label in the extra metadata, with the given
 optional value.
 args = getargsdict(x, 'extra', 'label value')
 if 'label' not in args:
 # i18n: "extra" is a keyword
 raise error.ParseError(_('extra takes at least 1 argument'))
 # i18n: "extra" is a keyword
-label = getstring(args['label'], _('first argument to extra must be '
+label = getstring(
-'a string'))
+args['label'], _('first argument to extra must be ' 'a string')
+)
 value = None
 if 'value' in args:
 # i18n: "extra" is a keyword
-value = getstring(args['value'], _('second argument to extra must be '
+value = getstring(
-'a string'))
+args['value'], _('second argument to extra must be ' 'a string')
+)
 kind, value, matcher = stringutil.stringmatcher(value)
 def _matchvalue(r):
 extra = repo[r].extra()
 return label in extra and (value is None or matcher(extra[label]))
-return subset.filter(lambda r: _matchvalue(r),
+return subset.filter(
-condrepr=('<extra[%r] %r>', label, value))
+lambda r: _matchvalue(r), condrepr=('<extra[%r] %r>', label, value)
+)
 @predicate('filelog(pattern)', safe=True)
 def filelog(repo, subset, x):
 """Changesets connected to the specified filelog.
 # deletion in changelog
 continue
 return subset & s
 @predicate('first(set, [n])', safe=True, takeorder=True, weight=0)
 def first(repo, subset, x, order):
 """An alias for limit().
 """
 return limit(repo, subset, x, order)
 def _follow(repo, subset, x, name, followfirst=False):
 args = getargsdict(x, name, 'file startrev')
 revs = None
 if 'startrev' in args:
 fctxs = []
 for r in revs:
 ctx = mctx = repo[r]
 if r is None:
 ctx = repo['.']
-m = matchmod.match(repo.root, repo.getcwd(), [x],
+m = matchmod.match(
-ctx=mctx, default='path')
+repo.root, repo.getcwd(), [x], ctx=mctx, default='path'
+)
 fctxs.extend(ctx[f].introfilectx() for f in ctx.manifest().walk(m))
 s = dagop.filerevancestors(fctxs, followfirst)
 else:
 if revs is None:
 revs = baseset([repo['.'].rev()])
 s = dagop.revancestors(repo, revs, followfirst)
 return subset & s
 @predicate('follow([file[, startrev]])', safe=True)
 def follow(repo, subset, x):
 """
 An alias for ``::.`` (ancestors of the working directory's first parent).
 If file pattern is specified, the histories of files matching given
 pattern in the revision given by startrev are followed, including copies.
 """
 return _follow(repo, subset, x, 'follow')
 @predicate('_followfirst', safe=True)
 def _followfirst(repo, subset, x):
 # ``followfirst([file[, startrev]])``
 # Like ``follow([file[, startrev]])`` but follows only the first parent
 # of every revisions or files revisions.
 return _follow(repo, subset, x, '_followfirst', followfirst=True)
-@predicate('followlines(file, fromline:toline[, startrev=., descend=False])',
-safe=True)
+@predicate(
+'followlines(file, fromline:toline[, startrev=., descend=False])', safe=True
+)
 def followlines(repo, subset, x):
 """Changesets modifying `file` in line range ('fromline', 'toline').
 Line range corresponds to 'file' content at 'startrev' and should hence be
 consistent with file size. If startrev is not specified, working directory's
 if 'startrev' in args:
 revs = getset(repo, fullreposet(repo), args['startrev'])
 if len(revs) != 1:
 raise error.ParseError(
 # i18n: "followlines" is a keyword
-_("followlines expects exactly one revision"))
+_("followlines expects exactly one revision")
+)
 rev = revs.last()
 pat = getstring(args['file'], _("followlines requires a pattern"))
 # i18n: "followlines" is a keyword
 msg = _("followlines expects exactly one file")
 fname = scmutil.parsefollowlinespattern(repo, rev, pat, msg)
 fromline, toline = util.processlinerange(
-*getintrange(args['lines'][0],
+*getintrange(
-# i18n: "followlines" is a keyword
+args['lines'][0],
-_("followlines expects a line number or a range"),
+# i18n: "followlines" is a keyword
-_("line range bounds must be integers")))
+_("followlines expects a line number or a range"),
+_("line range bounds must be integers"),
+)
+)
 fctx = repo[rev].filectx(fname)
 descend = False
 if 'descend' in args:
-descend = getboolean(args['descend'],
+descend = getboolean(
-# i18n: "descend" is a keyword
+args['descend'],
-_("descend argument must be a boolean"))
+# i18n: "descend" is a keyword
+_("descend argument must be a boolean"),
+)
 if descend:
 rs = generatorset(
-(c.rev() for c, _linerange
+(
-in dagop.blockdescendants(fctx, fromline, toline)),
+c.rev()
-iterasc=True)
+for c, _linerange in dagop.blockdescendants(
+fctx, fromline, toline
+)
+),
+iterasc=True,
+)
 else:
 rs = generatorset(
-(c.rev() for c, _linerange
+(
-in dagop.blockancestors(fctx, fromline, toline)),
+c.rev()
-iterasc=False)
+for c, _linerange in dagop.blockancestors(
+fctx, fromline, toline
+)
+),
+iterasc=False,
+)
 return subset & rs
 @predicate('all()', safe=True)
 def getall(repo, subset, x):
 """All changesets, the same as ``0:tip``.
 """
 # i18n: "all" is a keyword
 getargs(x, 0, 0, _("all takes no arguments"))
 return subset & spanset(repo)  # drop "null" if any
 @predicate('grep(regex)', weight=10)
 def grep(repo, subset, x):
 """Like ``keyword(string)`` but accepts a regex. Use ``grep(r'...')``
 to ensure special escape characters are handled correctly. Unlike
 try:
 # i18n: "grep" is a keyword
 gr = re.compile(getstring(x, _("grep requires a string")))
 except re.error as e:
 raise error.ParseError(
-_('invalid match pattern: %s') % stringutil.forcebytestr(e))
+_('invalid match pattern: %s') % stringutil.forcebytestr(e)
+)
 def matches(x):
 c = repo[x]
 for e in c.files() + [c.user(), c.description()]:
 if gr.search(e):
 return True
 return False
 return subset.filter(matches, condrepr=('<grep %r>', gr.pattern))
 @predicate('_matchfiles', safe=True)
 def _matchfiles(repo, subset, x):
 # _matchfiles takes a revset list of prefixed arguments:
 #
 inc.append(value)
 elif prefix == 'x:':
 exc.append(value)
 elif prefix == 'r:':
 if rev is not None:
-raise error.ParseError('_matchfiles expected at most one '
+raise error.ParseError(
-'revision')
+'_matchfiles expected at most one ' 'revision'
-if value == '': # empty means working directory
+)
+if value == '':  # empty means working directory
 rev = node.wdirrev
 else:
 rev = value
 elif prefix == 'd:':
 if default is not None:
-raise error.ParseError('_matchfiles expected at most one '
+raise error.ParseError(
-'default mode')
+'_matchfiles expected at most one ' 'default mode'
+)
 default = value
 else:
 raise error.ParseError('invalid _matchfiles prefix: %s' % prefix)
 if not default:
 default = 'glob'
 # This directly read the changelog data as creating changectx for all
 # revisions is quite expensive.
 getfiles = repo.changelog.readfiles
 wdirrev = node.wdirrev
 def matches(x):
 if x == wdirrev:
 files = repo[x].files()
 else:
 files = getfiles(x)
 if not mcache[0] or (hasset and rev is None):
 r = x if rev is None else rev
-mcache[0] = matchmod.match(repo.root, repo.getcwd(), pats,
+mcache[0] = matchmod.match(
-include=inc, exclude=exc, ctx=repo[r],
+repo.root,
-default=default)
+repo.getcwd(),
+pats,
+include=inc,
+exclude=exc,
+ctx=repo[r],
+default=default,
+)
 m = mcache[0]
 for f in files:
 if m(f):
 return True
 return False
-return subset.filter(matches,
+return subset.filter(
-condrepr=('<matchfiles patterns=%r, include=%r '
+matches,
-'exclude=%r, default=%r, rev=%r>',
+condrepr=(
-pats, inc, exc, default, rev))
+'<matchfiles patterns=%r, include=%r '
+'exclude=%r, default=%r, rev=%r>',
+pats,
+inc,
+exc,
+default,
+rev,
+),
+)
 @predicate('file(pattern)', safe=True, weight=10)
 def hasfile(repo, subset, x):
 """Changesets affecting files matched by pattern.
 This predicate uses ``glob:`` as the default kind of pattern.
 """
 # i18n: "file" is a keyword
 pat = getstring(x, _("file requires a pattern"))
 return _matchfiles(repo, subset, ('string', 'p:' + pat))
 @predicate('head()', safe=True)
 def head(repo, subset, x):
 """Changeset is a named branch head.
 """
 hs = set()
 cl = repo.changelog
 for ls in repo.branchmap().iterheads():
 hs.update(cl.rev(h) for h in ls)
 return subset & baseset(hs)
 @predicate('heads(set)', safe=True, takeorder=True)
 def heads(repo, subset, x, order):
 """Members of set with no children in set.
 """
 heads.difference_update(wdirparents)
 heads.add(node.wdirrev)
 heads = baseset(heads)
 return subset & heads
 @predicate('hidden()', safe=True)
 def hidden(repo, subset, x):
 """Hidden changesets.
 """
 # i18n: "hidden" is a keyword
 getargs(x, 0, 0, _("hidden takes no arguments"))
 hiddenrevs = repoview.filterrevs(repo, 'visible')
 return subset & hiddenrevs
 @predicate('keyword(string)', safe=True, weight=10)
 def keyword(repo, subset, x):
 """Search commit message, user name, and names of changed files for
 string. The match is case-insensitive.
 # i18n: "keyword" is a keyword
 kw = encoding.lower(getstring(x, _("keyword requires a string")))
 def matches(r):
 c = repo[r]
-return any(kw in encoding.lower(t)
+return any(
-for t in c.files() + [c.user(), c.description()])
+kw in encoding.lower(t)
+for t in c.files() + [c.user(), c.description()]
+)
 return subset.filter(matches, condrepr=('<keyword %r>', kw))
 @predicate('limit(set[, n[, offset]])', safe=True, takeorder=True, weight=0)
 def limit(repo, subset, x, order):
 """First n members of set, defaulting to 1, starting from offset.
 """
 ls = os.slice(ofs, ofs + lim)
 if order == followorder and lim > 1:
 return subset & ls
 return ls & subset
 @predicate('last(set, [n])', safe=True, takeorder=True)
 def last(repo, subset, x, order):
 """Last n members of set, defaulting to 1.
 """
 # i18n: "last" is a keyword
 if order == followorder and lim > 1:
 return subset & ls
 ls.reverse()
 return ls & subset
 @predicate('max(set)', safe=True)
 def maxrev(repo, subset, x):
 """Changeset with highest revision number in set.
 """
 os = getset(repo, fullreposet(repo), x)
 # os.max() throws a ValueError when the collection is empty.
 # Same as python's max().
 pass
 return baseset(datarepr=('<max %r, %r>', subset, os))
 @predicate('merge()', safe=True)
 def merge(repo, subset, x):
 """Changeset is a merge changeset.
 """
 # i18n: "merge" is a keyword
 getargs(x, 0, 0, _("merge takes no arguments"))
 cl = repo.changelog
 nullrev = node.nullrev
 def ismerge(r):
 try:
 return cl.parentrevs(r)[1] != nullrev
 except error.WdirUnsupported:
 return bool(repo[r].p2())
 return subset.filter(ismerge, condrepr='<merge>')
 @predicate('branchpoint()', safe=True)
 def branchpoint(repo, subset, x):
 """Changesets with more than one child.
 """
 if not subset:
 return baseset()
 # XXX this should be 'parentset.min()' assuming 'parentset' is a smartset
 # (and if it is not, it should.)
 baserev = min(subset)
-parentscount = [0]*(len(repo) - baserev)
+parentscount = [0] * (len(repo) - baserev)
 for r in cl.revs(start=baserev + 1):
 for p in cl.parentrevs(r):
 if p >= baserev:
 parentscount[p - baserev] += 1
-return subset.filter(lambda r: parentscount[r - baserev] > 1,
+return subset.filter(
-condrepr='<branchpoint>')
+lambda r: parentscount[r - baserev] > 1, condrepr='<branchpoint>'
+)
 @predicate('min(set)', safe=True)
 def minrev(repo, subset, x):
 """Changeset with lowest revision number in set.
 """
 # os.min() throws a ValueError when the collection is empty.
 # Same as python's min().
 pass
 return baseset(datarepr=('<min %r, %r>', subset, os))
 @predicate('modifies(pattern)', safe=True, weight=30)
 def modifies(repo, subset, x):
 """Changesets modifying files matched by pattern.
 The pattern without explicit kind like ``glob:`` is expected to be
 """
 # i18n: "modifies" is a keyword
 pat = getstring(x, _("modifies requires a pattern"))
 return checkstatus(repo, subset, pat, 0)
 @predicate('named(namespace)')
 def named(repo, subset, x):
 """The changesets in a given namespace.
 Pattern matching is supported for `namespace`. See
 :hg:`help revisions.patterns`.
 """
 # i18n: "named" is a keyword
 args = getargs(x, 1, 1, _('named requires a namespace argument'))
-ns = getstring(args[0],
+ns = getstring(
-# i18n: "named" is a keyword
+args[0],
-_('the argument to named must be a string'))
+# i18n: "named" is a keyword
+_('the argument to named must be a string'),
+)
 kind, pattern, matcher = stringutil.stringmatcher(ns)
 namespaces = set()
 if kind == 'literal':
 if pattern not in repo.names:
-raise error.RepoLookupError(_("namespace '%s' does not exist")
+raise error.RepoLookupError(_("namespace '%s' does not exist") % ns)
-% ns)
 namespaces.add(repo.names[pattern])
 else:
 for name, ns in repo.names.iteritems():
 if matcher(name):
 namespaces.add(ns)
 if name not in ns.deprecated:
 names.update(repo[n].rev() for n in ns.nodes(repo, name))
 names -= {node.nullrev}
 return subset & names
 @predicate('id(string)', safe=True)
 def node_(repo, subset, x):
 """Revision non-ambiguously specified by the given hex string prefix.
 """
 if rn is None:
 return baseset()
 result = baseset([rn])
 return result & subset
 @predicate('none()', safe=True)
 def none(repo, subset, x):
 """No changesets.
 """
 # i18n: "none" is a keyword
 getargs(x, 0, 0, _("none takes no arguments"))
 return baseset()
 @predicate('obsolete()', safe=True)
 def obsolete(repo, subset, x):
 """Mutable changeset with a newer version."""
 # i18n: "obsolete" is a keyword
 getargs(x, 0, 0, _("obsolete takes no arguments"))
 obsoletes = obsmod.getrevs(repo, 'obsolete')
 return subset & obsoletes
 @predicate('only(set, [set])', safe=True)
 def only(repo, subset, x):
 """Changesets that are ancestors of the first set that are not ancestors
 of any other head in the repo. If a second set is specified, the result
 is ancestors of the first set that are not ancestors of the second set
 if len(args) == 1:
 if not include:
 return baseset()
 descendants = set(dagop.revdescendants(repo, include, False))
-exclude = [rev for rev in cl.headrevs()
+exclude = [
-if not rev in descendants and not rev in include]
+rev
+for rev in cl.headrevs()
+if not rev in descendants and not rev in include
+]
 else:
 exclude = getset(repo, fullreposet(repo), args[1])
 results = set(cl.findmissingrevs(common=exclude, heads=include))
 # XXX we should turn this into a baseset instead of a set, smartset may do
 # some optimizations from the fact this is a baseset.
 return subset & results
 @predicate('origin([set])', safe=True)
 def origin(repo, subset, x):
 """
 Changesets that were specified as a source for the grafts, transplants or
 o -= {None}
 # XXX we should turn this into a baseset instead of a set, smartset may do
 # some optimizations from the fact this is a baseset.
 return subset & o
 @predicate('outgoing([path])', safe=False, weight=10)
 def outgoing(repo, subset, x):
 """Changesets not found in the specified destination repository, or the
 default push location.
 """
 # Avoid cycles.
 from . import (
 discovery,
 hg,
 )
 # i18n: "outgoing" is a keyword
 l = getargs(x, 0, 1, _("outgoing takes one or no arguments"))
 # i18n: "outgoing" is a keyword
 dest = l and getstring(l[0], _("outgoing requires a repository path")) or ''
 if not dest:
 # ui.paths.getpath() explicitly tests for None, not just a boolean
 dest = None
 path = repo.ui.paths.getpath(dest, default=('default-push', 'default'))
 if not path:
-raise error.Abort(_('default repository not configured!'),
+raise error.Abort(
-hint=_("see 'hg help config.paths'"))
+_('default repository not configured!'),
+hint=_("see 'hg help config.paths'"),
+)
 dest = path.pushloc or path.loc
 branches = path.branch, []
 revs, checkout = hg.addbranchrevs(repo, repo, branches, [])
 if revs:
 outgoing = discovery.findcommonoutgoing(repo, other, onlyheads=revs)
 repo.ui.popbuffer()
 cl = repo.changelog
 o = {cl.rev(r) for r in outgoing.missing}
 return subset & o
 @predicate('p1([set])', safe=True)
 def p1(repo, subset, x):
 """First parent of changesets in set, or the working directory.
 """
 ps.add(repo[r].p1().rev())
 ps -= {node.nullrev}
 # XXX we should turn this into a baseset instead of a set, smartset may do
 # some optimizations from the fact this is a baseset.
 return subset & ps
 @predicate('p2([set])', safe=True)
 def p2(repo, subset, x):
 """Second parent of changesets in set, or the working directory.
 """
 ps -= {node.nullrev}
 # XXX we should turn this into a baseset instead of a set, smartset may do
 # some optimizations from the fact this is a baseset.
 return subset & ps
 def parentpost(repo, subset, x, order):
 return p1(repo, subset, x)
 @predicate('parents([set])', safe=True)
 def parents(repo, subset, x):
 """
 The set of all parents for all changesets in set, or the working directory.
 except error.WdirUnsupported:
 up(p.rev() for p in repo[r].parents())
 ps -= {node.nullrev}
 return subset & ps
 def _phase(repo, subset, *targets):
 """helper to select all rev in <targets> phases"""
 return repo._phasecache.getrevset(repo, targets, subset)
 @predicate('_phase(idx)', safe=True)
 def phase(repo, subset, x):
-l = getargs(x, 1, 1, ("_phase requires one argument"))
+l = getargs(x, 1, 1, "_phase requires one argument")
-target = getinteger(l[0], ("_phase expects a number"))
+target = getinteger(l[0], "_phase expects a number")
 return _phase(repo, subset, target)
 @predicate('draft()', safe=True)
 def draft(repo, subset, x):
 """Changeset in draft phase."""
 # i18n: "draft" is a keyword
 getargs(x, 0, 0, _("draft takes no arguments"))
 target = phases.draft
 return _phase(repo, subset, target)
 @predicate('secret()', safe=True)
 def secret(repo, subset, x):
 """Changeset in secret phase."""
 # i18n: "secret" is a keyword
 getargs(x, 0, 0, _("secret takes no arguments"))
 target = phases.secret
 return _phase(repo, subset, target)
 @predicate('stack([revs])', safe=True)
 def stack(repo, subset, x):
 """Experimental revset for the stack of changesets or working directory
 parent. (EXPERIMENTAL)
 """
 for revision in getset(repo, fullreposet(repo), x):
 currentstack = stackmod.getstack(repo, revision)
 stacks = stacks + currentstack
 return subset & stacks
 def parentspec(repo, subset, x, n, order):
 """``set^0``
 The set.
 ``set^1`` (or ``set^``), ``set^2``
 parents = repo[r].parents()
 if len(parents) == 2:
 ps.add(parents[1].rev())
 return subset & ps
 @predicate('present(set)', safe=True, takeorder=True)
 def present(repo, subset, x, order):
 """An empty set, if any revision in set isn't found; otherwise,
 all revisions in set.
 """
 try:
 return getset(repo, subset, x, order)
 except error.RepoLookupError:
 return baseset()
 # for internal use
 @predicate('_notpublic', safe=True)
 def _notpublic(repo, subset, x):
 getargs(x, 0, 0, "_notpublic takes no arguments")
 return _phase(repo, subset, phases.draft, phases.secret)
 # for internal use
 @predicate('_phaseandancestors(phasename, set)', safe=True)
 def _phaseandancestors(repo, subset, x):
 # equivalent to (phasename() & ancestors(set)) but more efficient
 draft = phases.draft
 secret = phases.secret
 phasenamemap = {
 '_notpublic': draft,
-'draft': draft, # follow secret's ancestors
+'draft': draft,  # follow secret's ancestors
 'secret': secret,
 }
 if phasename not in phasenamemap:
 raise error.ParseError('%r is not a valid phasename' % phasename)
 def cutfunc(rev):
 return getphase(repo, rev) < minimalphase
 revs = dagop.revancestors(repo, s, cutfunc=cutfunc)
-if phasename == 'draft': # need to remove secret changesets
+if phasename == 'draft':  # need to remove secret changesets
 revs = revs.filter(lambda r: getphase(repo, r) == draft)
 return subset & revs
 @predicate('public()', safe=True)
 def public(repo, subset, x):
 """Changeset in public phase."""
 # i18n: "public" is a keyword
 getargs(x, 0, 0, _("public takes no arguments"))
 return _phase(repo, subset, phases.public)
 @predicate('remote([id [,path]])', safe=False)
 def remote(repo, subset, x):
 """Local revision that corresponds to the given identifier in a
 remote repository, if present. Here, the '.' identifier is a
 synonym for the current local branch.
 """
-from . import hg # avoid start-up nasties
+from . import hg  # avoid start-up nasties
 # i18n: "remote" is a keyword
 l = getargs(x, 0, 2, _("remote takes zero, one, or two arguments"))
 q = '.'
 if len(l) > 0:
 # i18n: "remote" is a keyword
 q = getstring(l[0], _("remote requires a string id"))
 if q == '.':
 q = repo['.'].branch()
 dest = ''
 r = repo[n].rev()
 if r in subset:
 return baseset([r])
 return baseset()
 @predicate('removes(pattern)', safe=True, weight=30)
 def removes(repo, subset, x):
 """Changesets which remove files matching pattern.
 The pattern without explicit kind like ``glob:`` is expected to be
 directory.
 """
 # i18n: "removes" is a keyword
 pat = getstring(x, _("removes requires a pattern"))
 return checkstatus(repo, subset, pat, 2)
 @predicate('rev(number)', safe=True)
 def rev(repo, subset, x):
 """Revision with the given numeric identifier.
 """
 raise error.ParseError(_("rev expects a number"))
 if l not in repo.changelog and l not in _virtualrevs:
 return baseset()
 return subset & baseset([l])
 @predicate('_rev(number)', safe=True)
 def _rev(repo, subset, x):
 # internal version of "rev(x)" that raise error if "x" is invalid
 # i18n: "rev" is a keyword
 l = getargs(x, 1, 1, _("rev requires one argument"))
 # i18n: "rev" is a keyword
 l = int(getstring(l[0], _("rev requires a number")))
 except (TypeError, ValueError):
 # i18n: "rev" is a keyword
 raise error.ParseError(_("rev expects a number"))
-repo.changelog.node(l) # check that the rev exists
+repo.changelog.node(l)  # check that the rev exists
 return subset & baseset([l])
 @predicate('revset(set)', safe=True, takeorder=True)
 def revsetpredicate(repo, subset, x, order):
 """Strictly interpret the content as a revset.
 The content of this special predicate will be strictly interpreted as a
 revset. For example, ``revset(id(0))`` will be interpreted as "id(0)"
 without possible ambiguity with a "id(0)" bookmark or tag.
 """
 return getset(repo, subset, x, order)
 @predicate('matching(revision [, field])', safe=True)
 def matching(repo, subset, x):
 """Changesets in which a given set of fields match the set of fields in the
 selected revision or set.
 revs = getset(repo, fullreposet(repo), l[0])
 fieldlist = ['metadata']
 if len(l) > 1:
-fieldlist = getstring(l[1],
+fieldlist = getstring(
-# i18n: "matching" is a keyword
+l[1],
-_("matching requires a string "
+# i18n: "matching" is a keyword
-"as its second argument")).split()
+_("matching requires a string " "as its second argument"),
+).split()
 # Make sure that there are no repeated fields,
 # expand the 'special' 'metadata' field type
 # and check the 'files' whenever we check the 'diff'
 fields = []
 fields.discard('summary')
 # We may want to match more than one field
 # Not all fields take the same amount of time to be matched
 # Sort the selected fields in order of increasing matching cost
-fieldorder = ['phase', 'parents', 'user', 'date', 'branch', 'summary',
+fieldorder = [
-'files', 'description', 'substate', 'diff']
+'phase',
+'parents',
+'user',
+'date',
+'branch',
+'summary',
+'files',
+'description',
+'substate',
+'diff',
+]
 def fieldkeyfunc(f):
 try:
 return fieldorder.index(f)
 except ValueError:
 # assume an unknown field is very costly
 return len(fieldorder)
 fields = list(fields)
 fields.sort(key=fieldkeyfunc)
 # Each field will be matched with its own "getfield" function
 # which will be added to the getfieldfuncs array of functions
 'files': lambda r: repo[r].files(),
 'parents': lambda r: repo[r].parents(),
 'phase': lambda r: repo[r].phase(),
 'substate': lambda r: repo[r].substate,
 'summary': lambda r: repo[r].description().splitlines()[0],
-'diff': lambda r: list(repo[r].diff(
+'diff': lambda r: list(
-opts=diffutil.diffallopts(repo.ui, {'git': True}))),
+repo[r].diff(opts=diffutil.diffallopts(repo.ui, {'git': True}))
+),
 }
 for info in fields:
 getfield = _funcs.get(info, None)
 if getfield is None:
 raise error.ParseError(
 # i18n: "matching" is a keyword
-_("unexpected field name passed to matching: %s") % info)
+_("unexpected field name passed to matching: %s")
+% info
+)
 getfieldfuncs.append(getfield)
 # convert the getfield array of functions into a "getinfo" function
 # which returns an array of field values (or a single value if there
 # is only one field to match)
 getinfo = lambda r: [f(r) for f in getfieldfuncs]
 return True
 return False
 return subset.filter(matches, condrepr=('<matching%r %r>', fields, revs))
 @predicate('reverse(set)', safe=True, takeorder=True, weight=0)
 def reverse(repo, subset, x, order):
 """Reverse order of set.
 """
 l = getset(repo, subset, x, order)
 if order == defineorder:
 l.reverse()
 return l
 @predicate('roots(set)', safe=True)
 def roots(repo, subset, x):
 """Changesets in set with no parent changeset in set.
 """
 s = getset(repo, fullreposet(repo), x)
 parents = repo.changelog.parentrevs
 def filter(r):
 for p in parents(r):
 if 0 <= p and p in s:
 return False
 return True
 return subset & s.filter(filter, condrepr='<roots>')
 _sortkeyfuncs = {
 'rev': lambda c: c.rev(),
 'branch': lambda c: c.branch(),
 'desc': lambda c: c.description(),
 'user': lambda c: c.user(),
 'author': lambda c: c.user(),
 'date': lambda c: c.date()[0],
 }
 def _getsortargs(x):
 """Parse sort options into (set, [(key, reverse)], opts)"""
 args = getargsdict(x, 'sort', 'set keys topo.firstbranch')
 if 'set' not in args:
 keys = getstring(args['keys'], _("sort spec must be a string"))
 keyflags = []
 for k in keys.split():
 fk = k
-reverse = (k.startswith('-'))
+reverse = k.startswith('-')
 if reverse:
 k = k[1:]
 if k not in _sortkeyfuncs and k != 'topo':
 raise error.ParseError(
-_("unknown sort key %r") % pycompat.bytestr(fk))
+_("unknown sort key %r") % pycompat.bytestr(fk)
+)
 keyflags.append((k, reverse))
 if len(keyflags) > 1 and any(k == 'topo' for k, reverse in keyflags):
 # i18n: "topo" is a keyword
-raise error.ParseError(_('topo sort order cannot be combined '
+raise error.ParseError(
-'with other sort keys'))
+_('topo sort order cannot be combined ' 'with other sort keys')
+)
 opts = {}
 if 'topo.firstbranch' in args:
 if any(k == 'topo' for k, reverse in keyflags):
 opts['topo.firstbranch'] = args['topo.firstbranch']
 else:
 # i18n: "topo" and "topo.firstbranch" are keywords
-raise error.ParseError(_('topo.firstbranch can only be used '
+raise error.ParseError(
-'when using the topo sort key'))
+_(
+'topo.firstbranch can only be used '
+'when using the topo sort key'
+)
+)
 return args['set'], keyflags, opts
-@predicate('sort(set[, [-]key... [, ...]])', safe=True, takeorder=True,
-weight=10)
+@predicate(
+'sort(set[, [-]key... [, ...]])', safe=True, takeorder=True, weight=10
+)
 def sort(repo, subset, x, order):
 """Sort set by keys. The default sort order is ascending, specify a key
 as ``-key`` to sort in descending order.
 The keys can be:
 return revs
 elif keyflags[0][0] == "topo":
 firstbranch = ()
 if 'topo.firstbranch' in opts:
 firstbranch = getset(repo, subset, opts['topo.firstbranch'])
-revs = baseset(dagop.toposort(revs, repo.changelog.parentrevs,
+revs = baseset(
-firstbranch),
+dagop.toposort(revs, repo.changelog.parentrevs, firstbranch),
-istopo=True)
+istopo=True,
+)
 if keyflags[0][1]:
 revs.reverse()
 return revs
 # sort() is guaranteed to be stable
 ctxs = [repo[r] for r in revs]
 for k, reverse in reversed(keyflags):
 ctxs.sort(key=_sortkeyfuncs[k], reverse=reverse)
 return baseset([c.rev() for c in ctxs])
 @predicate('subrepo([pattern])')
 def subrepo(repo, subset, x):
 """Changesets that add, modify or remove the given subrepo.  If no subrepo
 pattern is named, any subrepo changes are returned.
 """
 return any(submatches(c.p1().substate.keys()))
 return False
 return subset.filter(matches, condrepr=('<subrepo %r>', pat))
 def _mapbynodefunc(repo, s, f):
 """(repo, smartset, [node] -> [node]) -> smartset
 Helper method to map a smartset to another smartset given a function only
 torev = cl.rev
 tonode = cl.node
 nodemap = cl.nodemap
 result = set(torev(n) for n in f(tonode(r) for r in s) if n in nodemap)
 return smartset.baseset(result - repo.changelog.filteredrevs)
 @predicate('successors(set)', safe=True)
 def successors(repo, subset, x):
 """All successors for set, including the given set themselves"""
 s = getset(repo, fullreposet(repo), x)
 f = lambda nodes: obsutil.allsuccessors(repo.obsstore, nodes)
 d = _mapbynodefunc(repo, s, f)
 return subset & d
 def _substringmatcher(pattern, casesensitive=True):
 kind, pattern, matcher = stringutil.stringmatcher(
-pattern, casesensitive=casesensitive)
+pattern, casesensitive=casesensitive
+)
 if kind == 'literal':
 if not casesensitive:
 pattern = encoding.lower(pattern)
 matcher = lambda s: pattern in encoding.lower(s)
 else:
 matcher = lambda s: pattern in s
 return kind, pattern, matcher
 @predicate('tag([name])', safe=True)
 def tag(repo, subset, x):
 """The specified tag by name, or all tagged revisions if no name is given.
 Pattern matching is supported for `name`. See
 """
 # i18n: "tag" is a keyword
 args = getargs(x, 0, 1, _("tag takes one or no arguments"))
 cl = repo.changelog
 if args:
-pattern = getstring(args[0],
+pattern = getstring(
-# i18n: "tag" is a keyword
+args[0],
-_('the argument to tag must be a string'))
+# i18n: "tag" is a keyword
+_('the argument to tag must be a string'),
+)
 kind, pattern, matcher = stringutil.stringmatcher(pattern)
 if kind == 'literal':
 # avoid resolving all tags
 tn = repo._tagscache.tags.get(pattern, None)
 if tn is None:
-raise error.RepoLookupError(_("tag '%s' does not exist")
+raise error.RepoLookupError(
-% pattern)
+_("tag '%s' does not exist") % pattern
+)
 s = {repo[tn].rev()}
 else:
 s = {cl.rev(n) for t, n in repo.tagslist() if matcher(t)}
 else:
 s = {cl.rev(n) for t, n in repo.tagslist() if t != 'tip'}
 return subset & s
 @predicate('tagged', safe=True)
 def tagged(repo, subset, x):
 return tag(repo, subset, x)
 @predicate('orphan()', safe=True)
 def orphan(repo, subset, x):
 """Non-obsolete changesets with obsolete ancestors. (EXPERIMENTAL)
 """
 Pattern matching is supported for `string`. See
 :hg:`help revisions.patterns`.
 """
 return author(repo, subset, x)
 @predicate('wdir()', safe=True, weight=0)
 def wdir(repo, subset, x):
 """Working directory. (EXPERIMENTAL)"""
 # i18n: "wdir" is a keyword
 getargs(x, 0, 0, _("wdir takes no arguments"))
 if node.wdirrev in subset or isinstance(subset, fullreposet):
 return baseset([node.wdirrev])
 return baseset()
 def _orderedlist(repo, subset, x):
 s = getstring(x, "internal error")
 if not s:
 return baseset()
 revs = stringset(repo, subset, t, defineorder)
 for r in revs:
 if r in seen:
 continue
-if (r in subset
+if (
-or r in _virtualrevs and isinstance(subset, fullreposet)):
+r in subset
+or r in _virtualrevs
+and isinstance(subset, fullreposet)
+):
 ls.append(r)
 seen.add(r)
 return baseset(ls)
 # for internal use
 @predicate('_list', safe=True, takeorder=True)
 def _list(repo, subset, x, order):
 if order == followorder:
 # slow path to take the subset order
 return subset & _orderedlist(repo, fullreposet(repo), x)
 else:
 return _orderedlist(repo, subset, x)
 def _orderedintlist(repo, subset, x):
 s = getstring(x, "internal error")
 if not s:
 return baseset()
 ls = [int(r) for r in s.split('\0')]
 s = subset
 return baseset([r for r in ls if r in s])
 # for internal use
 @predicate('_intlist', safe=True, takeorder=True, weight=0)
 def _intlist(repo, subset, x, order):
 if order == followorder:
 # slow path to take the subset order
 return subset & _orderedintlist(repo, fullreposet(repo), x)
 else:
 return _orderedintlist(repo, subset, x)
 def _orderedhexlist(repo, subset, x):
 s = getstring(x, "internal error")
 if not s:
 return baseset()
 cl = repo.changelog
 ls = [cl.rev(node.bin(r)) for r in s.split('\0')]
 s = subset
 return baseset([r for r in ls if r in s])
 # for internal use
 @predicate('_hexlist', safe=True, takeorder=True)
 def _hexlist(repo, subset, x, order):
 if order == followorder:
 # slow path to take the subset order
 return subset & _orderedhexlist(repo, fullreposet(repo), x)
 else:
 return _orderedhexlist(repo, subset, x)
 methods = {
 "range": rangeset,
 "rangeall": rangeall,
 "rangepre": rangepre,
 subscriptrelations = {
 "g": generationsrel,
 "generations": generationsrel,
 }
 def lookupfn(repo):
 return lambda symbol: scmutil.isrevsymbol(repo, symbol)
 def match(ui, spec, lookup=None):
 """Create a matcher for a single revision spec"""
 return matchany(ui, [spec], lookup=lookup)
 def matchany(ui, specs, lookup=None, localalias=None):
 """Create a matcher that will include any revisions matching one of the
 given specs
 If lookup function is not None, the parser will first attempt to handle
 If localalias is not None, it is a dict {name: definitionstring}. It takes
 precedence over [revsetalias] config section.
 """
 if not specs:
 def mfunc(repo, subset=None):
 return baseset()
 return mfunc
 if not all(specs):
 raise error.ParseError(_("empty query"))
 if len(specs) == 1:
 tree = revsetlang.parse(specs[0], lookup)
 else:
-tree = ('or',
+tree = (
-('list',) + tuple(revsetlang.parse(s, lookup) for s in specs))
+'or',
+('list',) + tuple(revsetlang.parse(s, lookup) for s in specs),
+)
 aliases = []
 warn = None
 if ui:
 aliases.extend(ui.configitems('revsetalias'))
 tree = revsetlang.foldconcat(tree)
 tree = revsetlang.analyze(tree)
 tree = revsetlang.optimize(tree)
 return makematcher(tree)
 def makematcher(tree):
 """Create a matcher from an evaluatable tree"""
 def mfunc(repo, subset=None, order=None):
 if order is None:
 if subset is None:
 order = defineorder  # 'x'
 else:
 order = followorder  # 'subset & x'
 if subset is None:
 subset = fullreposet(repo)
 return getset(repo, subset, tree, order)
 return mfunc
 def loadpredicate(ui, extname, registrarobj):
 """Load revset predicates from specified registrarobj
 """
 for name, func in registrarobj._table.iteritems():
 symbols[name] = func
 if func._safe:
 safesymbols.add(name)
 # load built-in predicates explicitly to setup safesymbols
 loadpredicate(None, None, predicate)
 # tell hggettext to extract docstrings from these functions:
 i18nfunctions = symbols.values()

Mercurial > public > mercurial-scm > hg-stable

comparison mercurial/revset.py @ 43076:2372284d9457