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

comparison mercurial/revlog.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	7902001aaf41
children	687b865b95ad

comparison

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 REVIDX_FLAGS_ORDER,
 REVIDX_ISCENSORED,
 REVIDX_RAWTEXT_CHANGING_FLAGS,
 REVIDX_SIDEDATA,
 )
-from .thirdparty import (
+from .thirdparty import attr
-attr,
-)
 from . import (
 ancestor,
 dagop,
 error,
 mdiff,
 # Flag processors for REVIDX_ELLIPSIS.
 def ellipsisreadprocessor(rl, text):
 return text, False, {}
 def ellipsiswriteprocessor(rl, text, sidedata):
 return text, False
 def ellipsisrawprocessor(rl, text):
 return False
 ellipsisprocessor = (
 ellipsisreadprocessor,
 ellipsiswriteprocessor,
 ellipsisrawprocessor,
 )
 def getoffset(q):
 return int(q >> 16)
 def gettype(q):
 return int(q & 0xFFFF)
 def offset_type(offset, type):
 if (type & ~flagutil.REVIDX_KNOWN_FLAGS) != 0:
 raise ValueError('unknown revlog index flags')
 return int(int(offset) << 16 | type)
 @attr.s(slots=True, frozen=True)
 class _revisioninfo(object):
 """Information about a revision that allows building its fulltext
 node:       expected hash of the revision
 cachedelta: (baserev, uncompressed_delta) or None
 flags:      flags associated to the revision storage
 One of btext[0] or cachedelta must be set.
 """
 node = attr.ib()
 p1 = attr.ib()
 p2 = attr.ib()
 btext = attr.ib()
 textlen = attr.ib()
 cachedelta = attr.ib()
 flags = attr.ib()
 @interfaceutil.implementer(repository.irevisiondelta)
 @attr.s(slots=True)
 class revlogrevisiondelta(object):
 node = attr.ib()
 baserevisionsize = attr.ib()
 revision = attr.ib()
 delta = attr.ib()
 linknode = attr.ib(default=None)
 @interfaceutil.implementer(repository.iverifyproblem)
 @attr.s(frozen=True)
 class revlogproblem(object):
 warning = attr.ib(default=None)
 error = attr.ib(default=None)
 node = attr.ib(default=None)
 # index v0:
 #  4 bytes: offset
 #  4 bytes: compressed length
 #  4 bytes: base rev
 # 20 bytes: nodeid
 indexformatv0 = struct.Struct(">4l20s20s20s")
 indexformatv0_pack = indexformatv0.pack
 indexformatv0_unpack = indexformatv0.unpack
 class revlogoldindex(list):
 def __getitem__(self, i):
 if i == -1:
 return (0, 0, 0, -1, -1, -1, -1, nullid)
 return list.__getitem__(self, i)
 class revlogoldio(object):
 def __init__(self):
 self.size = indexformatv0.size
 index = []
 nodemap = {nullid: nullrev}
 n = off = 0
 l = len(data)
 while off + s <= l:
-cur = data[off:off + s]
+cur = data[off : off + s]
 off += s
 e = indexformatv0_unpack(cur)
 # transform to revlogv1 format
-e2 = (offset_type(e[0], 0), e[1], -1, e[2], e[3],
+e2 = (
-nodemap.get(e[4], nullrev), nodemap.get(e[5], nullrev), e[6])
+offset_type(e[0], 0),
+e[1],
+-1,
+e[2],
+e[3],
+nodemap.get(e[4], nullrev),
+nodemap.get(e[5], nullrev),
+e[6],
+)
 index.append(e2)
 nodemap[e[6]] = n
 n += 1
 return revlogoldindex(index), nodemap, None
 def packentry(self, entry, node, version, rev):
 if gettype(entry[0]):
-raise error.RevlogError(_('index entry flags need revlog '
+raise error.RevlogError(
-'version 1'))
+_('index entry flags need revlog ' 'version 1')
-e2 = (getoffset(entry[0]), entry[1], entry[3], entry[4],
+)
-node(entry[5]), node(entry[6]), entry[7])
+e2 = (
+getoffset(entry[0]),
+entry[1],
+entry[3],
+entry[4],
+node(entry[5]),
+node(entry[6]),
+entry[7],
+)
 return indexformatv0_pack(*e2)
 # index ng:
 #  6 bytes: offset
 #  2 bytes: flags
 #  4 bytes: compressed length
 versionformat_pack = versionformat.pack
 versionformat_unpack = versionformat.unpack
 # corresponds to uncompressed length of indexformatng (2 gigs, 4-byte
 # signed integer)
-_maxentrysize = 0x7fffffff
+_maxentrysize = 0x7FFFFFFF
 class revlogio(object):
 def __init__(self):
 self.size = indexformatng.size
 def packentry(self, entry, node, version, rev):
 p = indexformatng_pack(*entry)
 if rev == 0:
 p = versionformat_pack(version) + p[4:]
 return p
 class revlog(object):
 """
 the underlying revision storage object
 compression for the data content.
 """
 _flagserrorclass = error.RevlogError
-def __init__(self, opener, indexfile, datafile=None, checkambig=False,
+def __init__(
-mmaplargeindex=False, censorable=False,
+self,
-upperboundcomp=None):
+opener,
+indexfile,
+datafile=None,
+checkambig=False,
+mmaplargeindex=False,
+censorable=False,
+upperboundcomp=None,
+):
 """
 create a revlog object
 opener is a function that abstracts the file opening operation
 and can be used to implement COW semantics or the like.
 # revlog v0 doesn't have flag processors
 for flag, processor in opts.get(b'flagprocessors', {}).iteritems():
 flagutil.insertflagprocessor(flag, processor, self._flagprocessors)
 if self._chunkcachesize <= 0:
-raise error.RevlogError(_('revlog chunk cache size %r is not '
+raise error.RevlogError(
-'greater than 0') % self._chunkcachesize)
+_('revlog chunk cache size %r is not ' 'greater than 0')
+% self._chunkcachesize
+)
 elif self._chunkcachesize & (self._chunkcachesize - 1):
-raise error.RevlogError(_('revlog chunk cache size %r is not a '
+raise error.RevlogError(
-'power of 2') % self._chunkcachesize)
+_('revlog chunk cache size %r is not a ' 'power of 2')
+% self._chunkcachesize
+)
 indexdata = ''
 self._initempty = True
 try:
 with self._indexfp() as f:
-if (mmapindexthreshold is not None and
+if (
-self.opener.fstat(f).st_size >= mmapindexthreshold):
+mmapindexthreshold is not None
+and self.opener.fstat(f).st_size >= mmapindexthreshold
+):
 # TODO: should .close() to release resources without
 # relying on Python GC
 indexdata = util.buffer(util.mmapread(f))
 else:
 indexdata = f.read()
 flags = versionflags & ~0xFFFF
 fmt = versionflags & 0xFFFF
 if fmt == REVLOGV0:
 if flags:
-raise error.RevlogError(_('unknown flags (%#04x) in version %d '
+raise error.RevlogError(
-'revlog %s') %
+_('unknown flags (%#04x) in version %d ' 'revlog %s')
-(flags >> 16, fmt, self.indexfile))
+% (flags >> 16, fmt, self.indexfile)
+)
 self._inline = False
 self._generaldelta = False
 elif fmt == REVLOGV1:
 if flags & ~REVLOGV1_FLAGS:
-raise error.RevlogError(_('unknown flags (%#04x) in version %d '
+raise error.RevlogError(
-'revlog %s') %
+_('unknown flags (%#04x) in version %d ' 'revlog %s')
-(flags >> 16, fmt, self.indexfile))
+% (flags >> 16, fmt, self.indexfile)
+)
 self._inline = versionflags & FLAG_INLINE_DATA
 self._generaldelta = versionflags & FLAG_GENERALDELTA
 elif fmt == REVLOGV2:
 if flags & ~REVLOGV2_FLAGS:
-raise error.RevlogError(_('unknown flags (%#04x) in version %d '
+raise error.RevlogError(
-'revlog %s') %
+_('unknown flags (%#04x) in version %d ' 'revlog %s')
-(flags >> 16, fmt, self.indexfile))
+% (flags >> 16, fmt, self.indexfile)
+)
 self._inline = versionflags & FLAG_INLINE_DATA
 # generaldelta implied by version 2 revlogs.
 self._generaldelta = True
 else:
-raise error.RevlogError(_('unknown version (%d) in revlog %s') %
+raise error.RevlogError(
-(fmt, self.indexfile))
+_('unknown version (%d) in revlog %s') % (fmt, self.indexfile)
+)
 # sparse-revlog can't be on without general-delta (issue6056)
 if not self._generaldelta:
 self._sparserevlog = False
 self._storedeltachains = True
 if self.version == REVLOGV0:
 self._io = revlogoldio()
 try:
 d = self._io.parseindex(indexdata, self._inline)
 except (ValueError, IndexError):
-raise error.RevlogError(_("index %s is corrupted") %
+raise error.RevlogError(_("index %s is corrupted") % self.indexfile)
-self.indexfile)
 self.index, nodemap, self._chunkcache = d
 if nodemap is not None:
 self.nodemap = self._nodecache = nodemap
 if not self._chunkcache:
 self._chunkclear()
 with func() as fp:
 yield fp
 def tip(self):
 return self.node(len(self.index) - 1)
 def __contains__(self, rev):
 return 0 <= rev < len(self)
 def __len__(self):
 return len(self.index)
 def __iter__(self):
 return iter(pycompat.xrange(len(self)))
 def revs(self, start=0, stop=None):
 """iterate over all rev in this revlog (from start to stop)"""
 return storageutil.iterrevs(len(self), start=start, stop=stop)
 @util.propertycache
 # Disable delta if either rev requires a content-changing flag
 # processor (ex. LFS). This is because such flag processor can alter
 # the rawtext content that the delta will be based on, and two clients
 # could have a same revlog node with different flags (i.e. different
 # rawtext contents) and the delta could be incompatible.
-if ((self.flags(baserev) & REVIDX_RAWTEXT_CHANGING_FLAGS)
+if (self.flags(baserev) & REVIDX_RAWTEXT_CHANGING_FLAGS) or (
-or (self.flags(rev) & REVIDX_RAWTEXT_CHANGING_FLAGS)):
+self.flags(rev) & REVIDX_RAWTEXT_CHANGING_FLAGS
+):
 return False
 return True
 def clearcaches(self):
 self._revisioncache = None
 return self.start(rev) + self.length(rev)
 def parents(self, node):
 i = self.index
 d = i[self.rev(node)]
-return i[d[5]][7], i[d[6]][7] # map revisions to nodes inline
+return i[d[5]][7], i[d[6]][7]  # map revisions to nodes inline
 def chainlen(self, rev):
 return self._chaininfo(rev)[0]
 def _chaininfo(self, rev):
 roots = list(roots)
 if not roots:
 return nonodes
 lowestrev = min([self.rev(n) for n in roots])
 else:
-roots = [nullid] # Everybody's a descendant of nullid
+roots = [nullid]  # Everybody's a descendant of nullid
 lowestrev = nullrev
 if (lowestrev == nullrev) and (heads is None):
 # We want _all_ the nodes!
 return ([self.node(r) for r in self], [nullid], list(self.heads()))
 if heads is None:
 r = self.rev(n)
 if r >= lowestrev:
 if n not in ancestors:
 # If we are possibly a descendant of one of the roots
 # and we haven't already been marked as an ancestor
-ancestors.add(n) # Mark as ancestor
+ancestors.add(n)  # Mark as ancestor
 # Add non-nullid parents to list of nodes to tag.
-nodestotag.update([p for p in self.parents(n) if
+nodestotag.update(
-p != nullid])
+[p for p in self.parents(n) if p != nullid]
-elif n in heads: # We've seen it before, is it a fake head?
+)
+elif n in heads:  # We've seen it before, is it a fake head?
 # So it is, real heads should not be the ancestors of
 # any other heads.
 heads.pop(n)
 if not ancestors:
 return nonodes
 else:
 start = self.rev(start)
 stoprevs = set(self.rev(n) for n in stop or [])
-revs = dagop.headrevssubset(self.revs, self.parentrevs, startrev=start,
+revs = dagop.headrevssubset(
-stoprevs=stoprevs)
+self.revs, self.parentrevs, startrev=start, stoprevs=stoprevs
+)
 return [self.node(rev) for rev in revs]
 def children(self, node):
 """find the children of a given node"""
 def _commonancestorsheads(self, *revs):
 """calculate all the heads of the common ancestors of revs"""
 try:
 ancs = self.index.commonancestorsheads(*revs)
-except (AttributeError, OverflowError): # C implementation failed
+except (AttributeError, OverflowError):  # C implementation failed
 ancs = ancestor.commonancestorsheads(self.parentrevs, *revs)
 return ancs
 def isancestor(self, a, b):
 """return True if node a is an ancestor of node b
 def reachableroots(self, minroot, heads, roots, includepath=False):
 """return (heads(::<roots> and <roots>::<heads>))
 If includepath is True, return (<roots>::<heads>)."""
 try:
-return self.index.reachableroots2(minroot, heads, roots,
+return self.index.reachableroots2(
-includepath)
+minroot, heads, roots, includepath
+)
 except AttributeError:
-return dagop._reachablerootspure(self.parentrevs,
+return dagop._reachablerootspure(
-minroot, roots, heads, includepath)
+self.parentrevs, minroot, roots, heads, includepath
+)
 def ancestor(self, a, b):
 """calculate the "best" common ancestor of nodes a and b"""
 a, b = self.rev(a), self.rev(b)
 if len(id) == 20:
 # possibly a binary node
 # odds of a binary node being all hex in ASCII are 1 in 10**25
 try:
 node = id
-self.rev(node) # quick search the index
+self.rev(node)  # quick search the index
 return node
 except error.LookupError:
-pass # may be partial hex id
+pass  # may be partial hex id
 try:
 # str(rev)
 rev = int(id)
 if "%d" % rev != id:
 raise ValueError
 except error.RevlogError:
 # parsers.c radix tree lookup gave multiple matches
 # fast path: for unfiltered changelog, radix tree is accurate
 if not getattr(self, 'filteredrevs', None):
 raise error.AmbiguousPrefixLookupError(
-id, self.indexfile, _('ambiguous identifier'))
+id, self.indexfile, _('ambiguous identifier')
+)
 # fall through to slow path that filters hidden revisions
 except (AttributeError, ValueError):
 # we are pure python, or key was too short to search radix tree
 pass
 if len(id) <= 40:
 try:
 # hex(node)[:...]
 l = len(id) // 2  # grab an even number of digits
-prefix = bin(id[:l * 2])
+prefix = bin(id[: l * 2])
 nl = [e[7] for e in self.index if e[7].startswith(prefix)]
-nl = [n for n in nl if hex(n).startswith(id) and
+nl = [
-self.hasnode(n)]
+n for n in nl if hex(n).startswith(id) and self.hasnode(n)
+]
 if nullhex.startswith(id):
 nl.append(nullid)
 if len(nl) > 0:
 if len(nl) == 1 and not maybewdir:
 self._pcache[id] = nl[0]
 return nl[0]
 raise error.AmbiguousPrefixLookupError(
-id, self.indexfile, _('ambiguous identifier'))
+id, self.indexfile, _('ambiguous identifier')
+)
 if maybewdir:
 raise error.WdirUnsupported
 return None
 except TypeError:
 pass
 raise error.LookupError(id, self.indexfile, _('no match found'))
 def shortest(self, node, minlength=1):
 """Find the shortest unambiguous prefix that matches node."""
 def isvalid(prefix):
 try:
 matchednode = self._partialmatch(prefix)
 except error.AmbiguousPrefixLookupError:
 return False
 # Cache data both forward and backward around the requested
 # data, in a fixed size window. This helps speed up operations
 # involving reading the revlog backwards.
 cachesize = self._chunkcachesize
 realoffset = offset & ~(cachesize - 1)
-reallength = (((offset + length + cachesize) & ~(cachesize - 1))
+reallength = (
-- realoffset)
+(offset + length + cachesize) & ~(cachesize - 1)
+) - realoffset
 with self._datareadfp(df) as df:
 df.seek(realoffset)
 d = df.read(reallength)
 self._cachesegment(realoffset, d)
 if offset != realoffset or reallength != length:
 startoffset = offset - realoffset
 if len(d) - startoffset < length:
 raise error.RevlogError(
-_('partial read of revlog %s; expected %d bytes from '
+_(
-'offset %d, got %d') %
+'partial read of revlog %s; expected %d bytes from '
-(self.indexfile if self._inline else self.datafile,
+'offset %d, got %d'
-length, realoffset, len(d) - startoffset))
+)
+% (
+self.indexfile if self._inline else self.datafile,
+length,
+realoffset,
+len(d) - startoffset,
+)
+)
 return util.buffer(d, startoffset, length)
 if len(d) < length:
 raise error.RevlogError(
-_('partial read of revlog %s; expected %d bytes from offset '
+_(
-'%d, got %d') %
+'partial read of revlog %s; expected %d bytes from offset '
-(self.indexfile if self._inline else self.datafile,
+'%d, got %d'
-length, offset, len(d)))
+)
+% (
+self.indexfile if self._inline else self.datafile,
+length,
+offset,
+len(d),
+)
+)
 return d
 def _getsegment(self, offset, length, df=None):
 """Obtain a segment of raw data from the revlog.
 # is it in the cache?
 cachestart = offset - o
 cacheend = cachestart + length
 if cachestart >= 0 and cacheend <= l:
 if cachestart == 0 and cacheend == l:
-return d # avoid a copy
+return d  # avoid a copy
 return util.buffer(d, cachestart, cacheend - cachestart)
 return self._readsegment(offset, length, df=df)
 def _getsegmentforrevs(self, startrev, endrev, df=None):
 ladd = l.append
 if not self._withsparseread:
 slicedchunks = (revs,)
 else:
-slicedchunks = deltautil.slicechunk(self, revs,
+slicedchunks = deltautil.slicechunk(
-targetsize=targetsize)
+self, revs, targetsize=targetsize
+)
 for revschunk in slicedchunks:
 firstrev = revschunk[0]
 # Skip trailing revisions with empty diff
 for lastrev in revschunk[::-1]:
 revlog data directly. So this function needs raw revision data.
 """
 if rev1 != nullrev and self.deltaparent(rev2) == rev1:
 return bytes(self._chunk(rev2))
-return mdiff.textdiff(self.rawdata(rev1),
+return mdiff.textdiff(self.rawdata(rev1), self.rawdata(rev2))
-self.rawdata(rev2))
 def _processflags(self, text, flags, operation, raw=False):
 """deprecated entry point to access flag processors"""
-msg = ('_processflag(...) use the specialized variant')
+msg = '_processflag(...) use the specialized variant'
 util.nouideprecwarn(msg, '5.2', stacklevel=2)
 if raw:
 return text, flagutil.processflagsraw(self, text, flags)
 elif operation == 'read':
 return flagutil.processflagsread(self, text, flags)
-else: # write operation
+else:  # write operation
 return flagutil.processflagswrite(self, text, flags)
 def revision(self, nodeorrev, _df=None, raw=False):
 """return an uncompressed revision of a given node or revision
 number.
 raw - an optional argument specifying if the revision data is to be
 treated as raw data when applying flag transforms. 'raw' should be set
 to True when generating changegroups or in debug commands.
 """
 if raw:
-msg = ('revlog.revision(..., raw=True) is deprecated, '
+msg = (
-'use revlog.rawdata(...)')
+'revlog.revision(..., raw=True) is deprecated, '
+'use revlog.rawdata(...)'
+)
 util.nouideprecwarn(msg, '5.2', stacklevel=2)
 return self._revisiondata(nodeorrev, _df, raw=raw)[0]
 def sidedata(self, nodeorrev, _df=None):
 """a map of extra data related to the changeset but not part of the hash
 else:
 try:
 r = flagutil.processflagsread(self, rawtext, flags)
 except error.SidedataHashError as exc:
 msg = _("integrity check failed on %s:%s sidedata key %d")
-msg %= (self.indexfile, pycompat.bytestr(rev),
+msg %= (self.indexfile, pycompat.bytestr(rev), exc.sidedatakey)
-exc.sidedatakey)
 raise error.RevlogError(msg)
 text, validatehash, sidedata = r
 if validatehash:
 self.checkhash(text, node, rev=rev)
 if not validated:
 if basetext is None:
 basetext = bytes(bins[0])
 bins = bins[1:]
 rawtext = mdiff.patches(basetext, bins)
-del basetext # let us have a chance to free memory early
+del basetext  # let us have a chance to free memory early
 return (rev, rawtext, False)
 def rawdata(self, nodeorrev, _df=None):
 """return an uncompressed raw data of a given node or revision number.
 self._revisioncache = None
 revornode = rev
 if revornode is None:
 revornode = templatefilters.short(hex(node))
-raise error.RevlogError(_("integrity check failed on %s:%s")
+raise error.RevlogError(
-% (self.indexfile, pycompat.bytestr(revornode)))
+_("integrity check failed on %s:%s")
+% (self.indexfile, pycompat.bytestr(revornode))
+)
 except error.RevlogError:
 if self._censorable and storageutil.iscensoredtext(text):
 raise error.CensoredNodeError(self.indexfile, node, text)
 raise
 This should be called after revisions are added to the revlog. If the
 revlog has grown too large to be an inline revlog, it will convert it
 to use multiple index and data files.
 """
 tiprev = len(self) - 1
-if (not self._inline or
+if (
-(self.start(tiprev) + self.length(tiprev)) < _maxinline):
+not self._inline
+or (self.start(tiprev) + self.length(tiprev)) < _maxinline
+):
 return
 trinfo = tr.find(self.indexfile)
 if trinfo is None:
-raise error.RevlogError(_("%s not found in the transaction")
+raise error.RevlogError(
-% self.indexfile)
+_("%s not found in the transaction") % self.indexfile
+)
 trindex = trinfo[2]
 if trindex is not None:
 dataoff = self.start(trindex)
 else:
 def _nodeduplicatecallback(self, transaction, node):
 """called when trying to add a node already stored.
 """
-def addrevision(self, text, transaction, link, p1, p2, cachedelta=None,
+def addrevision(
-node=None, flags=REVIDX_DEFAULT_FLAGS, deltacomputer=None,
+self,
-sidedata=None):
+text,
+transaction,
+link,
+p1,
+p2,
+cachedelta=None,
+node=None,
+flags=REVIDX_DEFAULT_FLAGS,
+deltacomputer=None,
+sidedata=None,
+):
 """add a revision to the log
 text - the revision data to add
 transaction - the transaction object used for rollback
 link - the linkrev data to add
 flags - the known flags to set on the revision
 deltacomputer - an optional deltacomputer instance shared between
 multiple calls
 """
 if link == nullrev:
-raise error.RevlogError(_("attempted to add linkrev -1 to %s")
+raise error.RevlogError(
-% self.indexfile)
+_("attempted to add linkrev -1 to %s") % self.indexfile
+)
 if sidedata is None:
 sidedata = {}
 flags = flags & ~REVIDX_SIDEDATA
 elif not self.hassidedata:
 raise error.ProgrammingError(
 _("trying to add sidedata to a revlog who don't support them")
 )
 else:
 flags |= REVIDX_SIDEDATA
 if flags:
 node = node or self.hash(text, p1, p2)
-rawtext, validatehash = flagutil.processflagswrite(self, text, flags,
+rawtext, validatehash = flagutil.processflagswrite(
-sidedata=sidedata)
+self, text, flags, sidedata=sidedata
+)
 # If the flag processor modifies the revision data, ignore any provided
 # cachedelta.
 if rawtext != text:
 cachedelta = None
 if len(rawtext) > _maxentrysize:
 raise error.RevlogError(
 _("%s: size of %d bytes exceeds maximum revlog storage of 2GiB")
-% (self.indexfile, len(rawtext)))
+% (self.indexfile, len(rawtext))
+)
 node = node or self.hash(rawtext, p1, p2)
 if node in self.nodemap:
 return node
 if validatehash:
 self.checkhash(rawtext, node, p1=p1, p2=p2)
-return self.addrawrevision(rawtext, transaction, link, p1, p2, node,
+return self.addrawrevision(
-flags, cachedelta=cachedelta,
+rawtext,
-deltacomputer=deltacomputer)
+transaction,
+link,
-def addrawrevision(self, rawtext, transaction, link, p1, p2, node, flags,
+p1,
-cachedelta=None, deltacomputer=None):
+p2,
+node,
+flags,
+cachedelta=cachedelta,
+deltacomputer=deltacomputer,
+)
+def addrawrevision(
+self,
+rawtext,
+transaction,
+link,
+p1,
+p2,
+node,
+flags,
+cachedelta=None,
+deltacomputer=None,
+):
 """add a raw revision with known flags, node and parents
 useful when reusing a revision not stored in this revlog (ex: received
 over wire, or read from an external bundle).
 """
 dfh = None
 if not self._inline:
 dfh = self._datafp("a+")
 ifh = self._indexfp("a+")
 try:
-return self._addrevision(node, rawtext, transaction, link, p1, p2,
+return self._addrevision(
-flags, cachedelta, ifh, dfh,
+node,
-deltacomputer=deltacomputer)
+rawtext,
+transaction,
+link,
+p1,
+p2,
+flags,
+cachedelta,
+ifh,
+dfh,
+deltacomputer=deltacomputer,
+)
 finally:
 if dfh:
 dfh.close()
 ifh.close()
 if t == 'x':
 try:
 return _zlibdecompress(data)
 except zlib.error as e:
-raise error.RevlogError(_('revlog decompress error: %s') %
+raise error.RevlogError(
-stringutil.forcebytestr(e))
+_('revlog decompress error: %s')
+% stringutil.forcebytestr(e)
+)
 # '\0' is more common than 'u' so it goes first.
 elif t == '\0':
 return data
 elif t == 'u':
 return util.buffer(data, 1)
 except KeyError:
 raise error.RevlogError(_('unknown compression type %r') % t)
 return compressor.decompress(data)
-def _addrevision(self, node, rawtext, transaction, link, p1, p2, flags,
+def _addrevision(
-cachedelta, ifh, dfh, alwayscache=False,
+self,
-deltacomputer=None):
+node,
+rawtext,
+transaction,
+link,
+p1,
+p2,
+flags,
+cachedelta,
+ifh,
+dfh,
+alwayscache=False,
+deltacomputer=None,
+):
 """internal function to add revisions to the log
 see addrevision for argument descriptions.
 note: "addrevision" takes non-raw text, "_addrevision" takes raw text.
 invariants:
 - rawtext is optional (can be None); if not set, cachedelta must be set.
 if both are set, they must correspond to each other.
 """
 if node == nullid:
-raise error.RevlogError(_("%s: attempt to add null revision") %
+raise error.RevlogError(
-self.indexfile)
+_("%s: attempt to add null revision") % self.indexfile
+)
 if node == wdirid or node in wdirfilenodeids:
-raise error.RevlogError(_("%s: attempt to add wdir revision") %
+raise error.RevlogError(
-self.indexfile)
+_("%s: attempt to add wdir revision") % self.indexfile
+)
 if self._inline:
 fh = ifh
 else:
 fh = dfh
 # become comparable to the uncompressed text
 if rawtext is None:
 # need rawtext size, before changed by flag processors, which is
 # the non-raw size. use revlog explicitly to avoid filelog's extra
 # logic that might remove metadata size.
-textlen = mdiff.patchedsize(revlog.size(self, cachedelta[0]),
+textlen = mdiff.patchedsize(
-cachedelta[1])
+revlog.size(self, cachedelta[0]), cachedelta[1]
+)
 else:
 textlen = len(rawtext)
 if deltacomputer is None:
 deltacomputer = deltautil.deltacomputer(self)
 revinfo = _revisioninfo(node, p1, p2, btext, textlen, cachedelta, flags)
 deltainfo = deltacomputer.finddeltainfo(revinfo, fh)
-e = (offset_type(offset, flags), deltainfo.deltalen, textlen,
+e = (
-deltainfo.base, link, p1r, p2r, node)
+offset_type(offset, flags),
+deltainfo.deltalen,
+textlen,
+deltainfo.base,
+link,
+p1r,
+p2r,
+node,
+)
 self.index.append(e)
 self.nodemap[node] = curr
 # Reset the pure node cache start lookup offset to account for new
 # revision.
 if self._nodepos is not None:
 self._nodepos = curr
 entry = self._io.packentry(e, self.node, self.version, curr)
-self._writeentry(transaction, ifh, dfh, entry, deltainfo.data,
+self._writeentry(
-link, offset)
+transaction, ifh, dfh, entry, deltainfo.data, link, offset
+)
 rawtext = btext[0]
 if alwayscache and rawtext is None:
 rawtext = deltacomputer.buildtext(revinfo, fh)
-if type(rawtext) == bytes: # only accept immutable objects
+if type(rawtext) == bytes:  # only accept immutable objects
 self._revisioncache = (node, curr, rawtext)
 self._chainbasecache[curr] = deltainfo.chainbase
 return node
 def _writeentry(self, transaction, ifh, dfh, entry, data, link, offset):
 dfh = None
 else:
 transaction.add(self.indexfile, isize, r)
 transaction.add(self.datafile, end)
 dfh = self._datafp("a+")
 def flush():
 if dfh:
 dfh.flush()
 ifh.flush()
 # this can happen if two branches make the same change
 continue
 for p in (p1, p2):
 if p not in self.nodemap:
-raise error.LookupError(p, self.indexfile,
+raise error.LookupError(
-_('unknown parent'))
+p, self.indexfile, _('unknown parent')
+)
 if deltabase not in self.nodemap:
-raise error.LookupError(deltabase, self.indexfile,
+raise error.LookupError(
-_('unknown delta base'))
+deltabase, self.indexfile, _('unknown delta base')
+)
 baserev = self.rev(deltabase)
 if baserev != nullrev and self.iscensored(baserev):
 # if base is censored, delta must be full replacement in a
 # single patch operation
 hlen = struct.calcsize(">lll")
 oldlen = self.rawsize(baserev)
 newlen = len(delta) - hlen
 if delta[:hlen] != mdiff.replacediffheader(oldlen, newlen):
-raise error.CensoredBaseError(self.indexfile,
+raise error.CensoredBaseError(
-self.node(baserev))
+self.indexfile, self.node(baserev)
+)
 if not flags and self._peek_iscensored(baserev, delta, flush):
 flags |= REVIDX_ISCENSORED
 # We assume consumers of addrevisioncb will want to retrieve
 # revision(). revision() will fast path if there is a cache
 # hit. So, we tell _addrevision() to always cache in this case.
 # We're only using addgroup() in the context of changegroup
 # generation so the revision data can always be handled as raw
 # by the flagprocessor.
-self._addrevision(node, None, transaction, link,
+self._addrevision(
-p1, p2, flags, (baserev, delta),
+node,
-ifh, dfh,
+None,
-alwayscache=bool(addrevisioncb),
+transaction,
-deltacomputer=deltacomputer)
+link,
+p1,
+p2,
+flags,
+(baserev, delta),
+ifh,
+dfh,
+alwayscache=bool(addrevisioncb),
+deltacomputer=deltacomputer,
+)
 if addrevisioncb:
 addrevisioncb(self, node)
 if not dfh and not self._inline:
 """find the minimum rev that must be stripped to strip the linkrev
 Returns a tuple containing the minimum rev and a set of all revs that
 have linkrevs that will be broken by this strip.
 """
-return storageutil.resolvestripinfo(minlink, len(self) - 1,
+return storageutil.resolvestripinfo(
-self.headrevs(),
+minlink,
-self.linkrev, self.parentrevs)
+len(self) - 1,
+self.headrevs(),
+self.linkrev,
+self.parentrevs,
+)
 def strip(self, minlink, transaction):
 """truncate the revlog on the first revision with a linkrev >= minlink
 This function is called when we're stripping revision minlink and
 res = [self.indexfile]
 if not self._inline:
 res.append(self.datafile)
 return res
-def emitrevisions(self, nodes, nodesorder=None, revisiondata=False,
+def emitrevisions(
-assumehaveparentrevisions=False,
+self,
-deltamode=repository.CG_DELTAMODE_STD):
+nodes,
+nodesorder=None,
+revisiondata=False,
+assumehaveparentrevisions=False,
+deltamode=repository.CG_DELTAMODE_STD,
+):
 if nodesorder not in ('nodes', 'storage', 'linear', None):
-raise error.ProgrammingError('unhandled value for nodesorder: %s' %
+raise error.ProgrammingError(
-nodesorder)
+'unhandled value for nodesorder: %s' % nodesorder
+)
 if nodesorder is None and not self._generaldelta:
 nodesorder = 'storage'
-if (not self._storedeltachains and
+if (
-deltamode != repository.CG_DELTAMODE_PREV):
+not self._storedeltachains
+and deltamode != repository.CG_DELTAMODE_PREV
+):
 deltamode = repository.CG_DELTAMODE_FULL
 return storageutil.emitrevisions(
-self, nodes, nodesorder, revlogrevisiondelta,
+self,
+nodes,
+nodesorder,
+revlogrevisiondelta,
 deltaparentfn=self.deltaparent,
 candeltafn=self.candelta,
 rawsizefn=self.rawsize,
 revdifffn=self.revdiff,
 flagsfn=self.flags,
 deltamode=deltamode,
 revisiondata=revisiondata,
-assumehaveparentrevisions=assumehaveparentrevisions)
+assumehaveparentrevisions=assumehaveparentrevisions,
+)
 DELTAREUSEALWAYS = 'always'
 DELTAREUSESAMEREVS = 'samerevs'
 DELTAREUSENEVER = 'never'
 DELTAREUSEFULLADD = 'fulladd'
 DELTAREUSEALL = {'always', 'samerevs', 'never', 'fulladd'}
-def clone(self, tr, destrevlog, addrevisioncb=None,
+def clone(
-deltareuse=DELTAREUSESAMEREVS, forcedeltabothparents=None):
+self,
+tr,
+destrevlog,
+addrevisioncb=None,
+deltareuse=DELTAREUSESAMEREVS,
+forcedeltabothparents=None,
+):
 """Copy this revlog to another, possibly with format changes.
 The destination revlog will contain the same revisions and nodes.
 However, it may not be bit-for-bit identical due to e.g. delta encoding
 differences.
 destrevlog._lazydeltabase = False
 destrevlog._lazydelta = False
 destrevlog._deltabothparents = forcedeltabothparents or oldamd
-self._clone(tr, destrevlog, addrevisioncb, deltareuse,
+self._clone(
-forcedeltabothparents)
+tr, destrevlog, addrevisioncb, deltareuse, forcedeltabothparents
+)
 finally:
 destrevlog._lazydelta = oldlazydelta
 destrevlog._lazydeltabase = oldlazydeltabase
 destrevlog._deltabothparents = oldamd
-def _clone(self, tr, destrevlog, addrevisioncb, deltareuse,
+def _clone(
-forcedeltabothparents):
+self, tr, destrevlog, addrevisioncb, deltareuse, forcedeltabothparents
+):
 """perform the core duty of `revlog.clone` after parameter processing"""
 deltacomputer = deltautil.deltacomputer(destrevlog)
 index = self.index
 for rev in self:
 entry = index[rev]
 # Some classes override linkrev to take filtered revs into
 # account. Use raw entry from index.
-flags = entry[0] & 0xffff
+flags = entry[0] & 0xFFFF
 linkrev = entry[4]
 p1 = index[entry[5]][7]
 p2 = index[entry[6]][7]
 node = entry[7]
 # the revlog chunk is a delta.
 cachedelta = None
 rawtext = None
 if deltareuse == self.DELTAREUSEFULLADD:
 text = self.revision(rev)
-destrevlog.addrevision(text, tr, linkrev, p1, p2,
+destrevlog.addrevision(
-cachedelta=cachedelta,
+text,
-node=node, flags=flags,
+tr,
-deltacomputer=deltacomputer)
+linkrev,
+p1,
+p2,
+cachedelta=cachedelta,
+node=node,
+flags=flags,
+deltacomputer=deltacomputer,
+)
 else:
 if destrevlog._lazydelta:
 dp = self.deltaparent(rev)
 if dp != nullrev:
 cachedelta = (dp, bytes(self._chunk(rev)))
 if not cachedelta:
 rawtext = self.rawdata(rev)
-ifh = destrevlog.opener(destrevlog.indexfile, 'a+',
+ifh = destrevlog.opener(
-checkambig=False)
+destrevlog.indexfile, 'a+', checkambig=False
+)
 dfh = None
 if not destrevlog._inline:
 dfh = destrevlog.opener(destrevlog.datafile, 'a+')
 try:
-destrevlog._addrevision(node, rawtext, tr, linkrev, p1,
+destrevlog._addrevision(
-p2, flags, cachedelta, ifh, dfh,
+node,
-deltacomputer=deltacomputer)
+rawtext,
+tr,
+linkrev,
+p1,
+p2,
+flags,
+cachedelta,
+ifh,
+dfh,
+deltacomputer=deltacomputer,
+)
 finally:
 if dfh:
 dfh.close()
 ifh.close()
 if addrevisioncb:
 addrevisioncb(self, rev, node)
 def censorrevision(self, tr, censornode, tombstone=b''):
 if (self.version & 0xFFFF) == REVLOGV0:
-raise error.RevlogError(_('cannot censor with version %d revlogs') %
+raise error.RevlogError(
-self.version)
+_('cannot censor with version %d revlogs') % self.version
+)
 censorrev = self.rev(censornode)
 tombstone = storageutil.packmeta({b'censored': tombstone}, b'')
 if len(tombstone) > self.rawsize(censorrev):
-raise error.Abort(_('censor tombstone must be no longer than '
+raise error.Abort(
-'censored data'))
+_('censor tombstone must be no longer than ' 'censored data')
+)
 # Rewriting the revlog in place is hard. Our strategy for censoring is
 # to create a new revlog, copy all revisions to it, then replace the
 # revlogs on transaction close.
 newindexfile = self.indexfile + b'.tmpcensored'
 newdatafile = self.datafile + b'.tmpcensored'
 # This is a bit dangerous. We could easily have a mismatch of state.
-newrl = revlog(self.opener, newindexfile, newdatafile,
+newrl = revlog(self.opener, newindexfile, newdatafile, censorable=True)
-censorable=True)
 newrl.version = self.version
 newrl._generaldelta = self._generaldelta
 newrl._io = self._io
 for rev in self.revs():
 node = self.node(rev)
 p1, p2 = self.parents(node)
 if rev == censorrev:
-newrl.addrawrevision(tombstone, tr, self.linkrev(censorrev),
+newrl.addrawrevision(
-p1, p2, censornode, REVIDX_ISCENSORED)
+tombstone,
+tr,
+self.linkrev(censorrev),
+p1,
+p2,
+censornode,
+REVIDX_ISCENSORED,
+)
 if newrl.deltaparent(rev) != nullrev:
-raise error.Abort(_('censored revision stored as delta; '
+raise error.Abort(
-'cannot censor'),
+_(
-hint=_('censoring of revlogs is not '
+'censored revision stored as delta; '
-'fully implemented; please report '
+'cannot censor'
-'this bug'))
+),
+hint=_(
+'censoring of revlogs is not '
+'fully implemented; please report '
+'this bug'
+),
+)
 continue
 if self.iscensored(rev):
 if self.deltaparent(rev) != nullrev:
-raise error.Abort(_('cannot censor due to censored '
+raise error.Abort(
-'revision having delta stored'))
+_(
+'cannot censor due to censored '
+'revision having delta stored'
+)
+)
 rawtext = self._chunk(rev)
 else:
 rawtext = self.rawdata(rev)
-newrl.addrawrevision(rawtext, tr, self.linkrev(rev), p1, p2, node,
+newrl.addrawrevision(
-self.flags(rev))
+rawtext, tr, self.linkrev(rev), p1, p2, node, self.flags(rev)
+)
 tr.addbackup(self.indexfile, location='store')
 if not self._inline:
 tr.addbackup(self.datafile, location='store')
 version = self.version & 0xFFFF
 # The verifier tells us what version revlog we should be.
 if version != state['expectedversion']:
 yield revlogproblem(
-warning=_("warning: '%s' uses revlog format %d; expected %d") %
+warning=_("warning: '%s' uses revlog format %d; expected %d")
-(self.indexfile, version, state['expectedversion']))
+% (self.indexfile, version, state['expectedversion'])
+)
 state['skipread'] = set()
 for rev in self:
 node = self.node(rev)
 l2 = len(self.rawdata(node))
 if l1 != l2:
 yield revlogproblem(
 error=_('unpacked size is %d, %d expected') % (l2, l1),
-node=node)
+node=node,
+)
 except error.CensoredNodeError:
 if state['erroroncensored']:
-yield revlogproblem(error=_('censored file data'),
+yield revlogproblem(
-node=node)
+error=_('censored file data'), node=node
+)
 state['skipread'].add(node)
 except Exception as e:
 yield revlogproblem(
-error=_('unpacking %s: %s') % (short(node),
+error=_('unpacking %s: %s')
-stringutil.forcebytestr(e)),
+% (short(node), stringutil.forcebytestr(e)),
-node=node)
+node=node,
+)
 state['skipread'].add(node)
-def storageinfo(self, exclusivefiles=False, sharedfiles=False,
+def storageinfo(
-revisionscount=False, trackedsize=False,
+self,
-storedsize=False):
+exclusivefiles=False,
+sharedfiles=False,
+revisionscount=False,
+trackedsize=False,
+storedsize=False,
+):
 d = {}
 if exclusivefiles:
 d['exclusivefiles'] = [(self.opener, self.indexfile)]
 if not self._inline:
 if trackedsize:
 d['trackedsize'] = sum(map(self.rawsize, iter(self)))
 if storedsize:
-d['storedsize'] = sum(self.opener.stat(path).st_size
+d['storedsize'] = sum(
-for path in self.files())
+self.opener.stat(path).st_size for path in self.files()
+)
 return d

Mercurial > public > mercurial-scm > hg-stable

comparison mercurial/revlog.py @ 43076:2372284d9457