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

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 encoding,
 error,
 pycompat,
 util,
 )
-from .utils import (
+from .utils import stringutil
-stringutil,
-)
 def _typename(o):
 return pycompat.sysbytes(type(o).__name__).lstrip('_')
 class abstractsmartset(object):
 def __nonzero__(self):
 """True if the smartset is not empty"""
 raise NotImplementedError()
 __bool__ = __nonzero__
 def __sub__(self, other):
 """Returns a new object with the substraction of the two collections.
 This is part of the mandatory API for smartset."""
 c = other.__contains__
-return self.filter(lambda r: not c(r), condrepr=('<not %r>', other),
+return self.filter(
-cache=False)
+lambda r: not c(r), condrepr=('<not %r>', other), cache=False
+)
 def filter(self, condition, condrepr=None, cache=True):
 """Returns this smartset filtered by condition as a new smartset.
 `condition` is a callable which takes a revision number and returns a
 if y is None:
 break
 ys.append(y)
 return baseset(ys, datarepr=('slice=%d:%d %r', start, stop, self))
 class baseset(abstractsmartset):
 """Basic data structure that represents a revset and contains the basic
 operation that it should be able to perform.
 Every method in this class should be implemented by any smartset class.
 >>> type(rs).__name__
 'baseset'
 >>> rs._istopo
 True
 """
 def __init__(self, data=(), datarepr=None, istopo=False):
 """
 datarepr: a tuple of (format, obj, ...), a function or an object that
 provides a printable representation of the given data.
 """
 return self._asclist[0]
 return None
 def _fastsetop(self, other, op):
 # try to use native set operations as fast paths
-if (type(other) is baseset and r'_set' in other.__dict__ and r'_set' in
+if (
-self.__dict__ and self._ascending is not None):
+type(other) is baseset
-s = baseset(data=getattr(self._set, op)(other._set),
+and r'_set' in other.__dict__
-istopo=self._istopo)
+and r'_set' in self.__dict__
+and self._ascending is not None
+):
+s = baseset(
+data=getattr(self._set, op)(other._set), istopo=self._istopo
+)
 s._ascending = self._ascending
 else:
 s = getattr(super(baseset, self), op)(other)
 return s
 if self._ascending is not None:
 l = self._asclist
 s = pycompat.byterepr(l)
 return '<%s%s %s>' % (_typename(self), d, s)
 class filteredset(abstractsmartset):
 """Duck type for baseset class which iterates lazily over the revisions in
 the subset and contains a function which tests for membership in the
 revset
 """
 def __init__(self, subset, condition=lambda x: True, condrepr=None):
 """
 condition: a function that decide whether a revision in the subset
 belongs to the revset or not.
 condrepr: a tuple of (format, obj, ...), a function or an object that
 return None
 return lambda: self._iterfilter(it())
 def __nonzero__(self):
 fast = None
-candidates = [self.fastasc if self.isascending() else None,
+candidates = [
-self.fastdesc if self.isdescending() else None,
+self.fastasc if self.isascending() else None,
-self.fastasc,
+self.fastdesc if self.isdescending() else None,
-self.fastdesc]
+self.fastasc,
+self.fastdesc,
+]
 for candidate in candidates:
 if candidate is not None:
 fast = candidate
 break
 elif self.isdescending():
 it = self.fastasc
 if it is not None:
 for x in it():
 return x
-return None #empty case
+return None  # empty case
 else:
 x = None
 for x in self:
 pass
 return x
 xs = [pycompat.byterepr(self._subset)]
 s = stringutil.buildrepr(self._condrepr)
 if s:
 xs.append(s)
 return '<%s %s>' % (_typename(self), ', '.join(xs))
 def _iterordered(ascending, iter1, iter2):
 """produce an ordered iteration from two iterators with the same order
 The ascending is used to indicated the iteration direction.
 # might have been equality and both are empty
 yield val2
 for val in it:
 yield val
 class addset(abstractsmartset):
 """Represent the addition of two sets
 Wrapper structure for lazily adding two structures without losing much
 performance on the __contains__ method
 >>> rs = addset(generatorset(xs), ys, ascending=False)
 >>> assert rs.fastdesc is None
 >>> [x for x in rs]
 [5, 4, 3, 2, 0]
 """
 def __init__(self, revs1, revs2, ascending=None):
 self._r1 = revs1
 self._r2 = revs2
 self._iter = None
 self._ascending = ascending
 same time, yielding only one value at a time in the given order.
 """
 if self._ascending is None:
 if self._genlist:
 return iter(self._genlist)
 def arbitraryordergen():
 for r in self._r1:
 yield r
 inr1 = self._r1.__contains__
 for r in self._r2:
 if not inr1(r):
 yield r
 return arbitraryordergen()
 # try to use our own fast iterator if it exists
 self._trysetasclist()
 if self._ascending:
 attr = 'fastasc'
 @encoding.strmethod
 def __repr__(self):
 d = {None: '', False: '-', True: '+'}[self._ascending]
 return '<%s%s %r, %r>' % (_typename(self), d, self._r1, self._r2)
 class generatorset(abstractsmartset):
 """Wrap a generator for lazy iteration
 Wrapper structure for generators that provides lazy membership and can
 be iterated more than once.
 >>> xs = generatorset([0, 1, 4], iterasc=True)
 >>> assert xs.last() == xs.last()
 >>> xs.last()  # cached
 4
 """
 def __new__(cls, gen, iterasc=None):
 if iterasc is None:
 typ = cls
 elif iterasc:
 typ = _generatorsetasc
 #
 # Getting rid of it would provide an about 15% speed up on this
 # iteration.
 genlist = self._genlist
 nextgen = self._consumegen()
-_len, _next = len, next # cache global lookup
+_len, _next = len, next  # cache global lookup
 def gen():
 i = 0
 while True:
 if i < _len(genlist):
 yield genlist[i]
 try:
 yield _next(nextgen)
 except StopIteration:
 return
 i += 1
 return gen()
 def _consumegen(self):
 cache = self._cache
 genlist = self._genlist.append
 @encoding.strmethod
 def __repr__(self):
 d = {False: '-', True: '+'}[self._ascending]
 return '<%s%s>' % (_typename(self), d)
 class _generatorsetasc(generatorset):
 """Special case of generatorset optimized for ascending generators."""
 fastasc = generatorset._iterator
 break
 self._cache[x] = False
 return False
 class _generatorsetdesc(generatorset):
 """Special case of generatorset optimized for descending generators."""
 fastdesc = generatorset._iterator
 if l < x:
 break
 self._cache[x] = False
 return False
 def spanset(repo, start=0, end=None):
 """Create a spanset that represents a range of repository revisions
 start: first revision included the set (default to 0)
 ascending = start <= end
 if not ascending:
 start, end = end + 1, start + 1
 return _spanset(start, end, ascending, repo.changelog.filteredrevs)
 class _spanset(abstractsmartset):
 """Duck type for baseset class which represents a range of revisions and
 can work lazily and without having all the range in memory
 Note that spanset(x, y) behave almost like xrange(x, y) except for two
 notable points:
 - when x < y it will be automatically descending,
 - revision filtered with this repoview will be skipped.
 """
 def __init__(self, start, end, ascending, hiddenrevs):
 self._start = start
 self._end = end
 self._ascending = ascending
 self._hiddenrevs = hiddenrevs
 return self._iterfilter(iterrange)
 return iter(iterrange)
 def __contains__(self, rev):
 hidden = self._hiddenrevs
-return ((self._start <= rev < self._end)
+return (self._start <= rev < self._end) and not (
-and not (hidden and rev in hidden))
+hidden and rev in hidden
+)
 def __nonzero__(self):
 for r in self:
 return True
 return False
 @encoding.strmethod
 def __repr__(self):
 d = {False: '-', True: '+'}[self._ascending]
 return '<%s%s %d:%d>' % (_typename(self), d, self._start, self._end)
 class fullreposet(_spanset):
 """a set containing all revisions in the repo
 This class exists to host special optimization and magic to handle virtual
 revisions such as "null".
 """
 def __init__(self, repo):
-super(fullreposet, self).__init__(0, len(repo), True,
+super(fullreposet, self).__init__(
-repo.changelog.filteredrevs)
+0, len(repo), True, repo.changelog.filteredrevs
+)
 def __and__(self, other):
 """As self contains the whole repo, all of the other set should also be
 in self. Therefore `self & other = other`.

changeset 43076	2372284d9457
parent 40233	6309128ff61f
child 43077	687b865b95ad