--- a/mercurial/revlog.py	Sat Oct 05 10:29:34 2019 -0400
+++ b/mercurial/revlog.py	Sun Oct 06 09:45:02 2019 -0400
@@ -56,9 +56,7 @@
     REVIDX_RAWTEXT_CHANGING_FLAGS,
     REVIDX_SIDEDATA,
 )
-from .thirdparty import (
-    attr,
-)
+from .thirdparty import attr
 from . import (
     ancestor,
     dagop,
@@ -118,29 +116,36 @@
 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
@@ -152,6 +157,7 @@
 
     One of btext[0] or cachedelta must be set.
     """
+
     node = attr.ib()
     p1 = attr.ib()
     p2 = attr.ib()
@@ -160,6 +166,7 @@
     cachedelta = attr.ib()
     flags = attr.ib()
 
+
 @interfaceutil.implementer(repository.irevisiondelta)
 @attr.s(slots=True)
 class revlogrevisiondelta(object):
@@ -173,6 +180,7 @@
     delta = attr.ib()
     linknode = attr.ib(default=None)
 
+
 @interfaceutil.implementer(repository.iverifyproblem)
 @attr.s(frozen=True)
 class revlogproblem(object):
@@ -180,6 +188,7 @@
     error = attr.ib(default=None)
     node = attr.ib(default=None)
 
+
 # index v0:
 #  4 bytes: offset
 #  4 bytes: compressed length
@@ -192,12 +201,14 @@
 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
@@ -209,12 +220,20 @@
         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],
-                  nodemap.get(e[4], nullrev), nodemap.get(e[5], nullrev), e[6])
+            e2 = (
+                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
@@ -223,12 +242,21 @@
 
     def packentry(self, entry, node, version, rev):
         if gettype(entry[0]):
-            raise error.RevlogError(_('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])
+            raise error.RevlogError(
+                _('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],
+        )
         return indexformatv0_pack(*e2)
 
+
 # index ng:
 #  6 bytes: offset
 #  2 bytes: flags
@@ -247,7 +275,8 @@
 
 # corresponds to uncompressed length of indexformatng (2 gigs, 4-byte
 # signed integer)
-_maxentrysize = 0x7fffffff
+_maxentrysize = 0x7FFFFFFF
+
 
 class revlogio(object):
     def __init__(self):
@@ -264,6 +293,7 @@
             p = versionformat_pack(version) + p[4:]
         return p
 
+
 class revlog(object):
     """
     the underlying revision storage object
@@ -304,9 +334,16 @@
 
     _flagserrorclass = error.RevlogError
 
-    def __init__(self, opener, indexfile, datafile=None, checkambig=False,
-                 mmaplargeindex=False, censorable=False,
-                 upperboundcomp=None):
+    def __init__(
+        self,
+        opener,
+        indexfile,
+        datafile=None,
+        checkambig=False,
+        mmaplargeindex=False,
+        censorable=False,
+        upperboundcomp=None,
+    ):
         """
         create a revlog object
 
@@ -410,18 +447,24 @@
             flagutil.insertflagprocessor(flag, processor, self._flagprocessors)
 
         if self._chunkcachesize <= 0:
-            raise error.RevlogError(_('revlog chunk cache size %r is not '
-                                      'greater than 0') % self._chunkcachesize)
+            raise error.RevlogError(
+                _('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 '
-                                      'power of 2') % self._chunkcachesize)
+            raise error.RevlogError(
+                _('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
-                    self.opener.fstat(f).st_size >= mmapindexthreshold):
+                if (
+                    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))
@@ -445,35 +488,39 @@
 
         if fmt == REVLOGV0:
             if flags:
-                raise error.RevlogError(_('unknown flags (%#04x) in version %d '
-                                          'revlog %s') %
-                                        (flags >> 16, fmt, self.indexfile))
+                raise error.RevlogError(
+                    _('unknown flags (%#04x) in version %d ' 'revlog %s')
+                    % (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 '
-                                          'revlog %s') %
-                                        (flags >> 16, fmt, self.indexfile))
+                raise error.RevlogError(
+                    _('unknown flags (%#04x) in version %d ' 'revlog %s')
+                    % (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 '
-                                          'revlog %s') %
-                                        (flags >> 16, fmt, self.indexfile))
+                raise error.RevlogError(
+                    _('unknown flags (%#04x) in version %d ' 'revlog %s')
+                    % (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') %
-                                    (fmt, self.indexfile))
+            raise error.RevlogError(
+                _('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
@@ -486,8 +533,7 @@
         try:
             d = self._io.parseindex(indexdata, self._inline)
         except (ValueError, IndexError):
-            raise error.RevlogError(_("index %s is corrupted") %
-                                    self.indexfile)
+            raise error.RevlogError(_("index %s is corrupted") % self.indexfile)
         self.index, nodemap, self._chunkcache = d
         if nodemap is not None:
             self.nodemap = self._nodecache = nodemap
@@ -544,12 +590,16 @@
 
     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)
@@ -576,8 +626,9 @@
         # 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)
-            or (self.flags(rev) & REVIDX_RAWTEXT_CHANGING_FLAGS)):
+        if (self.flags(baserev) & REVIDX_RAWTEXT_CHANGING_FLAGS) or (
+            self.flags(rev) & REVIDX_RAWTEXT_CHANGING_FLAGS
+        ):
             return False
         return True
 
@@ -704,7 +755,7 @@
     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]
@@ -966,7 +1017,7 @@
                 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!
@@ -1005,11 +1056,12 @@
                     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
-                                           p != nullid])
-                    elif n in heads: # We've seen it before, is it a fake head?
+                        nodestotag.update(
+                            [p for p in self.parents(n) if p != nullid]
+                        )
+                    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)
@@ -1139,8 +1191,9 @@
 
         stoprevs = set(self.rev(n) for n in stop or [])
 
-        revs = dagop.headrevssubset(self.revs, self.parentrevs, startrev=start,
-                                    stoprevs=stoprevs)
+        revs = dagop.headrevssubset(
+            self.revs, self.parentrevs, startrev=start, stoprevs=stoprevs
+        )
 
         return [self.node(rev) for rev in revs]
 
@@ -1168,7 +1221,7 @@
         """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
 
@@ -1199,11 +1252,13 @@
 
         If includepath is True, return (<roots>::<heads>)."""
         try:
-            return self.index.reachableroots2(minroot, heads, roots,
-                                              includepath)
+            return self.index.reachableroots2(
+                minroot, heads, roots, includepath
+            )
         except AttributeError:
-            return dagop._reachablerootspure(self.parentrevs,
-                                             minroot, roots, heads, includepath)
+            return dagop._reachablerootspure(
+                self.parentrevs, minroot, roots, heads, includepath
+            )
 
     def ancestor(self, a, b):
         """calculate the "best" common ancestor of nodes a and b"""
@@ -1227,10 +1282,10 @@
             # 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)
@@ -1271,7 +1326,8 @@
             # 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
@@ -1284,10 +1340,11 @@
             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
-                      self.hasnode(n)]
+                nl = [
+                    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:
@@ -1295,7 +1352,8 @@
                         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
@@ -1318,6 +1376,7 @@
 
     def shortest(self, node, minlength=1):
         """Find the shortest unambiguous prefix that matches node."""
+
         def isvalid(prefix):
             try:
                 matchednode = self._partialmatch(prefix)
@@ -1402,8 +1461,9 @@
         # involving reading the revlog backwards.
         cachesize = self._chunkcachesize
         realoffset = offset & ~(cachesize - 1)
-        reallength = (((offset + length + cachesize) & ~(cachesize - 1))
-                      - realoffset)
+        reallength = (
+            (offset + length + cachesize) & ~(cachesize - 1)
+        ) - realoffset
         with self._datareadfp(df) as df:
             df.seek(realoffset)
             d = df.read(reallength)
@@ -1413,19 +1473,33 @@
             startoffset = offset - realoffset
             if len(d) - startoffset < length:
                 raise error.RevlogError(
-                    _('partial read of revlog %s; expected %d bytes from '
-                      'offset %d, got %d') %
-                    (self.indexfile if self._inline else self.datafile,
-                     length, realoffset, len(d) - startoffset))
+                    _(
+                        'partial read of revlog %s; expected %d bytes from '
+                        'offset %d, got %d'
+                    )
+                    % (
+                        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') %
-                (self.indexfile if self._inline else self.datafile,
-                 length, offset, len(d)))
+                _(
+                    'partial read of revlog %s; expected %d bytes from offset '
+                    '%d, got %d'
+                )
+                % (
+                    self.indexfile if self._inline else self.datafile,
+                    length,
+                    offset,
+                    len(d),
+                )
+            )
 
         return d
 
@@ -1448,7 +1522,7 @@
         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)
@@ -1525,8 +1599,9 @@
         if not self._withsparseread:
             slicedchunks = (revs,)
         else:
-            slicedchunks = deltautil.slicechunk(self, revs,
-                                                targetsize=targetsize)
+            slicedchunks = deltautil.slicechunk(
+                self, revs, targetsize=targetsize
+            )
 
         for revschunk in slicedchunks:
             firstrev = revschunk[0]
@@ -1604,18 +1679,17 @@
         if rev1 != nullrev and self.deltaparent(rev2) == rev1:
             return bytes(self._chunk(rev2))
 
-        return mdiff.textdiff(self.rawdata(rev1),
-                              self.rawdata(rev2))
+        return mdiff.textdiff(self.rawdata(rev1), 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):
@@ -1628,8 +1702,10 @@
         to True when generating changegroups or in debug commands.
         """
         if raw:
-            msg = ('revlog.revision(..., raw=True) is deprecated, '
-                   'use revlog.rawdata(...)')
+            msg = (
+                'revlog.revision(..., raw=True) is deprecated, '
+                'use revlog.rawdata(...)'
+            )
             util.nouideprecwarn(msg, '5.2', stacklevel=2)
         return self._revisiondata(nodeorrev, _df, raw=raw)[0]
 
@@ -1684,8 +1760,7 @@
                 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),
-                        exc.sidedatakey)
+                msg %= (self.indexfile, pycompat.bytestr(rev), exc.sidedatakey)
                 raise error.RevlogError(msg)
             text, validatehash, sidedata = r
         if validatehash:
@@ -1735,7 +1810,7 @@
             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):
@@ -1775,8 +1850,10 @@
                 revornode = rev
                 if revornode is None:
                     revornode = templatefilters.short(hex(node))
-                raise error.RevlogError(_("integrity check failed on %s:%s")
-                    % (self.indexfile, pycompat.bytestr(revornode)))
+                raise error.RevlogError(
+                    _("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)
@@ -1790,14 +1867,17 @@
         to use multiple index and data files.
         """
         tiprev = len(self) - 1
-        if (not self._inline or
-            (self.start(tiprev) + self.length(tiprev)) < _maxinline):
+        if (
+            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")
-                                    % self.indexfile)
+            raise error.RevlogError(
+                _("%s not found in the transaction") % self.indexfile
+            )
 
         trindex = trinfo[2]
         if trindex is not None:
@@ -1838,9 +1918,19 @@
         """called when trying to add a node already stored.
         """
 
-    def addrevision(self, text, transaction, link, p1, p2, cachedelta=None,
-                    node=None, flags=REVIDX_DEFAULT_FLAGS, deltacomputer=None,
-                    sidedata=None):
+    def addrevision(
+        self,
+        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
@@ -1856,8 +1946,9 @@
             multiple calls
         """
         if link == nullrev:
-            raise error.RevlogError(_("attempted to add linkrev -1 to %s")
-                                    % self.indexfile)
+            raise error.RevlogError(
+                _("attempted to add linkrev -1 to %s") % self.indexfile
+            )
 
         if sidedata is None:
             sidedata = {}
@@ -1865,15 +1956,16 @@
         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,
-                                                           sidedata=sidedata)
+        rawtext, validatehash = flagutil.processflagswrite(
+            self, text, flags, sidedata=sidedata
+        )
 
         # If the flag processor modifies the revision data, ignore any provided
         # cachedelta.
@@ -1883,7 +1975,8 @@
         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:
@@ -1892,12 +1985,30 @@
         if validatehash:
             self.checkhash(rawtext, node, p1=p1, p2=p2)
 
-        return self.addrawrevision(rawtext, transaction, link, p1, p2, node,
-                                   flags, cachedelta=cachedelta,
-                                   deltacomputer=deltacomputer)
-
-    def addrawrevision(self, rawtext, transaction, link, p1, p2, node, flags,
-                       cachedelta=None, deltacomputer=None):
+        return self.addrawrevision(
+            rawtext,
+            transaction,
+            link,
+            p1,
+            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).
@@ -1907,9 +2018,19 @@
             dfh = self._datafp("a+")
         ifh = self._indexfp("a+")
         try:
-            return self._addrevision(node, rawtext, transaction, link, p1, p2,
-                                     flags, cachedelta, ifh, dfh,
-                                     deltacomputer=deltacomputer)
+            return self._addrevision(
+                node,
+                rawtext,
+                transaction,
+                link,
+                p1,
+                p2,
+                flags,
+                cachedelta,
+                ifh,
+                dfh,
+                deltacomputer=deltacomputer,
+            )
         finally:
             if dfh:
                 dfh.close()
@@ -1966,8 +2087,10 @@
             try:
                 return _zlibdecompress(data)
             except zlib.error as e:
-                raise error.RevlogError(_('revlog decompress error: %s') %
-                                        stringutil.forcebytestr(e))
+                raise error.RevlogError(
+                    _('revlog decompress error: %s')
+                    % stringutil.forcebytestr(e)
+                )
         # '\0' is more common than 'u' so it goes first.
         elif t == '\0':
             return data
@@ -1986,9 +2109,21 @@
 
         return compressor.decompress(data)
 
-    def _addrevision(self, node, rawtext, transaction, link, p1, p2, flags,
-                     cachedelta, ifh, dfh, alwayscache=False,
-                     deltacomputer=None):
+    def _addrevision(
+        self,
+        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.
@@ -2003,11 +2138,13 @@
           if both are set, they must correspond to each other.
         """
         if node == nullid:
-            raise error.RevlogError(_("%s: attempt to add null revision") %
-                                    self.indexfile)
+            raise error.RevlogError(
+                _("%s: attempt to add null revision") % self.indexfile
+            )
         if node == wdirid or node in wdirfilenodeids:
-            raise error.RevlogError(_("%s: attempt to add wdir revision") %
-                                    self.indexfile)
+            raise error.RevlogError(
+                _("%s: attempt to add wdir revision") % self.indexfile
+            )
 
         if self._inline:
             fh = ifh
@@ -2027,8 +2164,9 @@
             # 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]),
-                                        cachedelta[1])
+            textlen = mdiff.patchedsize(
+                revlog.size(self, cachedelta[0]), cachedelta[1]
+            )
         else:
             textlen = len(rawtext)
 
@@ -2039,8 +2177,16 @@
 
         deltainfo = deltacomputer.finddeltainfo(revinfo, fh)
 
-        e = (offset_type(offset, flags), deltainfo.deltalen, textlen,
-             deltainfo.base, link, p1r, p2r, node)
+        e = (
+            offset_type(offset, flags),
+            deltainfo.deltalen,
+            textlen,
+            deltainfo.base,
+            link,
+            p1r,
+            p2r,
+            node,
+        )
         self.index.append(e)
         self.nodemap[node] = curr
 
@@ -2050,15 +2196,16 @@
             self._nodepos = curr
 
         entry = self._io.packentry(e, self.node, self.version, curr)
-        self._writeentry(transaction, ifh, dfh, entry, deltainfo.data,
-                         link, offset)
+        self._writeentry(
+            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
@@ -2126,6 +2273,7 @@
             transaction.add(self.indexfile, isize, r)
             transaction.add(self.datafile, end)
             dfh = self._datafp("a+")
+
         def flush():
             if dfh:
                 dfh.flush()
@@ -2150,12 +2298,14 @@
 
                 for p in (p1, p2):
                     if p not in self.nodemap:
-                        raise error.LookupError(p, self.indexfile,
-                                                _('unknown parent'))
+                        raise error.LookupError(
+                            p, self.indexfile, _('unknown parent')
+                        )
 
                 if deltabase not in self.nodemap:
-                    raise error.LookupError(deltabase, self.indexfile,
-                                            _('unknown delta base'))
+                    raise error.LookupError(
+                        deltabase, self.indexfile, _('unknown delta base')
+                    )
 
                 baserev = self.rev(deltabase)
 
@@ -2166,8 +2316,9 @@
                     oldlen = self.rawsize(baserev)
                     newlen = len(delta) - hlen
                     if delta[:hlen] != mdiff.replacediffheader(oldlen, newlen):
-                        raise error.CensoredBaseError(self.indexfile,
-                                                      self.node(baserev))
+                        raise error.CensoredBaseError(
+                            self.indexfile, self.node(baserev)
+                        )
 
                 if not flags and self._peek_iscensored(baserev, delta, flush):
                     flags |= REVIDX_ISCENSORED
@@ -2179,11 +2330,20 @@
                 # 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,
-                                  p1, p2, flags, (baserev, delta),
-                                  ifh, dfh,
-                                  alwayscache=bool(addrevisioncb),
-                                  deltacomputer=deltacomputer)
+                self._addrevision(
+                    node,
+                    None,
+                    transaction,
+                    link,
+                    p1,
+                    p2,
+                    flags,
+                    (baserev, delta),
+                    ifh,
+                    dfh,
+                    alwayscache=bool(addrevisioncb),
+                    deltacomputer=deltacomputer,
+                )
 
                 if addrevisioncb:
                     addrevisioncb(self, node)
@@ -2224,9 +2384,13 @@
         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,
-                                            self.headrevs(),
-                                            self.linkrev, self.parentrevs)
+        return storageutil.resolvestripinfo(
+            minlink,
+            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
@@ -2319,22 +2483,33 @@
             res.append(self.datafile)
         return res
 
-    def emitrevisions(self, nodes, nodesorder=None, revisiondata=False,
-                      assumehaveparentrevisions=False,
-                      deltamode=repository.CG_DELTAMODE_STD):
+    def emitrevisions(
+        self,
+        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' %
-                                         nodesorder)
+            raise error.ProgrammingError(
+                'unhandled value for nodesorder: %s' % nodesorder
+            )
 
         if nodesorder is None and not self._generaldelta:
             nodesorder = 'storage'
 
-        if (not self._storedeltachains and
-                deltamode != repository.CG_DELTAMODE_PREV):
+        if (
+            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,
@@ -2342,7 +2517,8 @@
             flagsfn=self.flags,
             deltamode=deltamode,
             revisiondata=revisiondata,
-            assumehaveparentrevisions=assumehaveparentrevisions)
+            assumehaveparentrevisions=assumehaveparentrevisions,
+        )
 
     DELTAREUSEALWAYS = 'always'
     DELTAREUSESAMEREVS = 'samerevs'
@@ -2352,8 +2528,14 @@
 
     DELTAREUSEALL = {'always', 'samerevs', 'never', 'fulladd'}
 
-    def clone(self, tr, destrevlog, addrevisioncb=None,
-            deltareuse=DELTAREUSESAMEREVS, forcedeltabothparents=None):
+    def clone(
+        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.
@@ -2425,16 +2607,18 @@
 
             destrevlog._deltabothparents = forcedeltabothparents or oldamd
 
-            self._clone(tr, destrevlog, addrevisioncb, deltareuse,
-                        forcedeltabothparents)
+            self._clone(
+                tr, destrevlog, addrevisioncb, deltareuse, forcedeltabothparents
+            )
 
         finally:
             destrevlog._lazydelta = oldlazydelta
             destrevlog._lazydeltabase = oldlazydeltabase
             destrevlog._deltabothparents = oldamd
 
-    def _clone(self, tr, destrevlog, addrevisioncb, deltareuse,
-               forcedeltabothparents):
+    def _clone(
+        self, tr, destrevlog, addrevisioncb, deltareuse, forcedeltabothparents
+    ):
         """perform the core duty of `revlog.clone` after parameter processing"""
         deltacomputer = deltautil.deltacomputer(destrevlog)
         index = self.index
@@ -2443,7 +2627,7 @@
 
             # 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]
@@ -2455,10 +2639,17 @@
             rawtext = None
             if deltareuse == self.DELTAREUSEFULLADD:
                 text = self.revision(rev)
-                destrevlog.addrevision(text, tr, linkrev, p1, p2,
-                                       cachedelta=cachedelta,
-                                       node=node, flags=flags,
-                                       deltacomputer=deltacomputer)
+                destrevlog.addrevision(
+                    text,
+                    tr,
+                    linkrev,
+                    p1,
+                    p2,
+                    cachedelta=cachedelta,
+                    node=node,
+                    flags=flags,
+                    deltacomputer=deltacomputer,
+                )
             else:
                 if destrevlog._lazydelta:
                     dp = self.deltaparent(rev)
@@ -2468,15 +2659,26 @@
                 if not cachedelta:
                     rawtext = self.rawdata(rev)
 
-                ifh = destrevlog.opener(destrevlog.indexfile, 'a+',
-                                        checkambig=False)
+                ifh = destrevlog.opener(
+                    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,
-                                            p2, flags, cachedelta, ifh, dfh,
-                                            deltacomputer=deltacomputer)
+                    destrevlog._addrevision(
+                        node,
+                        rawtext,
+                        tr,
+                        linkrev,
+                        p1,
+                        p2,
+                        flags,
+                        cachedelta,
+                        ifh,
+                        dfh,
+                        deltacomputer=deltacomputer,
+                    )
                 finally:
                     if dfh:
                         dfh.close()
@@ -2487,15 +2689,17 @@
 
     def censorrevision(self, tr, censornode, tombstone=b''):
         if (self.version & 0xFFFF) == REVLOGV0:
-            raise error.RevlogError(_('cannot censor with version %d revlogs') %
-                                    self.version)
+            raise error.RevlogError(
+                _('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 '
-                                'censored data'))
+            raise error.Abort(
+                _('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
@@ -2505,8 +2709,7 @@
         newdatafile = self.datafile + b'.tmpcensored'
 
         # This is a bit dangerous. We could easily have a mismatch of state.
-        newrl = revlog(self.opener, newindexfile, newdatafile,
-                       censorable=True)
+        newrl = revlog(self.opener, newindexfile, newdatafile, censorable=True)
         newrl.version = self.version
         newrl._generaldelta = self._generaldelta
         newrl._io = self._io
@@ -2516,27 +2719,45 @@
             p1, p2 = self.parents(node)
 
             if rev == censorrev:
-                newrl.addrawrevision(tombstone, tr, self.linkrev(censorrev),
-                                     p1, p2, censornode, REVIDX_ISCENSORED)
+                newrl.addrawrevision(
+                    tombstone,
+                    tr,
+                    self.linkrev(censorrev),
+                    p1,
+                    p2,
+                    censornode,
+                    REVIDX_ISCENSORED,
+                )
 
                 if newrl.deltaparent(rev) != nullrev:
-                    raise error.Abort(_('censored revision stored as delta; '
-                                        'cannot censor'),
-                                      hint=_('censoring of revlogs is not '
-                                             'fully implemented; please report '
-                                             'this bug'))
+                    raise error.Abort(
+                        _(
+                            'censored revision stored as delta; '
+                            'cannot censor'
+                        ),
+                        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 '
-                                        'revision having delta stored'))
+                    raise error.Abort(
+                        _(
+                            '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,
-                                 self.flags(rev))
+            newrl.addrawrevision(
+                rawtext, tr, self.linkrev(rev), p1, p2, node, self.flags(rev)
+            )
 
         tr.addbackup(self.indexfile, location='store')
         if not self._inline:
@@ -2566,8 +2787,9 @@
         # 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") %
-                        (self.indexfile, version, state['expectedversion']))
+                warning=_("warning: '%s' uses revlog format %d; expected %d")
+                % (self.indexfile, version, state['expectedversion'])
+            )
 
         state['skipread'] = set()
 
@@ -2639,23 +2861,31 @@
                 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'),
-                                        node=node)
+                    yield revlogproblem(
+                        error=_('censored file data'), node=node
+                    )
                     state['skipread'].add(node)
             except Exception as e:
                 yield revlogproblem(
-                    error=_('unpacking %s: %s') % (short(node),
-                                                   stringutil.forcebytestr(e)),
-                    node=node)
+                    error=_('unpacking %s: %s')
+                    % (short(node), stringutil.forcebytestr(e)),
+                    node=node,
+                )
                 state['skipread'].add(node)
 
-    def storageinfo(self, exclusivefiles=False, sharedfiles=False,
-                    revisionscount=False, trackedsize=False,
-                    storedsize=False):
+    def storageinfo(
+        self,
+        exclusivefiles=False,
+        sharedfiles=False,
+        revisionscount=False,
+        trackedsize=False,
+        storedsize=False,
+    ):
         d = {}
 
         if exclusivefiles:
@@ -2673,7 +2903,8 @@
             d['trackedsize'] = sum(map(self.rawsize, iter(self)))
 
         if storedsize:
-            d['storedsize'] = sum(self.opener.stat(path).st_size
-                                  for path in self.files())
+            d['storedsize'] = sum(
+                self.opener.stat(path).st_size for path in self.files()
+            )
 
         return d