mercurial-scm/hg: mercurial/revlogutils/deltas.py comparison

comparison mercurial/revlogutils/deltas.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	dff95420480f
children	687b865b95ad

comparison

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 import collections
 import struct
 # import stuff from node for others to import from revlog
-from ..node import (
+from ..node import nullrev
-nullrev,
-)
 from ..i18n import _
 from .constants import (
 REVIDX_ISCENSORED,
 REVIDX_RAWTEXT_CHANGING_FLAGS,
 )
-from ..thirdparty import (
+from ..thirdparty import attr
-attr,
-)
 from .. import (
 error,
 mdiff,
 util,
 )
-from . import (
+from . import flagutil
-flagutil,
-)
 # maximum <delta-chain-data>/<revision-text-length> ratio
 LIMIT_DELTA2TEXT = 2
 class _testrevlog(object):
 """minimalist fake revlog to use in doctests"""
 def __init__(self, data, density=0.5, mingap=0, snapshot=()):
 def issnapshot(self, rev):
 if rev == nullrev:
 return True
 return rev in self._snapshot
 def slicechunk(revlog, revs, targetsize=None):
 """slice revs to reduce the amount of unrelated data to be read from disk.
 ``revs`` is sliced into groups that should be read in one time.
 # targetsize should not be specified when evaluating delta candidates:
 # * targetsize is used to ensure we stay within specification when reading,
 densityslicing = getattr(revlog.index, 'slicechunktodensity', None)
 if densityslicing is None:
 densityslicing = lambda x, y, z: _slicechunktodensity(revlog, x, y, z)
-for chunk in densityslicing(revs,
+for chunk in densityslicing(
-revlog._srdensitythreshold,
+revs, revlog._srdensitythreshold, revlog._srmingapsize
-revlog._srmingapsize):
+):
 for subchunk in _slicechunktosize(revlog, chunk, targetsize):
 yield subchunk
 def _slicechunktosize(revlog, revs, targetsize=None):
 """slice revs to match the target size
 This is intended to be used on chunk that density slicing selected by that
 return
 startrevidx = 0
 endrevidx = 1
 iterrevs = enumerate(revs)
-next(iterrevs) # skip first rev.
+next(iterrevs)  # skip first rev.
 # first step: get snapshots out of the way
 for idx, r in iterrevs:
 span = revlog.end(r) - startdata
 snapshot = revlog.issnapshot(r)
 if span <= targetsize and snapshot:
 # focuses on quickly converging toward valid chunks.
 nbitem = len(revs)
 while (enddata - startdata) > targetsize:
 endrevidx = nbitem
 if nbitem - startrevidx <= 1:
-break # protect against individual chunk larger than limit
+break  # protect against individual chunk larger than limit
 localenddata = revlog.end(revs[endrevidx - 1])
 span = localenddata - startdata
 while span > targetsize:
 if endrevidx - startrevidx <= 1:
-break # protect against individual chunk larger than limit
+break  # protect against individual chunk larger than limit
 endrevidx -= (endrevidx - startrevidx) // 2
 localenddata = revlog.end(revs[endrevidx - 1])
 span = localenddata - startdata
 chunk = _trimchunk(revlog, revs, startrevidx, endrevidx)
 if chunk:
 chunk = _trimchunk(revlog, revs, startrevidx)
 if chunk:
 yield chunk
-def _slicechunktodensity(revlog, revs, targetdensity=0.5,
-mingapsize=0):
+def _slicechunktodensity(revlog, revs, targetdensity=0.5, mingapsize=0):
 """slice revs to reduce the amount of unrelated data to be read from disk.
 ``revs`` is sliced into groups that should be read in one time.
 Assume that revs are sorted.
 chunk = _trimchunk(revlog, revs, previdx)
 if chunk:
 yield chunk
 def _trimchunk(revlog, revs, startidx, endidx=None):
 """returns revs[startidx:endidx] without empty trailing revs
 Doctest Setup
 >>> revlog = _testrevlog([
 endidx = len(revs)
 # If we have a non-emtpy delta candidate, there are nothing to trim
 if revs[endidx - 1] < len(revlog):
 # Trim empty revs at the end, except the very first revision of a chain
-while (endidx > 1
+while (
-and endidx > startidx
+endidx > 1 and endidx > startidx and length(revs[endidx - 1]) == 0
-and length(revs[endidx - 1]) == 0):
+):
 endidx -= 1
 return revs[startidx:endidx]
 def segmentspan(revlog, revs):
 """Get the byte span of a segment of revisions
 revs is a sorted array of revision numbers
 if not revs:
 return 0
 end = revlog.end(revs[-1])
 return end - revlog.start(revs[0])
 def _textfromdelta(fh, revlog, baserev, delta, p1, p2, flags, expectednode):
 """build full text from a (base, delta) pair and other metadata"""
 # special case deltas which replace entire base; no need to decode
 # base revision. this neatly avoids censored bases, which throw when
 # they're decoded.
 hlen = struct.calcsize(">lll")
-if delta[:hlen] == mdiff.replacediffheader(revlog.rawsize(baserev),
+if delta[:hlen] == mdiff.replacediffheader(
-len(delta) - hlen):
+revlog.rawsize(baserev), len(delta) - hlen
+):
 fulltext = delta[hlen:]
 else:
 # deltabase is rawtext before changed by flag processors, which is
 # equivalent to non-raw text
 basetext = revlog.revision(baserev, _df=fh, raw=False)
 try:
 validatehash = flagutil.processflagsraw(revlog, fulltext, flags)
 if validatehash:
 revlog.checkhash(fulltext, expectednode, p1=p1, p2=p2)
 if flags & REVIDX_ISCENSORED:
-raise error.StorageError(_('node %s is not censored') %
+raise error.StorageError(
-expectednode)
+_('node %s is not censored') % expectednode
+)
 except error.CensoredNodeError:
 # must pass the censored index flag to add censored revisions
 if not flags & REVIDX_ISCENSORED:
 raise
 return fulltext
 @attr.s(slots=True, frozen=True)
 class _deltainfo(object):
 distance = attr.ib()
 deltalen = attr.ib()
 chainbase = attr.ib()
 chainlen = attr.ib()
 compresseddeltalen = attr.ib()
 snapshotdepth = attr.ib()
 def isgooddeltainfo(revlog, deltainfo, revinfo):
 """Returns True if the given delta is good. Good means that it is within
 the disk span, disk size, and chain length bounds that we know to be
 performant."""
 if deltainfo is None:
 textlen = revinfo.textlen
 defaultmax = textlen * 4
 maxdist = revlog._maxdeltachainspan
 if not maxdist:
-maxdist = deltainfo.distance # ensure the conditional pass
+maxdist = deltainfo.distance  # ensure the conditional pass
 maxdist = max(maxdist, defaultmax)
 # Bad delta from read span:
 #
 #   If the span of data read is larger than the maximum allowed.
 return False
 # Bad delta from chain length:
 #
 #   If the number of delta in the chain gets too high.
-if (revlog._maxchainlen
+if revlog._maxchainlen and revlog._maxchainlen < deltainfo.chainlen:
-and revlog._maxchainlen < deltainfo.chainlen):
 return False
 # bad delta from intermediate snapshot size limit
 #
 #   If an intermediate snapshot size is higher than the limit.  The
 #   limit exist to prevent endless chain of intermediate delta to be
 #   created.
-if (deltainfo.snapshotdepth is not None and
+if (
-(textlen >> deltainfo.snapshotdepth) < deltainfo.deltalen):
+deltainfo.snapshotdepth is not None
+and (textlen >> deltainfo.snapshotdepth) < deltainfo.deltalen
+):
 return False
 # bad delta if new intermediate snapshot is larger than the previous
 # snapshot
-if (deltainfo.snapshotdepth
+if (
-and revlog.length(deltainfo.base) < deltainfo.deltalen):
+deltainfo.snapshotdepth
+and revlog.length(deltainfo.base) < deltainfo.deltalen
+):
 return False
 return True
 # If a revision's full text is that much bigger than a base candidate full
 # text's, it is very unlikely that it will produce a valid delta. We no longer
 # consider these candidates.
 LIMIT_BASE2TEXT = 500
 def _candidategroups(revlog, textlen, p1, p2, cachedelta):
 """Provides group of revision to be tested as delta base
 This top level function focus on emitting groups with unique and worthwhile
 if temptative is None:
 break
 group = []
 for rev in temptative:
 # skip over empty delta (no need to include them in a chain)
-while (revlog._generaldelta
+while revlog._generaldelta and not (
-and not (rev == nullrev
+rev == nullrev or rev in tested or deltalength(rev)
-or rev in tested
+):
-or deltalength(rev))):
 tested.add(rev)
 rev = deltaparent(rev)
 # no need to try a delta against nullrev, this will be done as a
 # last resort.
 if rev == nullrev:
 #      impacting performances. Some bounding or slicing mecanism
 #      would help to reduce this impact.
 good = yield tuple(group)
 yield None
 def _findsnapshots(revlog, cache, start_rev):
 """find snapshot from start_rev to tip"""
 if util.safehasattr(revlog.index, 'findsnapshots'):
 revlog.index.findsnapshots(cache, start_rev)
 else:
 deltaparent = revlog.deltaparent
 issnapshot = revlog.issnapshot
 for rev in revlog.revs(start_rev):
 if issnapshot(rev):
 cache[deltaparent(rev)].append(rev)
 def _refinedgroups(revlog, p1, p2, cachedelta):
 good = None
 # First we try to reuse a the delta contained in the bundle.
 # (or from the source revlog)
 children = tuple(sorted(c for c in snapshots[good]))
 good = yield children
 # we have found nothing
 yield None
 def _rawgroups(revlog, p1, p2, cachedelta, snapshots=None):
 """Provides group of revision to be tested as delta base
 This lower level function focus on emitting delta theorically interresting
 if not sparse:
 # other approach failed try against prev to hopefully save us a
 # fulltext.
 yield (prev,)
 class deltacomputer(object):
 def __init__(self, revlog):
 self.revlog = revlog
 def buildtext(self, revinfo, fh):
 revlog = self.revlog
 cachedelta = revinfo.cachedelta
 baserev = cachedelta[0]
 delta = cachedelta[1]
-fulltext = btext[0] = _textfromdelta(fh, revlog, baserev, delta,
+fulltext = btext[0] = _textfromdelta(
-revinfo.p1, revinfo.p2,
+fh,
-revinfo.flags, revinfo.node)
+revlog,
+baserev,
+delta,
+revinfo.p1,
+revinfo.p2,
+revinfo.flags,
+revinfo.node,
+)
 return fulltext
 def _builddeltadiff(self, base, revinfo, fh):
 revlog = self.revlog
 t = self.buildtext(revinfo, fh)
 if deltabase not in (p1, p2) and revlog.issnapshot(deltabase):
 snapshotdepth = len(revlog._deltachain(deltabase)[0])
 delta = None
 if revinfo.cachedelta:
 cachebase, cachediff = revinfo.cachedelta
-#check if the diff still apply
+# check if the diff still apply
 currentbase = cachebase
-while (currentbase != nullrev
+while (
-and currentbase != base
+currentbase != nullrev
-and self.revlog.length(currentbase) == 0):
+and currentbase != base
+and self.revlog.length(currentbase) == 0
+):
 currentbase = self.revlog.deltaparent(currentbase)
 if self.revlog._lazydelta and currentbase == base:
 delta = revinfo.cachedelta[1]
 if delta is None:
 delta = self._builddeltadiff(base, revinfo, fh)
 dist = deltalen + offset - revlog.start(chainbase)
 chainlen, compresseddeltalen = revlog._chaininfo(base)
 chainlen += 1
 compresseddeltalen += deltalen
-return _deltainfo(dist, deltalen, (header, data), deltabase,
+return _deltainfo(
-chainbase, chainlen, compresseddeltalen,
+dist,
-snapshotdepth)
+deltalen,
+(header, data),
+deltabase,
+chainbase,
+chainlen,
+compresseddeltalen,
+snapshotdepth,
+)
 def _fullsnapshotinfo(self, fh, revinfo):
 curr = len(self.revlog)
 rawtext = self.buildtext(revinfo, fh)
 data = self.revlog.compress(rawtext)
 compresseddeltalen = deltalen = dist = len(data[1]) + len(data[0])
 deltabase = chainbase = curr
 snapshotdepth = 0
 chainlen = 1
-return _deltainfo(dist, deltalen, data, deltabase,
+return _deltainfo(
-chainbase, chainlen, compresseddeltalen,
+dist,
-snapshotdepth)
+deltalen,
+data,
+deltabase,
+chainbase,
+chainlen,
+compresseddeltalen,
+snapshotdepth,
+)
 def finddeltainfo(self, revinfo, fh):
 """Find an acceptable delta against a candidate revision
 revinfo: information about the revision (instance of _revisioninfo)
 p2 = revinfo.p2
 revlog = self.revlog
 deltainfo = None
 p1r, p2r = revlog.rev(p1), revlog.rev(p2)
-groups = _candidategroups(self.revlog, revinfo.textlen,
+groups = _candidategroups(
-p1r, p2r, cachedelta)
+self.revlog, revinfo.textlen, p1r, p2r, cachedelta
+)
 candidaterevs = next(groups)
 while candidaterevs is not None:
 nominateddeltas = []
 if deltainfo is not None:
 # if we already found a good delta,

Mercurial > public > mercurial-scm > hg

comparison mercurial/revlogutils/deltas.py @ 43076:2372284d9457