mercurial: comparison mercurial/debugcommands.py

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 dateutil,
 procutil,
 stringutil,
 )
-from .revlogutils import (
+from .revlogutils import deltas as deltautil
-deltas as deltautil
-)
 release = lockmod.release
 command = registrar.command()
 @command('debugancestor', [], _('[INDEX] REV1 REV2'), optionalrepo=True)
 def debugancestor(ui, repo, *args):
 """find the ancestor revision of two revisions in a given index"""
 if len(args) == 3:
 index, rev1, rev2 = args
 r = revlog.revlog(vfsmod.vfs(encoding.getcwd(), audit=False), index)
 lookup = r.lookup
 elif len(args) == 2:
 if not repo:
-raise error.Abort(_('there is no Mercurial repository here '
+raise error.Abort(
-'(.hg not found)'))
+_('there is no Mercurial repository here ' '(.hg not found)')
+)
 rev1, rev2 = args
 r = repo.changelog
 lookup = repo.lookup
 else:
 raise error.Abort(_('either two or three arguments required'))
 a = r.ancestor(lookup(rev1), lookup(rev2))
 ui.write('%d:%s\n' % (r.rev(a), hex(a)))
 @command('debugapplystreamclonebundle', [], 'FILE')
 def debugapplystreamclonebundle(ui, repo, fname):
 """apply a stream clone bundle file"""
 f = hg.openpath(ui, fname)
 gen = exchange.readbundle(ui, f, fname)
 gen.apply(repo)
-@command('debugbuilddag',
-[('m', 'mergeable-file', None, _('add single file mergeable changes')),
+@command(
-('o', 'overwritten-file', None, _('add single file all revs overwrite')),
+'debugbuilddag',
-('n', 'new-file', None, _('add new file at each rev'))],
+[
-_('[OPTION]... [TEXT]'))
+('m', 'mergeable-file', None, _('add single file mergeable changes')),
-def debugbuilddag(ui, repo, text=None,
+(
-mergeable_file=False,
+'o',
-overwritten_file=False,
+'overwritten-file',
-new_file=False):
+None,
+_('add single file all revs overwrite'),
+),
+('n', 'new-file', None, _('add new file at each rev')),
+],
+_('[OPTION]... [TEXT]'),
+)
+def debugbuilddag(
+ui,
+repo,
+text=None,
+mergeable_file=False,
+overwritten_file=False,
+new_file=False,
+):
 """builds a repo with a given DAG from scratch in the current empty repo
 The description of the DAG is read from stdin if not given on the
 command line.
 total += 1
 if mergeable_file:
 linesperrev = 2
 # make a file with k lines per rev
-initialmergedlines = ['%d' % i
+initialmergedlines = [
-for i in pycompat.xrange(0, total * linesperrev)]
+'%d' % i for i in pycompat.xrange(0, total * linesperrev)
+]
 initialmergedlines.append("")
 tags = []
-progress = ui.makeprogress(_('building'), unit=_('revisions'),
+progress = ui.makeprogress(_('building'), unit=_('revisions'), total=total)
-total=total)
 with progress, repo.wlock(), repo.lock(), repo.transaction("builddag"):
 at = -1
 atbranch = 'default'
 nodeids = []
 id = 0
 fn = "mf"
 p1 = repo[ps[0]]
 if len(ps) > 1:
 p2 = repo[ps[1]]
 pa = p1.ancestor(p2)
-base, local, other = [x[fn].data() for x in (pa, p1,
+base, local, other = [
-p2)]
+x[fn].data() for x in (pa, p1, p2)
+]
 m3 = simplemerge.Merge3Text(base, local, other)
 ml = [l.strip() for l in m3.merge_lines()]
 ml.append("")
 elif at > 0:
 ml = p1[fn].data().split("\n")
 files.append(fn)
 filecontent[fn] = p2[fn].data()
 def fctxfn(repo, cx, path):
 if path in filecontent:
-return context.memfilectx(repo, cx, path,
+return context.memfilectx(
-filecontent[path])
+repo, cx, path, filecontent[path]
+)
 return None
 if len(ps) == 0 or ps[0] < 0:
 pars = [None, None]
 elif len(ps) == 1:
 pars = [nodeids[ps[0]], None]
 else:
 pars = [nodeids[p] for p in ps]
-cx = context.memctx(repo, pars, "r%i" % id, files, fctxfn,
+cx = context.memctx(
-date=(id, 0),
+repo,
-user="debugbuilddag",
+pars,
-extra={'branch': atbranch})
+"r%i" % id,
+files,
+fctxfn,
+date=(id, 0),
+user="debugbuilddag",
+extra={'branch': atbranch},
+)
 nodeid = repo.commitctx(cx)
 nodeids.append(nodeid)
 at = id
 elif type == 'l':
 id, name = data
 progress.update(id)
 if tags:
 repo.vfs.write("localtags", "".join(tags))
 def _debugchangegroup(ui, gen, all=None, indent=0, **opts):
 indent_string = ' ' * indent
 if all:
-ui.write(("%sformat: id, p1, p2, cset, delta base, len(delta)\n")
+ui.write(
-% indent_string)
+"%sformat: id, p1, p2, cset, delta base, len(delta)\n"
+% indent_string
+)
 def showchunks(named):
 ui.write("\n%s%s\n" % (indent_string, named))
 for deltadata in gen.deltaiter():
 node, p1, p2, cs, deltabase, delta, flags = deltadata
-ui.write("%s%s %s %s %s %s %d\n" %
+ui.write(
-(indent_string, hex(node), hex(p1), hex(p2),
+"%s%s %s %s %s %s %d\n"
-hex(cs), hex(deltabase), len(delta)))
+% (
+indent_string,
+hex(node),
+hex(p1),
+hex(p2),
+hex(cs),
+hex(deltabase),
+len(delta),
+)
+)
 chunkdata = gen.changelogheader()
 showchunks("changelog")
 chunkdata = gen.manifestheader()
 showchunks("manifest")
 raise error.Abort(_('use debugbundle2 for this file'))
 chunkdata = gen.changelogheader()
 for deltadata in gen.deltaiter():
 node, p1, p2, cs, deltabase, delta, flags = deltadata
 ui.write("%s%s\n" % (indent_string, hex(node)))
 def _debugobsmarkers(ui, part, indent=0, **opts):
 """display version and markers contained in 'data'"""
 opts = pycompat.byteskwargs(opts)
 data = part.read()
 fm.startitem()
 fm.plain(indent_string)
 cmdutil.showmarker(fm, m)
 fm.end()
 def _debugphaseheads(ui, data, indent=0):
 """display version and markers contained in 'data'"""
 indent_string = ' ' * indent
 headsbyphase = phases.binarydecode(data)
 for phase in phases.allphases:
 for head in headsbyphase[phase]:
 ui.write(indent_string)
 ui.write('%s %s\n' % (hex(head), phases.phasenames[phase]))
 def _quasirepr(thing):
 if isinstance(thing, (dict, util.sortdict, collections.OrderedDict)):
 return '{%s}' % (
-b', '.join(b'%s: %s' % (k, thing[k]) for k in sorted(thing)))
+b', '.join(b'%s: %s' % (k, thing[k]) for k in sorted(thing))
+)
 return pycompat.bytestr(repr(thing))
 def _debugbundle2(ui, gen, all=None, **opts):
 """lists the contents of a bundle2"""
 if not isinstance(gen, bundle2.unbundle20):
 raise error.Abort(_('not a bundle2 file'))
 _debugobsmarkers(ui, part, indent=4, **opts)
 if part.type == 'phase-heads':
 if not ui.quiet:
 _debugphaseheads(ui, part, indent=4)
-@command('debugbundle',
-[('a', 'all', None, _('show all details')),
+@command(
-('', 'part-type', [], _('show only the named part type')),
+'debugbundle',
-('', 'spec', None, _('print the bundlespec of the bundle'))],
+[
-_('FILE'),
+('a', 'all', None, _('show all details')),
-norepo=True)
+('', 'part-type', [], _('show only the named part type')),
+('', 'spec', None, _('print the bundlespec of the bundle')),
+],
+_('FILE'),
+norepo=True,
+)
 def debugbundle(ui, bundlepath, all=None, spec=None, **opts):
 """lists the contents of a bundle"""
 with hg.openpath(ui, bundlepath) as f:
 if spec:
 spec = exchange.getbundlespec(ui, f)
 gen = exchange.readbundle(ui, f, bundlepath)
 if isinstance(gen, bundle2.unbundle20):
 return _debugbundle2(ui, gen, all=all, **opts)
 _debugchangegroup(ui, gen, all=all, **opts)
-@command('debugcapabilities',
-[], _('PATH'),
+@command('debugcapabilities', [], _('PATH'), norepo=True)
-norepo=True)
 def debugcapabilities(ui, path, **opts):
 """lists the capabilities of a remote peer"""
 opts = pycompat.byteskwargs(opts)
 peer = hg.peer(ui, opts, path)
 caps = peer.capabilities()
-ui.write(('Main capabilities:\n'))
+ui.write('Main capabilities:\n')
 for c in sorted(caps):
-ui.write(('  %s\n') % c)
+ui.write('  %s\n' % c)
 b2caps = bundle2.bundle2caps(peer)
 if b2caps:
-ui.write(('Bundle2 capabilities:\n'))
+ui.write('Bundle2 capabilities:\n')
 for key, values in sorted(b2caps.iteritems()):
-ui.write(('  %s\n') % key)
+ui.write('  %s\n' % key)
 for v in values:
-ui.write(('    %s\n') % v)
+ui.write('    %s\n' % v)
 @command('debugcheckstate', [], '')
 def debugcheckstate(ui, repo):
 """validate the correctness of the current dirstate"""
 parent1, parent2 = repo.dirstate.parents()
 errors += 1
 if state in "a" and f in m1:
 ui.warn(_("%s in state %s, but also in manifest1\n") % (f, state))
 errors += 1
 if state in "m" and f not in m1 and f not in m2:
-ui.warn(_("%s in state %s, but not in either manifest\n") %
+ui.warn(
-(f, state))
+_("%s in state %s, but not in either manifest\n") % (f, state)
+)
 errors += 1
 for f in m1:
 state = repo.dirstate[f]
 if state not in "nrm":
 ui.warn(_("%s in manifest1, but listed as state %s") % (f, state))
 errors += 1
 if errors:
 error = _(".hg/dirstate inconsistent with current parent's manifest")
 raise error.Abort(error)
-@command('debugcolor',
-[('', 'style', None, _('show all configured styles'))],
+@command(
-'hg debugcolor')
+'debugcolor',
+[('', 'style', None, _('show all configured styles'))],
+'hg debugcolor',
+)
 def debugcolor(ui, repo, **opts):
 """show available color, effects or style"""
-ui.write(('color mode: %s\n') % stringutil.pprint(ui._colormode))
+ui.write('color mode: %s\n' % stringutil.pprint(ui._colormode))
 if opts.get(r'style'):
 return _debugdisplaystyle(ui)
 else:
 return _debugdisplaycolor(ui)
 def _debugdisplaycolor(ui):
 ui = ui.copy()
 ui._styles.clear()
 for effect in color._activeeffects(ui).keys():
 ui._styles[k] = k[6:]
 elif k.startswith('terminfo.'):
 ui._styles[k] = k[9:]
 ui.write(_('available colors:\n'))
 # sort label with a '_' after the other to group '_background' entry.
-items = sorted(ui._styles.items(),
+items = sorted(ui._styles.items(), key=lambda i: ('_' in i[0], i[0], i[1]))
-key=lambda i: ('_' in i[0], i[0], i[1]))
 for colorname, label in items:
-ui.write(('%s\n') % colorname, label=label)
+ui.write('%s\n' % colorname, label=label)
 def _debugdisplaystyle(ui):
 ui.write(_('available style:\n'))
 if not ui._styles:
 return
 ui.write(': ')
 ui.write(' ' * (max(0, width - len(label))))
 ui.write(', '.join(ui.label(e, e) for e in effects.split()))
 ui.write('\n')
 @command('debugcreatestreamclonebundle', [], 'FILE')
 def debugcreatestreamclonebundle(ui, repo, fname):
 """create a stream clone bundle file
 Stream bundles are special bundles that are essentially archives of
 revlog files. They are commonly used for cloning very quickly.
 """
 # TODO we may want to turn this into an abort when this functionality
 # is moved into `hg bundle`.
 if phases.hassecret(repo):
-ui.warn(_('(warning: stream clone bundle will contain secret '
+ui.warn(
-'revisions)\n'))
+_(
+'(warning: stream clone bundle will contain secret '
+'revisions)\n'
+)
+)
 requirements, gen = streamclone.generatebundlev1(repo)
 changegroup.writechunks(ui, gen, fname)
 ui.write(_('bundle requirements: %s\n') % ', '.join(sorted(requirements)))
-@command('debugdag',
-[('t', 'tags', None, _('use tags as labels')),
+@command(
-('b', 'branches', None, _('annotate with branch names')),
+'debugdag',
-('', 'dots', None, _('use dots for runs')),
+[
-('s', 'spaces', None, _('separate elements by spaces'))],
+('t', 'tags', None, _('use tags as labels')),
+('b', 'branches', None, _('annotate with branch names')),
+('', 'dots', None, _('use dots for runs')),
+('s', 'spaces', None, _('separate elements by spaces')),
+],
 _('[OPTION]... [FILE [REV]...]'),
-optionalrepo=True)
+optionalrepo=True,
+)
 def debugdag(ui, repo, file_=None, *revs, **opts):
 """format the changelog or an index DAG as a concise textual description
 If you pass a revlog index, the revlog's DAG is emitted. If you list
 revision numbers, they get labeled in the output as rN.
 Otherwise, the changelog DAG of the current repo is emitted.
 """
 spaces = opts.get(r'spaces')
 dots = opts.get(r'dots')
 if file_:
-rlog = revlog.revlog(vfsmod.vfs(encoding.getcwd(), audit=False),
+rlog = revlog.revlog(vfsmod.vfs(encoding.getcwd(), audit=False), file_)
-file_)
 revs = set((int(r) for r in revs))
 def events():
 for r in rlog:
-yield 'n', (r, list(p for p in rlog.parentrevs(r)
+yield 'n', (r, list(p for p in rlog.parentrevs(r) if p != -1))
-if p != -1))
 if r in revs:
 yield 'l', (r, "r%i" % r)
 elif repo:
 cl = repo.changelog
 tags = opts.get(r'tags')
 branches = opts.get(r'branches')
 if tags:
 labels = {}
 for l, n in repo.tags().items():
 labels.setdefault(cl.rev(n), []).append(l)
 def events():
 b = "default"
 for r in cl:
 if branches:
 newb = cl.read(cl.node(r))[5]['branch']
 if newb != b:
 yield 'a', newb
 b = newb
-yield 'n', (r, list(p for p in cl.parentrevs(r)
+yield 'n', (r, list(p for p in cl.parentrevs(r) if p != -1))
-if p != -1))
 if tags:
 ls = labels.get(r)
 if ls:
 for l in ls:
 yield 'l', (r, l)
 else:
 raise error.Abort(_('need repo for changelog dag'))
-for line in dagparser.dagtextlines(events(),
+for line in dagparser.dagtextlines(
-addspaces=spaces,
+events(),
-wraplabels=True,
+addspaces=spaces,
-wrapannotations=True,
+wraplabels=True,
-wrapnonlinear=dots,
+wrapannotations=True,
-usedots=dots,
+wrapnonlinear=dots,
-maxlinewidth=70):
+usedots=dots,
+maxlinewidth=70,
+):
 ui.write(line)
 ui.write("\n")
 @command('debugdata', cmdutil.debugrevlogopts, _('-c|-m|FILE REV'))
 def debugdata(ui, repo, file_, rev=None, **opts):
 """dump the contents of a data file revision"""
 opts = pycompat.byteskwargs(opts)
 try:
 ui.write(r.rawdata(r.lookup(rev)))
 except KeyError:
 raise error.Abort(_('invalid revision identifier %s') % rev)
-@command('debugdate',
+@command(
+'debugdate',
 [('e', 'extended', None, _('try extended date formats'))],
 _('[-e] DATE [RANGE]'),
-norepo=True, optionalrepo=True)
+norepo=True,
+optionalrepo=True,
+)
 def debugdate(ui, date, range=None, **opts):
 """parse and display a date"""
 if opts[r"extended"]:
 d = dateutil.parsedate(date, util.extendeddateformats)
 else:
 d = dateutil.parsedate(date)
-ui.write(("internal: %d %d\n") % d)
+ui.write("internal: %d %d\n" % d)
-ui.write(("standard: %s\n") % dateutil.datestr(d))
+ui.write("standard: %s\n" % dateutil.datestr(d))
 if range:
 m = dateutil.matchdate(range)
-ui.write(("match: %s\n") % m(d[0]))
+ui.write("match: %s\n" % m(d[0]))
-@command('debugdeltachain',
+@command(
+'debugdeltachain',
 cmdutil.debugrevlogopts + cmdutil.formatteropts,
 _('-c|-m|FILE'),
-optionalrepo=True)
+optionalrepo=True,
+)
 def debugdeltachain(ui, repo, file_=None, **opts):
 """dump information about delta chains in a revlog
 Output can be templatized. Available template keywords are:
 return compsize, uncompsize, deltatype, chain, chainsize
 fm = ui.formatter('debugdeltachain', opts)
-fm.plain('    rev  chain# chainlen     prev   delta       '
+fm.plain(
-'size    rawsize  chainsize     ratio   lindist extradist '
+'    rev  chain# chainlen     prev   delta       '
-'extraratio')
+'size    rawsize  chainsize     ratio   lindist extradist '
+'extraratio'
+)
 if withsparseread:
 fm.plain('   readsize largestblk rddensity srchunks')
 fm.plain('\n')
 chainbases = {}
 extraratio = float(extradist) / float(chainsize)
 else:
 extraratio = extradist
 fm.startitem()
-fm.write('rev chainid chainlen prevrev deltatype compsize '
+fm.write(
-'uncompsize chainsize chainratio lindist extradist '
+'rev chainid chainlen prevrev deltatype compsize '
-'extraratio',
+'uncompsize chainsize chainratio lindist extradist '
-'%7d %7d %8d %8d %7s %10d %10d %10d %9.5f %9d %9d %10.5f',
+'extraratio',
-rev, chainid, len(chain), prevrev, deltatype, comp,
+'%7d %7d %8d %8d %7s %10d %10d %10d %9.5f %9d %9d %10.5f',
-uncomp, chainsize, chainratio, lineardist, extradist,
+rev,
-extraratio,
+chainid,
-rev=rev, chainid=chainid, chainlen=len(chain),
+len(chain),
-prevrev=prevrev, deltatype=deltatype, compsize=comp,
+prevrev,
-uncompsize=uncomp, chainsize=chainsize,
+deltatype,
-chainratio=chainratio, lindist=lineardist,
+comp,
-extradist=extradist, extraratio=extraratio)
+uncomp,
+chainsize,
+chainratio,
+lineardist,
+extradist,
+extraratio,
+rev=rev,
+chainid=chainid,
+chainlen=len(chain),
+prevrev=prevrev,
+deltatype=deltatype,
+compsize=comp,
+uncompsize=uncomp,
+chainsize=chainsize,
+chainratio=chainratio,
+lindist=lineardist,
+extradist=extradist,
+extraratio=extraratio,
+)
 if withsparseread:
 readsize = 0
 largestblock = 0
 srchunks = 0
 if readsize:
 readdensity = float(chainsize) / float(readsize)
 else:
 readdensity = 1
-fm.write('readsize largestblock readdensity srchunks',
+fm.write(
-' %10d %10d %9.5f %8d',
+'readsize largestblock readdensity srchunks',
-readsize, largestblock, readdensity, srchunks,
+' %10d %10d %9.5f %8d',
-readsize=readsize, largestblock=largestblock,
+readsize,
-readdensity=readdensity, srchunks=srchunks)
+largestblock,
+readdensity,
+srchunks,
+readsize=readsize,
+largestblock=largestblock,
+readdensity=readdensity,
+srchunks=srchunks,
+)
 fm.plain('\n')
 fm.end()
-@command('debugdirstate|debugstate',
-[('', 'nodates', None, _('do not display the saved mtime (DEPRECATED)')),
+@command(
-('', 'dates', True, _('display the saved mtime')),
+'debugdirstate|debugstate',
-('', 'datesort', None, _('sort by saved mtime'))],
+[
-_('[OPTION]...'))
+('', 'nodates', None, _('do not display the saved mtime (DEPRECATED)')),
+('', 'dates', True, _('display the saved mtime')),
+('', 'datesort', None, _('sort by saved mtime')),
+],
+_('[OPTION]...'),
+)
 def debugstate(ui, repo, **opts):
 """show the contents of the current dirstate"""
 nodates = not opts[r'dates']
 if opts.get(r'nodates') is not None:
 nodates = True
 datesort = opts.get(r'datesort')
 if datesort:
-keyfunc = lambda x: (x[1][3], x[0]) # sort by mtime, then by filename
+keyfunc = lambda x: (x[1][3], x[0])  # sort by mtime, then by filename
 else:
-keyfunc = None # sort by filename
+keyfunc = None  # sort by filename
 for file_, ent in sorted(repo.dirstate.iteritems(), key=keyfunc):
 if ent[3] == -1:
 timestr = 'unset               '
 elif nodates:
 timestr = 'set                 '
 else:
-timestr = time.strftime(r"%Y-%m-%d %H:%M:%S ",
+timestr = time.strftime(
-time.localtime(ent[3]))
+r"%Y-%m-%d %H:%M:%S ", time.localtime(ent[3])
+)
 timestr = encoding.strtolocal(timestr)
 if ent[1] & 0o20000:
 mode = 'lnk'
 else:
 mode = '%3o' % (ent[1] & 0o777 & ~util.umask)
 ui.write("%c %s %10d %s%s\n" % (ent[0], mode, ent[2], timestr, file_))
 for f in repo.dirstate.copies():
 ui.write(_("copy: %s -> %s\n") % (repo.dirstate.copied(f), f))
-@command('debugdiscovery',
-[('', 'old', None, _('use old-style discovery')),
+@command(
-('', 'nonheads', None,
+'debugdiscovery',
-_('use old-style discovery with non-heads included')),
+[
-('', 'rev', [], 'restrict discovery to this set of revs'),
+('', 'old', None, _('use old-style discovery')),
-('', 'seed', '12323', 'specify the random seed use for discovery'),
+(
-] + cmdutil.remoteopts,
+'',
-_('[--rev REV] [OTHER]'))
+'nonheads',
+None,
+_('use old-style discovery with non-heads included'),
+),
+('', 'rev', [], 'restrict discovery to this set of revs'),
+('', 'seed', '12323', 'specify the random seed use for discovery'),
+]
++ cmdutil.remoteopts,
+_('[--rev REV] [OTHER]'),
+)
 def debugdiscovery(ui, repo, remoteurl="default", **opts):
 """runs the changeset discovery protocol in isolation"""
 opts = pycompat.byteskwargs(opts)
 remoteurl, branches = hg.parseurl(ui.expandpath(remoteurl))
 remote = hg.peer(repo, opts, remoteurl)
 ui.status(_('comparing with %s\n') % util.hidepassword(remoteurl))
 # make sure tests are repeatable
 random.seed(int(opts['seed']))
 if opts.get('old'):
 def doit(pushedrevs, remoteheads, remote=remote):
 if not util.safehasattr(remote, 'branches'):
 # enable in-client legacy support
 remote = localrepo.locallegacypeer(remote.local())
-common, _in, hds = treediscovery.findcommonincoming(repo, remote,
+common, _in, hds = treediscovery.findcommonincoming(
-force=True)
+repo, remote, force=True
+)
 common = set(common)
 if not opts.get('nonheads'):
-ui.write(("unpruned common: %s\n") %
+ui.write(
-" ".join(sorted(short(n) for n in common)))
+"unpruned common: %s\n"
+% " ".join(sorted(short(n) for n in common))
+)
 clnode = repo.changelog.node
 common = repo.revs('heads(::%ln)', common)
 common = {clnode(r) for r in common}
 return common, hds
 else:
 def doit(pushedrevs, remoteheads, remote=remote):
 nodes = None
 if pushedrevs:
 revs = scmutil.revrange(repo, pushedrevs)
 nodes = [repo[r].node() for r in revs]
-common, any, hds = setdiscovery.findcommonheads(ui, repo, remote,
+common, any, hds = setdiscovery.findcommonheads(
-ancestorsof=nodes)
+ui, repo, remote, ancestorsof=nodes
+)
 return common, hds
 remoterevs, _checkout = hg.addbranchrevs(repo, remote, branches, revs=None)
 localrevs = opts['rev']
 with util.timedcm('debug-discovery') as t:
 data['nb-revs'] = len(repo.revs('all()'))
 data['nb-revs-common'] = len(repo.revs('::%ln', common))
 data['nb-revs-missing'] = data['nb-revs'] - data['nb-revs-common']
 # display discovery summary
-ui.write(("elapsed time:  %(elapsed)f seconds\n") % data)
+ui.write("elapsed time:  %(elapsed)f seconds\n" % data)
-ui.write(("heads summary:\n"))
+ui.write("heads summary:\n")
-ui.write(("  total common heads:  %(nb-common)9d\n") % data)
+ui.write("  total common heads:  %(nb-common)9d\n" % data)
-ui.write(("    also local heads:  %(nb-common-local)9d\n") % data)
+ui.write("    also local heads:  %(nb-common-local)9d\n" % data)
-ui.write(("    also remote heads: %(nb-common-remote)9d\n") % data)
+ui.write("    also remote heads: %(nb-common-remote)9d\n" % data)
-ui.write(("    both:              %(nb-common-both)9d\n") % data)
+ui.write("    both:              %(nb-common-both)9d\n" % data)
-ui.write(("  local heads:         %(nb-local)9d\n") % data)
+ui.write("  local heads:         %(nb-local)9d\n" % data)
-ui.write(("    common:            %(nb-common-local)9d\n") % data)
+ui.write("    common:            %(nb-common-local)9d\n" % data)
-ui.write(("    missing:           %(nb-local-missing)9d\n") % data)
+ui.write("    missing:           %(nb-local-missing)9d\n" % data)
-ui.write(("  remote heads:        %(nb-remote)9d\n") % data)
+ui.write("  remote heads:        %(nb-remote)9d\n" % data)
-ui.write(("    common:            %(nb-common-remote)9d\n") % data)
+ui.write("    common:            %(nb-common-remote)9d\n" % data)
-ui.write(("    unknown:           %(nb-remote-unknown)9d\n") % data)
+ui.write("    unknown:           %(nb-remote-unknown)9d\n" % data)
-ui.write(("local changesets:      %(nb-revs)9d\n") % data)
+ui.write("local changesets:      %(nb-revs)9d\n" % data)
-ui.write(("  common:              %(nb-revs-common)9d\n") % data)
+ui.write("  common:              %(nb-revs-common)9d\n" % data)
-ui.write(("  missing:             %(nb-revs-missing)9d\n") % data)
+ui.write("  missing:             %(nb-revs-missing)9d\n" % data)
 if ui.verbose:
-ui.write(("common heads: %s\n") %
+ui.write(
-" ".join(sorted(short(n) for n in common)))
+"common heads: %s\n" % " ".join(sorted(short(n) for n in common))
+)
 _chunksize = 4 << 10
-@command('debugdownload',
-[
+@command('debugdownload', [('o', 'output', '', _('path')),], optionalrepo=True)
-('o', 'output', '', _('path')),
-],
-optionalrepo=True)
 def debugdownload(ui, repo, url, output=None, **opts):
 """download a resource using Mercurial logic and config
 """
 fh = urlmod.open(ui, url, output)
 dest.write(data)
 data = fh.read(_chunksize)
 finally:
 if output:
 dest.close()
 @command('debugextensions', cmdutil.formatteropts, [], optionalrepo=True)
 def debugextensions(ui, repo, **opts):
 '''show information about active extensions'''
 opts = pycompat.byteskwargs(opts)
 fm.plain(_(' (untested!)\n'))
 else:
 lasttestedversion = exttestedwith[-1]
 fm.plain(' (%s!)\n' % lasttestedversion)
-fm.condwrite(ui.verbose and extsource, 'source',
+fm.condwrite(
-_('  location: %s\n'), extsource or "")
+ui.verbose and extsource,
+'source',
+_('  location: %s\n'),
+extsource or "",
+)
 if ui.verbose:
 fm.plain(_('  bundled: %s\n') % ['no', 'yes'][isinternal])
 fm.data(bundled=isinternal)
-fm.condwrite(ui.verbose and exttestedwith, 'testedwith',
+fm.condwrite(
-_('  tested with: %s\n'),
+ui.verbose and exttestedwith,
-fm.formatlist(exttestedwith, name='ver'))
+'testedwith',
+_('  tested with: %s\n'),
-fm.condwrite(ui.verbose and extbuglink, 'buglink',
+fm.formatlist(exttestedwith, name='ver'),
-_('  bug reporting: %s\n'), extbuglink or "")
+)
+fm.condwrite(
+ui.verbose and extbuglink,
+'buglink',
+_('  bug reporting: %s\n'),
+extbuglink or "",
+)
 fm.end()
-@command('debugfileset',
-[('r', 'rev', '', _('apply the filespec on this revision'), _('REV')),
+@command(
-('', 'all-files', False,
+'debugfileset',
-_('test files from all revisions and working directory')),
+[
-('s', 'show-matcher', None,
+('r', 'rev', '', _('apply the filespec on this revision'), _('REV')),
-_('print internal representation of matcher')),
+(
-('p', 'show-stage', [],
+'',
-_('print parsed tree at the given stage'), _('NAME'))],
+'all-files',
-_('[-r REV] [--all-files] [OPTION]... FILESPEC'))
+False,
+_('test files from all revisions and working directory'),
+),
+(
+'s',
+'show-matcher',
+None,
+_('print internal representation of matcher'),
+),
+(
+'p',
+'show-stage',
+[],
+_('print parsed tree at the given stage'),
+_('NAME'),
+),
+],
+_('[-r REV] [--all-files] [OPTION]... FILESPEC'),
+)
 def debugfileset(ui, repo, expr, **opts):
 '''parse and apply a fileset specification'''
 from . import fileset
-fileset.symbols # force import of fileset so we have predicates to optimize
+fileset.symbols  # force import of fileset so we have predicates to optimize
 opts = pycompat.byteskwargs(opts)
 ctx = scmutil.revsingle(repo, opts.get('rev'), None)
 stages = [
 ('parsed', pycompat.identity),
 tree = filesetlang.parse(expr)
 for n, f in stages:
 tree = f(tree)
 if n in showalways:
 if opts['show_stage'] or n != 'parsed':
-ui.write(("* %s:\n") % n)
+ui.write("* %s:\n" % n)
 ui.write(filesetlang.prettyformat(tree), "\n")
 files = set()
 if opts['all_files']:
 for r in repo:
 c = repo[r]
 files.update(c.files())
 files.update(c.substate)
 if opts['all_files'] or ctx.rev() is None:
 wctx = repo[None]
-files.update(repo.dirstate.walk(scmutil.matchall(repo),
+files.update(
-subrepos=list(wctx.substate),
+repo.dirstate.walk(
-unknown=True, ignored=True))
+scmutil.matchall(repo),
+subrepos=list(wctx.substate),
+unknown=True,
+ignored=True,
+)
+)
 files.update(wctx.substate)
 else:
 files.update(ctx.files())
 files.update(ctx.substate)
 m = ctx.matchfileset(expr)
 if opts['show_matcher'] or (opts['show_matcher'] is None and ui.verbose):
-ui.write(('* matcher:\n'), stringutil.prettyrepr(m), '\n')
+ui.write('* matcher:\n', stringutil.prettyrepr(m), '\n')
 for f in sorted(files):
 if not m(f):
 continue
 ui.write("%s\n" % f)
-@command('debugformat',
-[] + cmdutil.formatteropts)
+@command('debugformat', [] + cmdutil.formatteropts)
 def debugformat(ui, repo, **opts):
 """display format information about the current repository
 Use --verbose to get extra information about current config value and
 Mercurial default."""
 def makeformatname(name):
 return '%s:' + (' ' * (maxvariantlength - len(name)))
 fm = ui.formatter('debugformat', opts)
 if fm.isplain():
 def formatvalue(value):
 if util.safehasattr(value, 'startswith'):
 return value
 if value:
 return 'yes'
 else:
 return 'no'
 else:
 formatvalue = pycompat.identity
 fm.plain('format-variant')
 fm.plain(' ' * (maxvariantlength - len('format-variant')))
 repolabel = 'formatvariant.repo.mismatchdefault'
 else:
 namelabel = 'formatvariant.name.uptodate'
 repolabel = 'formatvariant.repo.uptodate'
-fm.write('name', makeformatname(fv.name), fv.name,
+fm.write('name', makeformatname(fv.name), fv.name, label=namelabel)
-label=namelabel)
+fm.write('repo', ' %3s', formatvalue(repovalue), label=repolabel)
-fm.write('repo', ' %3s', formatvalue(repovalue),
-label=repolabel)
 if fv.default != configvalue:
 configlabel = 'formatvariant.config.special'
 else:
 configlabel = 'formatvariant.config.default'
-fm.condwrite(ui.verbose, 'config', ' %6s', formatvalue(configvalue),
+fm.condwrite(
-label=configlabel)
+ui.verbose,
-fm.condwrite(ui.verbose, 'default', ' %7s', formatvalue(fv.default),
+'config',
-label='formatvariant.default')
+' %6s',
+formatvalue(configvalue),
+label=configlabel,
+)
+fm.condwrite(
+ui.verbose,
+'default',
+' %7s',
+formatvalue(fv.default),
+label='formatvariant.default',
+)
 fm.plain('\n')
 fm.end()
 @command('debugfsinfo', [], _('[PATH]'), norepo=True)
 def debugfsinfo(ui, path="."):
 """show information detected about current filesystem"""
-ui.write(('path: %s\n') % path)
+ui.write('path: %s\n' % path)
-ui.write(('mounted on: %s\n') % (util.getfsmountpoint(path) or '(unknown)'))
+ui.write('mounted on: %s\n' % (util.getfsmountpoint(path) or '(unknown)'))
-ui.write(('exec: %s\n') % (util.checkexec(path) and 'yes' or 'no'))
+ui.write('exec: %s\n' % (util.checkexec(path) and 'yes' or 'no'))
-ui.write(('fstype: %s\n') % (util.getfstype(path) or '(unknown)'))
+ui.write('fstype: %s\n' % (util.getfstype(path) or '(unknown)'))
-ui.write(('symlink: %s\n') % (util.checklink(path) and 'yes' or 'no'))
+ui.write('symlink: %s\n' % (util.checklink(path) and 'yes' or 'no'))
-ui.write(('hardlink: %s\n') % (util.checknlink(path) and 'yes' or 'no'))
+ui.write('hardlink: %s\n' % (util.checknlink(path) and 'yes' or 'no'))
 casesensitive = '(unknown)'
 try:
 with pycompat.namedtempfile(prefix='.debugfsinfo', dir=path) as f:
 casesensitive = util.fscasesensitive(f.name) and 'yes' or 'no'
 except OSError:
 pass
-ui.write(('case-sensitive: %s\n') % casesensitive)
+ui.write('case-sensitive: %s\n' % casesensitive)
-@command('debuggetbundle',
-[('H', 'head', [], _('id of head node'), _('ID')),
+@command(
-('C', 'common', [], _('id of common node'), _('ID')),
+'debuggetbundle',
-('t', 'type', 'bzip2', _('bundle compression type to use'), _('TYPE'))],
+[
+('H', 'head', [], _('id of head node'), _('ID')),
+('C', 'common', [], _('id of common node'), _('ID')),
+('t', 'type', 'bzip2', _('bundle compression type to use'), _('TYPE')),
+],
 _('REPO FILE [-H|-C ID]...'),
-norepo=True)
+norepo=True,
+)
 def debuggetbundle(ui, repopath, bundlepath, head=None, common=None, **opts):
 """retrieves a bundle from a repo
 Every ID must be a full-length hex node id string. Saves the bundle to the
 given file.
 # TODO: get desired bundlecaps from command line.
 args[r'bundlecaps'] = None
 bundle = repo.getbundle('debug', **args)
 bundletype = opts.get('type', 'bzip2').lower()
-btypes = {'none': 'HG10UN',
+btypes = {
-'bzip2': 'HG10BZ',
+'none': 'HG10UN',
-'gzip': 'HG10GZ',
+'bzip2': 'HG10BZ',
-'bundle2': 'HG20'}
+'gzip': 'HG10GZ',
+'bundle2': 'HG20',
+}
 bundletype = btypes.get(bundletype)
 if bundletype not in bundle2.bundletypes:
 raise error.Abort(_('unknown bundle type specified with --type'))
 bundle2.writebundle(ui, bundle, bundlepath, bundletype)
 @command('debugignore', [], '[FILE]')
 def debugignore(ui, repo, *files, **opts):
 """display the combined ignore pattern and information about ignored files
 break
 if ignored:
 if ignored == nf:
 ui.write(_("%s is ignored\n") % uipathfn(f))
 else:
-ui.write(_("%s is ignored because of "
+ui.write(
-"containing directory %s\n")
+_(
-% (uipathfn(f), ignored))
+"%s is ignored because of "
+"containing directory %s\n"
+)
+% (uipathfn(f), ignored)
+)
 ignorefile, lineno, line = ignoredata
-ui.write(_("(ignore rule in %s, line %d: '%s')\n")
+ui.write(
-% (ignorefile, lineno, line))
+_("(ignore rule in %s, line %d: '%s')\n")
+% (ignorefile, lineno, line)
+)
 else:
 ui.write(_("%s is not ignored\n") % uipathfn(f))
-@command('debugindex', cmdutil.debugrevlogopts + cmdutil.formatteropts,
-_('-c|-m|FILE'))
+@command(
+'debugindex',
+cmdutil.debugrevlogopts + cmdutil.formatteropts,
+_('-c|-m|FILE'),
+)
 def debugindex(ui, repo, file_=None, **opts):
 """dump index data for a storage primitive"""
 opts = pycompat.byteskwargs(opts)
 store = cmdutil.openstorage(repo, 'debugindex', file_, opts)
 for i in store:
 idlen = len(shortfn(store.node(i)))
 break
 fm = ui.formatter('debugindex', opts)
-fm.plain(b'   rev linkrev %s %s p2\n' % (
+fm.plain(
-b'nodeid'.ljust(idlen),
+b'   rev linkrev %s %s p2\n'
-b'p1'.ljust(idlen)))
+% (b'nodeid'.ljust(idlen), b'p1'.ljust(idlen))
+)
 for rev in store:
 node = store.node(rev)
 parents = store.parents(node)
 fm.write(b'p2', '%s', shortfn(parents[1]))
 fm.plain(b'\n')
 fm.end()
-@command('debugindexdot', cmdutil.debugrevlogopts,
-_('-c|-m|FILE'), optionalrepo=True)
+@command(
+'debugindexdot', cmdutil.debugrevlogopts, _('-c|-m|FILE'), optionalrepo=True
+)
 def debugindexdot(ui, repo, file_=None, **opts):
 """dump an index DAG as a graphviz dot file"""
 opts = pycompat.byteskwargs(opts)
 r = cmdutil.openstorage(repo, 'debugindexdot', file_, opts)
-ui.write(("digraph G {\n"))
+ui.write("digraph G {\n")
 for i in r:
 node = r.node(i)
 pp = r.parents(node)
 ui.write("\t%d -> %d\n" % (r.rev(pp[0]), i))
 if pp[1] != nullid:
 ui.write("\t%d -> %d\n" % (r.rev(pp[1]), i))
 ui.write("}\n")
 @command('debugindexstats', [])
 def debugindexstats(ui, repo):
 """show stats related to the changelog index"""
 repo.changelog.shortest(nullid, 1)
 if not util.safehasattr(index, 'stats'):
 raise error.Abort(_('debugindexstats only works with native code'))
 for k, v in sorted(index.stats().items()):
 ui.write('%s: %d\n' % (k, v))
 @command('debuginstall', [] + cmdutil.formatteropts, '', norepo=True)
 def debuginstall(ui, **opts):
 '''test Mercurial installation
 Returns 0 on success.
 try:
 codecs.lookup(pycompat.sysstr(encoding.encoding))
 except LookupError as inst:
 err = stringutil.forcebytestr(inst)
 problems += 1
-fm.condwrite(err, 'encodingerror', _(" %s\n"
+fm.condwrite(
-" (check that your locale is properly set)\n"), err)
+err,
+'encodingerror',
+_(" %s\n" " (check that your locale is properly set)\n"),
+err,
+)
 # Python
-fm.write('pythonexe', _("checking Python executable (%s)\n"),
+fm.write(
-pycompat.sysexecutable or _("unknown"))
+'pythonexe',
-fm.write('pythonver', _("checking Python version (%s)\n"),
+_("checking Python executable (%s)\n"),
-("%d.%d.%d" % sys.version_info[:3]))
+pycompat.sysexecutable or _("unknown"),
-fm.write('pythonlib', _("checking Python lib (%s)...\n"),
+)
-os.path.dirname(pycompat.fsencode(os.__file__)))
+fm.write(
+'pythonver',
+_("checking Python version (%s)\n"),
+("%d.%d.%d" % sys.version_info[:3]),
+)
+fm.write(
+'pythonlib',
+_("checking Python lib (%s)...\n"),
+os.path.dirname(pycompat.fsencode(os.__file__)),
+)
 security = set(sslutil.supportedprotocols)
 if sslutil.hassni:
 security.add('sni')
-fm.write('pythonsecurity', _("checking Python security support (%s)\n"),
+fm.write(
-fm.formatlist(sorted(security), name='protocol',
+'pythonsecurity',
-fmt='%s', sep=','))
+_("checking Python security support (%s)\n"),
+fm.formatlist(sorted(security), name='protocol', fmt='%s', sep=','),
+)
 # These are warnings, not errors. So don't increment problem count. This
 # may change in the future.
 if 'tls1.2' not in security:
-fm.plain(_('  TLS 1.2 not supported by Python install; '
+fm.plain(
-'network connections lack modern security\n'))
+_(
+'  TLS 1.2 not supported by Python install; '
+'network connections lack modern security\n'
+)
+)
 if 'sni' not in security:
-fm.plain(_('  SNI not supported by Python install; may have '
+fm.plain(
-'connectivity issues with some servers\n'))
+_(
+'  SNI not supported by Python install; may have '
+'connectivity issues with some servers\n'
+)
+)
 # TODO print CA cert info
 # hg version
 hgver = util.version()
-fm.write('hgver', _("checking Mercurial version (%s)\n"),
+fm.write(
-hgver.split('+')[0])
+'hgver', _("checking Mercurial version (%s)\n"), hgver.split('+')[0]
-fm.write('hgverextra', _("checking Mercurial custom build (%s)\n"),
+)
-'+'.join(hgver.split('+')[1:]))
+fm.write(
+'hgverextra',
+_("checking Mercurial custom build (%s)\n"),
+'+'.join(hgver.split('+')[1:]),
+)
 # compiled modules
-fm.write('hgmodulepolicy', _("checking module policy (%s)\n"),
+fm.write(
-policy.policy)
+'hgmodulepolicy', _("checking module policy (%s)\n"), policy.policy
-fm.write('hgmodules', _("checking installed modules (%s)...\n"),
+)
-os.path.dirname(pycompat.fsencode(__file__)))
+fm.write(
+'hgmodules',
+_("checking installed modules (%s)...\n"),
+os.path.dirname(pycompat.fsencode(__file__)),
+)
 rustandc = policy.policy in ('rust+c', 'rust+c-allow')
 rustext = rustandc  # for now, that's the only case
 cext = policy.policy in ('c', 'allow') or rustandc
 nopure = cext or rustext
 base85,
 bdiff,
 mpatch,
 osutil,
 )
 # quiet pyflakes
 dir(bdiff), dir(mpatch), dir(base85), dir(osutil)
 if rustext:
 from .rustext import (
 ancestor,
 dirstate,
 )
-dir(ancestor), dir(dirstate) # quiet pyflakes
+dir(ancestor), dir(dirstate)  # quiet pyflakes
 except Exception as inst:
 err = stringutil.forcebytestr(inst)
 problems += 1
 fm.condwrite(err, 'extensionserror', " %s\n", err)
 compengines = util.compengines._engines.values()
-fm.write('compengines', _('checking registered compression engines (%s)\n'),
+fm.write(
-fm.formatlist(sorted(e.name() for e in compengines),
+'compengines',
-name='compengine', fmt='%s', sep=', '))
+_('checking registered compression engines (%s)\n'),
-fm.write('compenginesavail', _('checking available compression engines '
+fm.formatlist(
-'(%s)\n'),
+sorted(e.name() for e in compengines),
-fm.formatlist(sorted(e.name() for e in compengines
+name='compengine',
-if e.available()),
+fmt='%s',
-name='compengine', fmt='%s', sep=', '))
+sep=', ',
+),
+)
+fm.write(
+'compenginesavail',
+_('checking available compression engines ' '(%s)\n'),
+fm.formatlist(
+sorted(e.name() for e in compengines if e.available()),
+name='compengine',
+fmt='%s',
+sep=', ',
+),
+)
 wirecompengines = compression.compengines.supportedwireengines(
-compression.SERVERROLE)
+compression.SERVERROLE
-fm.write('compenginesserver', _('checking available compression engines '
+)
-'for wire protocol (%s)\n'),
+fm.write(
-fm.formatlist([e.name() for e in wirecompengines
+'compenginesserver',
-if e.wireprotosupport()],
+_('checking available compression engines ' 'for wire protocol (%s)\n'),
-name='compengine', fmt='%s', sep=', '))
+fm.formatlist(
+[e.name() for e in wirecompengines if e.wireprotosupport()],
+name='compengine',
+fmt='%s',
+sep=', ',
+),
+)
 re2 = 'missing'
 if util._re2:
 re2 = 'available'
 fm.plain(_('checking "re2" regexp engine (%s)\n') % re2)
 fm.data(re2=bool(util._re2))
 err = stringutil.forcebytestr(inst)
 p = None
 fm.condwrite(err, 'defaulttemplateerror', " %s\n", err)
 else:
 p = None
-fm.condwrite(p, 'defaulttemplate',
+fm.condwrite(
-_("checking default template (%s)\n"), m)
+p, 'defaulttemplate', _("checking default template (%s)\n"), m
-fm.condwrite(not m, 'defaulttemplatenotfound',
+)
-_(" template '%s' not found\n"), "default")
+fm.condwrite(
+not m,
+'defaulttemplatenotfound',
+_(" template '%s' not found\n"),
+"default",
+)
 if not p:
 problems += 1
-fm.condwrite(not p, '',
+fm.condwrite(
-_(" (templates seem to have been installed incorrectly)\n"))
+not p, '', _(" (templates seem to have been installed incorrectly)\n")
+)
 # editor
 editor = ui.geteditor()
 editor = util.expandpath(editor)
 editorbin = procutil.shellsplit(editor)[0]
 fm.write('editor', _("checking commit editor... (%s)\n"), editorbin)
 cmdpath = procutil.findexe(editorbin)
-fm.condwrite(not cmdpath and editor == 'vi', 'vinotfound',
+fm.condwrite(
-_(" No commit editor set and can't find %s in PATH\n"
+not cmdpath and editor == 'vi',
-" (specify a commit editor in your configuration"
+'vinotfound',
-" file)\n"), not cmdpath and editor == 'vi' and editorbin)
+_(
-fm.condwrite(not cmdpath and editor != 'vi', 'editornotfound',
+" No commit editor set and can't find %s in PATH\n"
-_(" Can't find editor '%s' in PATH\n"
+" (specify a commit editor in your configuration"
-" (specify a commit editor in your configuration"
+" file)\n"
-" file)\n"), not cmdpath and editorbin)
+),
+not cmdpath and editor == 'vi' and editorbin,
+)
+fm.condwrite(
+not cmdpath and editor != 'vi',
+'editornotfound',
+_(
+" Can't find editor '%s' in PATH\n"
+" (specify a commit editor in your configuration"
+" file)\n"
+),
+not cmdpath and editorbin,
+)
 if not cmdpath and editor != 'vi':
 problems += 1
 # check username
 username = None
 username = ui.username()
 except error.Abort as e:
 err = stringutil.forcebytestr(e)
 problems += 1
-fm.condwrite(username, 'username',  _("checking username (%s)\n"), username)
+fm.condwrite(username, 'username', _("checking username (%s)\n"), username)
-fm.condwrite(err, 'usernameerror', _("checking username...\n %s\n"
+fm.condwrite(
-" (specify a username in your configuration file)\n"), err)
+err,
+'usernameerror',
+_(
+"checking username...\n %s\n"
+" (specify a username in your configuration file)\n"
+),
+err,
+)
 for name, mod in extensions.extensions():
 handler = getattr(mod, 'debuginstall', None)
 if handler is not None:
 problems += handler(ui, fm)
-fm.condwrite(not problems, '',
+fm.condwrite(not problems, '', _("no problems detected\n"))
-_("no problems detected\n"))
 if not problems:
 fm.data(problems=problems)
-fm.condwrite(problems, 'problems',
+fm.condwrite(
-_("%d problems detected,"
+problems,
-" please check your install!\n"), problems)
+'problems',
+_("%d problems detected," " please check your install!\n"),
+problems,
+)
 fm.end()
 return problems
 @command('debugknown', [], _('REPO ID...'), norepo=True)
 def debugknown(ui, repopath, *ids, **opts):
 """test whether node ids are known to a repo
 if not repo.capable('known'):
 raise error.Abort("known() not supported by target repository")
 flags = repo.known([bin(s) for s in ids])
 ui.write("%s\n" % ("".join([f and "1" or "0" for f in flags])))
 @command('debuglabelcomplete', [], _('LABEL...'))
 def debuglabelcomplete(ui, repo, *args):
 '''backwards compatibility with old bash completion scripts (DEPRECATED)'''
 debugnamecomplete(ui, repo, *args)
-@command('debuglocks',
-[('L', 'force-lock', None, _('free the store lock (DANGEROUS)')),
+@command(
-('W', 'force-wlock', None,
+'debuglocks',
-_('free the working state lock (DANGEROUS)')),
+[
-('s', 'set-lock', None, _('set the store lock until stopped')),
+('L', 'force-lock', None, _('free the store lock (DANGEROUS)')),
-('S', 'set-wlock', None,
+(
-_('set the working state lock until stopped'))],
+'W',
-_('[OPTION]...'))
+'force-wlock',
+None,
+_('free the working state lock (DANGEROUS)'),
+),
+('s', 'set-lock', None, _('set the store lock until stopped')),
+('S', 'set-wlock', None, _('set the working state lock until stopped')),
+],
+_('[OPTION]...'),
+)
 def debuglocks(ui, repo, **opts):
 """show or modify state of locks
 By default, this command will show which locks are held. This
 includes the user and process holding the lock, the amount of time
 if ":" in locker:
 host, pid = locker.split(':')
 if host == socket.gethostname():
 locker = 'user %s, process %s' % (user or b'None', pid)
 else:
-locker = ('user %s, process %s, host %s'
+locker = 'user %s, process %s, host %s' % (
-% (user or b'None', pid, host))
+user or b'None',
-ui.write(("%-6s %s (%ds)\n") % (name + ":", locker, age))
+pid,
+host,
+)
+ui.write("%-6s %s (%ds)\n" % (name + ":", locker, age))
 return 1
 except OSError as e:
 if e.errno != errno.ENOENT:
 raise
-ui.write(("%-6s free\n") % (name + ":"))
+ui.write("%-6s free\n" % (name + ":"))
 return 0
 held += report(repo.svfs, "lock", repo.lock)
 held += report(repo.vfs, "wlock", repo.wlock)
 return held
-@command('debugmanifestfulltextcache', [
+@command(
+'debugmanifestfulltextcache',
+[
 ('', 'clear', False, _('clear the cache')),
-('a', 'add', [], _('add the given manifest nodes to the cache'),
+(
-_('NODE'))
+'a',
-], '')
+'add',
+[],
+_('add the given manifest nodes to the cache'),
+_('NODE'),
+),
+],
+'',
+)
 def debugmanifestfulltextcache(ui, repo, add=(), **opts):
 """show, clear or amend the contents of the manifest fulltext cache"""
 def getcache():
 r = repo.manifestlog.getstorage(b'')
 try:
 return r._fulltextcache
 except AttributeError:
-msg = _("Current revlog implementation doesn't appear to have a "
+msg = _(
-"manifest fulltext cache\n")
+"Current revlog implementation doesn't appear to have a "
+"manifest fulltext cache\n"
+)
 raise error.Abort(msg)
 if opts.get(r'clear'):
 with repo.wlock():
 cache = getcache()
 cache = getcache()
 if not len(cache):
 ui.write(_('cache empty\n'))
 else:
 ui.write(
-_('cache contains %d manifest entries, in order of most to '
+_(
-'least recent:\n') % (len(cache),))
+'cache contains %d manifest entries, in order of most to '
+'least recent:\n'
+)
+% (len(cache),)
+)
 totalsize = 0
 for nodeid in cache:
 # Use cache.get to not update the LRU order
 data = cache.peek(nodeid)
 size = len(data)
-totalsize += size + 24   # 20 bytes nodeid, 4 bytes size
+totalsize += size + 24  # 20 bytes nodeid, 4 bytes size
-ui.write(_('id: %s, size %s\n') % (
+ui.write(
-hex(nodeid), util.bytecount(size)))
+_('id: %s, size %s\n') % (hex(nodeid), util.bytecount(size))
+)
 ondisk = cache._opener.stat('manifestfulltextcache').st_size
 ui.write(
-_('total cache data size %s, on-disk %s\n') % (
+_('total cache data size %s, on-disk %s\n')
-util.bytecount(totalsize), util.bytecount(ondisk))
+% (util.bytecount(totalsize), util.bytecount(ondisk))
 )
 @command('debugmergestate', [], '')
 def debugmergestate(ui, repo, *args):
 """print merge state
 Use --verbose to print out information about whether v1 or v2 merge state
 was chosen."""
 def _hashornull(h):
 if h == nullhex:
 return 'null'
 else:
 return h
 def printrecords(version):
-ui.write(('* version %d records\n') % version)
+ui.write('* version %d records\n' % version)
 if version == 1:
 records = v1records
 else:
 records = v2records
 for rtype, record in records:
 # pretty print some record types
 if rtype == 'L':
-ui.write(('local: %s\n') % record)
+ui.write('local: %s\n' % record)
 elif rtype == 'O':
-ui.write(('other: %s\n') % record)
+ui.write('other: %s\n' % record)
 elif rtype == 'm':
 driver, mdstate = record.split('\0', 1)
-ui.write(('merge driver: %s (state "%s")\n')
+ui.write('merge driver: %s (state "%s")\n' % (driver, mdstate))
-% (driver, mdstate))
 elif rtype in 'FDC':
 r = record.split('\0')
 f, state, hash, lfile, afile, anode, ofile = r[0:7]
 if version == 1:
 onode = 'not stored in v1 format'
 flags = r[7]
 else:
 onode, flags = r[7:9]
-ui.write(('file: %s (record type "%s", state "%s", hash %s)\n')
+ui.write(
-% (f, rtype, state, _hashornull(hash)))
+'file: %s (record type "%s", state "%s", hash %s)\n'
-ui.write(('  local path: %s (flags "%s")\n') % (lfile, flags))
+% (f, rtype, state, _hashornull(hash))
-ui.write(('  ancestor path: %s (node %s)\n')
+)
-% (afile, _hashornull(anode)))
+ui.write('  local path: %s (flags "%s")\n' % (lfile, flags))
-ui.write(('  other path: %s (node %s)\n')
+ui.write(
-% (ofile, _hashornull(onode)))
+'  ancestor path: %s (node %s)\n'
+% (afile, _hashornull(anode))
+)
+ui.write(
+'  other path: %s (node %s)\n' % (ofile, _hashornull(onode))
+)
 elif rtype == 'f':
 filename, rawextras = record.split('\0', 1)
 extras = rawextras.split('\0')
 i = 0
 extrastrings = []
 while i < len(extras):
 extrastrings.append('%s = %s' % (extras[i], extras[i + 1]))
 i += 2
-ui.write(('file extras: %s (%s)\n')
+ui.write(
-% (filename, ', '.join(extrastrings)))
+'file extras: %s (%s)\n'
+% (filename, ', '.join(extrastrings))
+)
 elif rtype == 'l':
 labels = record.split('\0', 2)
 labels = [l for l in labels if len(l) > 0]
-ui.write(('labels:\n'))
+ui.write('labels:\n')
 ui.write(('  local: %s\n' % labels[0]))
 ui.write(('  other: %s\n' % labels[1]))
 if len(labels) > 2:
 ui.write(('  base:  %s\n' % labels[2]))
 else:
-ui.write(('unrecognized entry: %s\t%s\n')
+ui.write(
-% (rtype, record.replace('\0', '\t')))
+'unrecognized entry: %s\t%s\n'
+% (rtype, record.replace('\0', '\t'))
+)
 # Avoid mergestate.read() since it may raise an exception for unsupported
 # merge state records. We shouldn't be doing this, but this is OK since this
 # command is pretty low-level.
 ms = mergemod.mergestate(repo)
 # sort so that reasonable information is on top
 v1records = ms._readrecordsv1()
 v2records = ms._readrecordsv2()
 order = 'LOml'
 def key(r):
 idx = order.find(r[0])
 if idx == -1:
 return (1, r[1])
 else:
 return (0, idx)
 v1records.sort(key=key)
 v2records.sort(key=key)
 if not v1records and not v2records:
-ui.write(('no merge state found\n'))
+ui.write('no merge state found\n')
 elif not v2records:
-ui.note(('no version 2 merge state\n'))
+ui.note('no version 2 merge state\n')
 printrecords(1)
 elif ms._v1v2match(v1records, v2records):
-ui.note(('v1 and v2 states match: using v2\n'))
+ui.note('v1 and v2 states match: using v2\n')
 printrecords(2)
 else:
-ui.note(('v1 and v2 states mismatch: using v1\n'))
+ui.note('v1 and v2 states mismatch: using v1\n')
 printrecords(1)
 if ui.verbose:
 printrecords(2)
 @command('debugnamecomplete', [], _('NAME...'))
 def debugnamecomplete(ui, repo, *args):
 '''complete "names" - tags, open branch names, bookmark names'''
 # since we previously only listed open branches, we will handle that
 # specially (after this for loop)
 for name, ns in repo.names.iteritems():
 if name != 'branches':
 names.update(ns.listnames(repo))
-names.update(tag for (tag, heads, tip, closed)
+names.update(
-in repo.branchmap().iterbranches() if not closed)
+tag
+for (tag, heads, tip, closed) in repo.branchmap().iterbranches()
+if not closed
+)
 completions = set()
 if not args:
 args = ['']
 for a in args:
 completions.update(n for n in names if n.startswith(a))
 ui.write('\n'.join(sorted(completions)))
 ui.write('\n')
-@command('debugobsolete',
-[('', 'flags', 0, _('markers flag')),
+@command(
-('', 'record-parents', False,
+'debugobsolete',
-_('record parent information for the precursor')),
+[
-('r', 'rev', [], _('display markers relevant to REV')),
+('', 'flags', 0, _('markers flag')),
-('', 'exclusive', False, _('restrict display to markers only '
+(
-'relevant to REV')),
+'',
-('', 'index', False, _('display index of the marker')),
+'record-parents',
-('', 'delete', [], _('delete markers specified by indices')),
+False,
-] + cmdutil.commitopts2 + cmdutil.formatteropts,
+_('record parent information for the precursor'),
-_('[OBSOLETED [REPLACEMENT ...]]'))
+),
+('r', 'rev', [], _('display markers relevant to REV')),
+(
+'',
+'exclusive',
+False,
+_('restrict display to markers only ' 'relevant to REV'),
+),
+('', 'index', False, _('display index of the marker')),
+('', 'delete', [], _('delete markers specified by indices')),
+]
++ cmdutil.commitopts2
++ cmdutil.formatteropts,
+_('[OBSOLETED [REPLACEMENT ...]]'),
+)
 def debugobsolete(ui, repo, precursor=None, *successors, **opts):
 """create arbitrary obsolete marker
 With no arguments, displays the list of obsolescence markers."""
 n = bin(s)
 if len(n) != len(nullid):
 raise TypeError()
 return n
 except TypeError:
-raise error.Abort('changeset references must be full hexadecimal '
+raise error.Abort(
-'node identifiers')
+'changeset references must be full hexadecimal '
+'node identifiers'
+)
 if opts.get('delete'):
 indices = []
 for v in opts.get('delete'):
 try:
 indices.append(int(v))
 except ValueError:
-raise error.Abort(_('invalid index value: %r') % v,
+raise error.Abort(
-hint=_('use integers for indices'))
+_('invalid index value: %r') % v,
+hint=_('use integers for indices'),
+)
 if repo.currenttransaction():
-raise error.Abort(_('cannot delete obsmarkers in the middle '
+raise error.Abort(
-'of transaction.'))
+_('cannot delete obsmarkers in the middle ' 'of transaction.')
+)
 with repo.lock():
 n = repair.deleteobsmarkers(repo.obsstore, indices)
 ui.write(_('deleted %i obsolescence markers\n') % n)
 date = None
 prec = parsenodeid(precursor)
 parents = None
 if opts['record_parents']:
 if prec not in repo.unfiltered():
-raise error.Abort('cannot used --record-parents on '
+raise error.Abort(
-'unknown changesets')
+'cannot used --record-parents on '
+'unknown changesets'
+)
 parents = repo.unfiltered()[prec].parents()
 parents = tuple(p.node() for p in parents)
-repo.obsstore.create(tr, prec, succs, opts['flags'],
+repo.obsstore.create(
-parents=parents, date=date,
+tr,
-metadata=metadata, ui=ui)
+prec,
+succs,
+opts['flags'],
+parents=parents,
+date=date,
+metadata=metadata,
+ui=ui,
+)
 tr.close()
 except ValueError as exc:
-raise error.Abort(_('bad obsmarker input: %s') %
+raise error.Abort(
-pycompat.bytestr(exc))
+_('bad obsmarker input: %s') % pycompat.bytestr(exc)
+)
 finally:
 tr.release()
 finally:
 l.release()
 else:
 if opts['rev']:
 revs = scmutil.revrange(repo, opts['rev'])
 nodes = [repo[r].node() for r in revs]
-markers = list(obsutil.getmarkers(repo, nodes=nodes,
+markers = list(
-exclusive=opts['exclusive']))
+obsutil.getmarkers(
+repo, nodes=nodes, exclusive=opts['exclusive']
+)
+)
 markers.sort(key=lambda x: x._data)
 else:
 markers = obsutil.getmarkers(repo)
 markerstoiter = markers
 fm.startitem()
 ind = i if opts.get('index') else None
 cmdutil.showmarker(fm, m, index=ind)
 fm.end()
-@command('debugp1copies',
-[('r', 'rev', '', _('revision to debug'), _('REV'))],
+@command(
-_('[-r REV]'))
+'debugp1copies',
+[('r', 'rev', '', _('revision to debug'), _('REV'))],
+_('[-r REV]'),
+)
 def debugp1copies(ui, repo, **opts):
 """dump copy information compared to p1"""
 opts = pycompat.byteskwargs(opts)
 ctx = scmutil.revsingle(repo, opts.get('rev'), default=None)
 for dst, src in ctx.p1copies().items():
 ui.write('%s -> %s\n' % (src, dst))
-@command('debugp2copies',
-[('r', 'rev', '', _('revision to debug'), _('REV'))],
+@command(
-_('[-r REV]'))
+'debugp2copies',
+[('r', 'rev', '', _('revision to debug'), _('REV'))],
+_('[-r REV]'),
+)
 def debugp1copies(ui, repo, **opts):
 """dump copy information compared to p2"""
 opts = pycompat.byteskwargs(opts)
 ctx = scmutil.revsingle(repo, opts.get('rev'), default=None)
 for dst, src in ctx.p2copies().items():
 ui.write('%s -> %s\n' % (src, dst))
-@command('debugpathcomplete',
-[('f', 'full', None, _('complete an entire path')),
+@command(
-('n', 'normal', None, _('show only normal files')),
+'debugpathcomplete',
-('a', 'added', None, _('show only added files')),
+[
-('r', 'removed', None, _('show only removed files'))],
+('f', 'full', None, _('complete an entire path')),
-_('FILESPEC...'))
+('n', 'normal', None, _('show only normal files')),
+('a', 'added', None, _('show only added files')),
+('r', 'removed', None, _('show only removed files')),
+],
+_('FILESPEC...'),
+)
 def debugpathcomplete(ui, repo, *specs, **opts):
 '''complete part or all of a tracked path
 This command supports shells that offer path name completion. It
 currently completes only files already known to the dirstate.
 rootdir = repo.root + pycompat.ossep
 if spec != repo.root and not spec.startswith(rootdir):
 return [], []
 if os.path.isdir(spec):
 spec += '/'
-spec = spec[len(rootdir):]
+spec = spec[len(rootdir) :]
 fixpaths = pycompat.ossep != '/'
 if fixpaths:
 spec = spec.replace(pycompat.ossep, '/')
 speclen = len(spec)
 fullpaths = opts[r'full']
 dirs.update(d)
 files.update(dirs)
 ui.write('\n'.join(repo.pathto(p, cwd) for p in sorted(files)))
 ui.write('\n')
-@command('debugpathcopies',
-cmdutil.walkopts,
+@command(
-'hg debugpathcopies REV1 REV2 [FILE]',
+'debugpathcopies',
-inferrepo=True)
+cmdutil.walkopts,
+'hg debugpathcopies REV1 REV2 [FILE]',
+inferrepo=True,
+)
 def debugpathcopies(ui, repo, rev1, rev2, *pats, **opts):
 """show copies between two revisions"""
 ctx1 = scmutil.revsingle(repo, rev1)
 ctx2 = scmutil.revsingle(repo, rev2)
 m = scmutil.match(ctx1, pats, opts)
 for dst, src in sorted(copies.pathcopies(ctx1, ctx2, m).items()):
 ui.write('%s -> %s\n' % (src, dst))
 @command('debugpeer', [], _('PATH'), norepo=True)
 def debugpeer(ui, path):
 """establish a connection to a peer repository"""
 # Always enable peer request logging. Requires --debug to display
 ui.write(_('url: %s\n') % peer.url())
 ui.write(_('local: %s\n') % (_('yes') if local else _('no')))
 ui.write(_('pushable: %s\n') % (_('yes') if canpush else _('no')))
-@command('debugpickmergetool',
-[('r', 'rev', '', _('check for files in this revision'), _('REV')),
+@command(
-('', 'changedelete', None, _('emulate merging change and delete')),
+'debugpickmergetool',
-] + cmdutil.walkopts + cmdutil.mergetoolopts,
+[
-_('[PATTERN]...'),
+('r', 'rev', '', _('check for files in this revision'), _('REV')),
-inferrepo=True)
+('', 'changedelete', None, _('emulate merging change and delete')),
+]
++ cmdutil.walkopts
++ cmdutil.mergetoolopts,
+_('[PATTERN]...'),
+inferrepo=True,
+)
 def debugpickmergetool(ui, repo, *pats, **opts):
 """examine which merge tool is chosen for specified file
 As described in :hg:`help merge-tools`, Mercurial examines
 configurations below in this order to decide which merge tool is
 """
 opts = pycompat.byteskwargs(opts)
 overrides = {}
 if opts['tool']:
 overrides[('ui', 'forcemerge')] = opts['tool']
-ui.note(('with --tool %r\n') % (pycompat.bytestr(opts['tool'])))
+ui.note('with --tool %r\n' % (pycompat.bytestr(opts['tool'])))
 with ui.configoverride(overrides, 'debugmergepatterns'):
 hgmerge = encoding.environ.get("HGMERGE")
 if hgmerge is not None:
-ui.note(('with HGMERGE=%r\n') % (pycompat.bytestr(hgmerge)))
+ui.note('with HGMERGE=%r\n' % (pycompat.bytestr(hgmerge)))
 uimerge = ui.config("ui", "merge")
 if uimerge:
-ui.note(('with ui.merge=%r\n') % (pycompat.bytestr(uimerge)))
+ui.note('with ui.merge=%r\n' % (pycompat.bytestr(uimerge)))
 ctx = scmutil.revsingle(repo, opts.get('rev'))
 m = scmutil.match(ctx, pats, opts)
 changedelete = opts['changedelete']
 for path in ctx.walk(m):
 fctx = ctx[path]
 try:
 if not ui.debugflag:
 ui.pushbuffer(error=True)
-tool, toolpath = filemerge._picktool(repo, ui, path,
+tool, toolpath = filemerge._picktool(
-fctx.isbinary(),
+repo,
-'l' in fctx.flags(),
+ui,
-changedelete)
+path,
+fctx.isbinary(),
+'l' in fctx.flags(),
+changedelete,
+)
 finally:
 if not ui.debugflag:
 ui.popbuffer()
-ui.write(('%s = %s\n') % (path, tool))
+ui.write('%s = %s\n' % (path, tool))
 @command('debugpushkey', [], _('REPO NAMESPACE [KEY OLD NEW]'), norepo=True)
 def debugpushkey(ui, repopath, namespace, *keyinfo, **opts):
 '''access the pushkey key/value protocol
 target = hg.peer(ui, {}, repopath)
 if keyinfo:
 key, old, new = keyinfo
 with target.commandexecutor() as e:
-r = e.callcommand('pushkey', {
+r = e.callcommand(
-'namespace': namespace,
+'pushkey',
-'key': key,
+{'namespace': namespace, 'key': key, 'old': old, 'new': new,},
-'old': old,
+).result()
-'new': new,
-}).result()
 ui.status(pycompat.bytestr(r) + '\n')
 return not r
 else:
 for k, v in sorted(target.listkeys(namespace).iteritems()):
-ui.write("%s\t%s\n" % (stringutil.escapestr(k),
+ui.write(
-stringutil.escapestr(v)))
+"%s\t%s\n" % (stringutil.escapestr(k), stringutil.escapestr(v))
+)
 @command('debugpvec', [], _('A B'))
 def debugpvec(ui, repo, a, b=None):
 ca = scmutil.revsingle(repo, a)
 cb = scmutil.revsingle(repo, b)
 elif pa | pb:
 rel = "|"
 ui.write(_("a: %s\n") % pa)
 ui.write(_("b: %s\n") % pb)
 ui.write(_("depth(a): %d depth(b): %d\n") % (pa._depth, pb._depth))
-ui.write(_("delta: %d hdist: %d distance: %d relation: %s\n") %
+ui.write(
-(abs(pa._depth - pb._depth), pvec._hamming(pa._vec, pb._vec),
+_("delta: %d hdist: %d distance: %d relation: %s\n")
-pa.distance(pb), rel))
+% (
+abs(pa._depth - pb._depth),
-@command('debugrebuilddirstate|debugrebuildstate',
+pvec._hamming(pa._vec, pb._vec),
-[('r', 'rev', '', _('revision to rebuild to'), _('REV')),
+pa.distance(pb),
-('', 'minimal', None, _('only rebuild files that are inconsistent with '
+rel,
-'the working copy parent')),
+)
+)
+@command(
+'debugrebuilddirstate|debugrebuildstate',
+[
+('r', 'rev', '', _('revision to rebuild to'), _('REV')),
+(
+'',
+'minimal',
+None,
+_(
+'only rebuild files that are inconsistent with '
+'the working copy parent'
+),
+),
 ],
-_('[-r REV]'))
+_('[-r REV]'),
+)
 def debugrebuilddirstate(ui, repo, rev, **opts):
 """rebuild the dirstate as it would look like for the given revision
 If no revision is specified the first current parent will be used.
 dsnotadded = set(f for f in dsonly if dirstate[f] != 'a')
 changedfiles = manifestonly | dsnotadded
 dirstate.rebuild(ctx.node(), ctx.manifest(), changedfiles)
 @command('debugrebuildfncache', [], '')
 def debugrebuildfncache(ui, repo):
 """rebuild the fncache file"""
 repair.rebuildfncache(ui, repo)
-@command('debugrename',
+@command(
+'debugrename',
 [('r', 'rev', '', _('revision to debug'), _('REV'))],
-_('[-r REV] [FILE]...'))
+_('[-r REV] [FILE]...'),
+)
 def debugrename(ui, repo, *pats, **opts):
 """dump rename information"""
 opts = pycompat.byteskwargs(opts)
 ctx = scmutil.revsingle(repo, opts.get('rev'))
 if o:
 ui.write(_("%s renamed from %s:%s\n") % (rel, o[0], hex(o[1])))
 else:
 ui.write(_("%s not renamed\n") % rel)
-@command('debugrevlog', cmdutil.debugrevlogopts +
-[('d', 'dump', False, _('dump index data'))],
+@command(
+'debugrevlog',
+cmdutil.debugrevlogopts + [('d', 'dump', False, _('dump index data'))],
 _('-c|-m|FILE'),
-optionalrepo=True)
+optionalrepo=True,
+)
 def debugrevlog(ui, repo, file_=None, **opts):
 """show data and statistics about a revlog"""
 opts = pycompat.byteskwargs(opts)
 r = cmdutil.openrevlog(repo, 'debugrevlog', file_, opts)
 if opts.get("dump"):
 numrevs = len(r)
-ui.write(("# rev p1rev p2rev start   end deltastart base   p1   p2"
+ui.write(
-" rawsize totalsize compression heads chainlen\n"))
+(
+"# rev p1rev p2rev start   end deltastart base   p1   p2"
+" rawsize totalsize compression heads chainlen\n"
+)
+)
 ts = 0
 heads = set()
 for rev in pycompat.xrange(numrevs):
 dbase = r.deltaparent(rev)
 heads.add(rev)
 try:
 compression = ts / r.end(rev)
 except ZeroDivisionError:
 compression = 0
-ui.write("%5d %5d %5d %5d %5d %10d %4d %4d %4d %7d %9d "
+ui.write(
-"%11d %5d %8d\n" %
+"%5d %5d %5d %5d %5d %10d %4d %4d %4d %7d %9d "
-(rev, p1, p2, r.start(rev), r.end(rev),
+"%11d %5d %8d\n"
-r.start(dbase), r.start(cbase),
+% (
-r.start(p1), r.start(p2),
+rev,
-rs, ts, compression, len(heads), clen))
+p1,
+p2,
+r.start(rev),
+r.end(rev),
+r.start(dbase),
+r.start(cbase),
+r.start(p1),
+r.start(p2),
+rs,
+ts,
+compression,
+len(heads),
+clen,
+)
+)
 return 0
 v = r.version
 format = v & 0xFFFF
 flags = []
 basedfmtstr = '%%%dd\n'
 basepcfmtstr = '%%%dd %s(%%5.2f%%%%)\n'
 def dfmtstr(max):
 return basedfmtstr % len(str(max))
 def pcfmtstr(max, padding=0):
 return basepcfmtstr % (len(str(max)), ' ' * padding)
 def pcfmt(value, total):
 if total:
 return (value, 100 * float(value) / total)
 else:
 return value, 100.0
-ui.write(('format : %d\n') % format)
+ui.write('format : %d\n' % format)
-ui.write(('flags  : %s\n') % ', '.join(flags))
+ui.write('flags  : %s\n' % ', '.join(flags))
 ui.write('\n')
 fmt = pcfmtstr(totalsize)
 fmt2 = dfmtstr(totalsize)
-ui.write(('revisions     : ') + fmt2 % numrevs)
+ui.write('revisions     : ' + fmt2 % numrevs)
-ui.write(('    merges    : ') + fmt % pcfmt(nummerges, numrevs))
+ui.write('    merges    : ' + fmt % pcfmt(nummerges, numrevs))
-ui.write(('    normal    : ') + fmt % pcfmt(numrevs - nummerges, numrevs))
+ui.write('    normal    : ' + fmt % pcfmt(numrevs - nummerges, numrevs))
-ui.write(('revisions     : ') + fmt2 % numrevs)
+ui.write('revisions     : ' + fmt2 % numrevs)
-ui.write(('    empty     : ') + fmt % pcfmt(numempty, numrevs))
+ui.write('    empty     : ' + fmt % pcfmt(numempty, numrevs))
-ui.write(('                   text  : ')
+ui.write(
-+ fmt % pcfmt(numemptytext, numemptytext + numemptydelta))
+'                   text  : '
-ui.write(('                   delta : ')
++ fmt % pcfmt(numemptytext, numemptytext + numemptydelta)
-+ fmt % pcfmt(numemptydelta, numemptytext + numemptydelta))
+)
-ui.write(('    snapshot  : ') + fmt % pcfmt(numfull + numsemi, numrevs))
+ui.write(
+'                   delta : '
++ fmt % pcfmt(numemptydelta, numemptytext + numemptydelta)
+)
+ui.write('    snapshot  : ' + fmt % pcfmt(numfull + numsemi, numrevs))
 for depth in sorted(numsnapdepth):
-ui.write(('      lvl-%-3d :       ' % depth)
+ui.write(
-+ fmt % pcfmt(numsnapdepth[depth], numrevs))
+('      lvl-%-3d :       ' % depth)
-ui.write(('    deltas    : ') + fmt % pcfmt(numdeltas, numrevs))
++ fmt % pcfmt(numsnapdepth[depth], numrevs)
-ui.write(('revision size : ') + fmt2 % totalsize)
+)
-ui.write(('    snapshot  : ')
+ui.write('    deltas    : ' + fmt % pcfmt(numdeltas, numrevs))
-+ fmt % pcfmt(fulltotal + semitotal, totalsize))
+ui.write('revision size : ' + fmt2 % totalsize)
+ui.write('    snapshot  : ' + fmt % pcfmt(fulltotal + semitotal, totalsize))
 for depth in sorted(numsnapdepth):
-ui.write(('      lvl-%-3d :       ' % depth)
+ui.write(
-+ fmt % pcfmt(snaptotal[depth], totalsize))
+('      lvl-%-3d :       ' % depth)
-ui.write(('    deltas    : ') + fmt % pcfmt(deltatotal, totalsize))
++ fmt % pcfmt(snaptotal[depth], totalsize)
+)
+ui.write('    deltas    : ' + fmt % pcfmt(deltatotal, totalsize))
 def fmtchunktype(chunktype):
 if chunktype == 'empty':
 return '    %s     : ' % chunktype
 elif chunktype in pycompat.bytestr(string.ascii_letters):
 return '    0x%s (%s)  : ' % (hex(chunktype), chunktype)
 else:
 return '    0x%s      : ' % hex(chunktype)
 ui.write('\n')
-ui.write(('chunks        : ') + fmt2 % numrevs)
+ui.write('chunks        : ' + fmt2 % numrevs)
 for chunktype in sorted(chunktypecounts):
 ui.write(fmtchunktype(chunktype))
 ui.write(fmt % pcfmt(chunktypecounts[chunktype], numrevs))
-ui.write(('chunks size   : ') + fmt2 % totalsize)
+ui.write('chunks size   : ' + fmt2 % totalsize)
 for chunktype in sorted(chunktypecounts):
 ui.write(fmtchunktype(chunktype))
 ui.write(fmt % pcfmt(chunktypesizes[chunktype], totalsize))
 ui.write('\n')
 fmt = dfmtstr(max(avgchainlen, maxchainlen, maxchainspan, compratio))
-ui.write(('avg chain length  : ') + fmt % avgchainlen)
+ui.write('avg chain length  : ' + fmt % avgchainlen)
-ui.write(('max chain length  : ') + fmt % maxchainlen)
+ui.write('max chain length  : ' + fmt % maxchainlen)
-ui.write(('max chain reach   : ') + fmt % maxchainspan)
+ui.write('max chain reach   : ' + fmt % maxchainspan)
-ui.write(('compression ratio : ') + fmt % compratio)
+ui.write('compression ratio : ' + fmt % compratio)
 if format > 0:
 ui.write('\n')
-ui.write(('uncompressed data size (min/max/avg) : %d / %d / %d\n')
+ui.write(
-% tuple(datasize))
+'uncompressed data size (min/max/avg) : %d / %d / %d\n'
-ui.write(('full revision size (min/max/avg)     : %d / %d / %d\n')
+% tuple(datasize)
-% tuple(fullsize))
+)
-ui.write(('inter-snapshot size (min/max/avg)    : %d / %d / %d\n')
+ui.write(
-% tuple(semisize))
+'full revision size (min/max/avg)     : %d / %d / %d\n'
+% tuple(fullsize)
+)
+ui.write(
+'inter-snapshot size (min/max/avg)    : %d / %d / %d\n'
+% tuple(semisize)
+)
 for depth in sorted(snapsizedepth):
 if depth == 0:
 continue
-ui.write(('    level-%-3d (min/max/avg)          : %d / %d / %d\n')
+ui.write(
-% ((depth,) + tuple(snapsizedepth[depth])))
+'    level-%-3d (min/max/avg)          : %d / %d / %d\n'
-ui.write(('delta size (min/max/avg)             : %d / %d / %d\n')
+% ((depth,) + tuple(snapsizedepth[depth]))
-% tuple(deltasize))
+)
+ui.write(
+'delta size (min/max/avg)             : %d / %d / %d\n'
+% tuple(deltasize)
+)
 if numdeltas > 0:
 ui.write('\n')
 fmt = pcfmtstr(numdeltas)
 fmt2 = pcfmtstr(numdeltas, 4)
-ui.write(('deltas against prev  : ') + fmt % pcfmt(numprev, numdeltas))
+ui.write('deltas against prev  : ' + fmt % pcfmt(numprev, numdeltas))
 if numprev > 0:
-ui.write(('    where prev = p1  : ') + fmt2 % pcfmt(nump1prev,
+ui.write(
-numprev))
+'    where prev = p1  : ' + fmt2 % pcfmt(nump1prev, numprev)
-ui.write(('    where prev = p2  : ') + fmt2 % pcfmt(nump2prev,
+)
-numprev))
+ui.write(
-ui.write(('    other            : ') + fmt2 % pcfmt(numoprev,
+'    where prev = p2  : ' + fmt2 % pcfmt(nump2prev, numprev)
-numprev))
+)
+ui.write(
+'    other            : ' + fmt2 % pcfmt(numoprev, numprev)
+)
 if gdelta:
-ui.write(('deltas against p1    : ')
+ui.write('deltas against p1    : ' + fmt % pcfmt(nump1, numdeltas))
-+ fmt % pcfmt(nump1, numdeltas))
+ui.write('deltas against p2    : ' + fmt % pcfmt(nump2, numdeltas))
-ui.write(('deltas against p2    : ')
+ui.write(
-+ fmt % pcfmt(nump2, numdeltas))
+'deltas against other : ' + fmt % pcfmt(numother, numdeltas)
-ui.write(('deltas against other : ') + fmt % pcfmt(numother,
+)
-numdeltas))
-@command('debugrevlogindex', cmdutil.debugrevlogopts +
+@command(
-[('f', 'format', 0, _('revlog format'), _('FORMAT'))],
+'debugrevlogindex',
+cmdutil.debugrevlogopts
++ [('f', 'format', 0, _('revlog format'), _('FORMAT'))],
 _('[-f FORMAT] -c|-m|FILE'),
-optionalrepo=True)
+optionalrepo=True,
+)
 def debugrevlogindex(ui, repo, file_=None, **opts):
 """dump the contents of a revlog index"""
 opts = pycompat.byteskwargs(opts)
 r = cmdutil.openrevlog(repo, 'debugrevlogindex', file_, opts)
 format = opts.get('format', 0)
 idlen = len(shortfn(r.node(i)))
 break
 if format == 0:
 if ui.verbose:
-ui.write(("   rev    offset  length linkrev"
+ui.write(
-" %s %s p2\n") % ("nodeid".ljust(idlen),
+("   rev    offset  length linkrev" " %s %s p2\n")
-"p1".ljust(idlen)))
+% ("nodeid".ljust(idlen), "p1".ljust(idlen))
+)
 else:
-ui.write(("   rev linkrev %s %s p2\n") % (
+ui.write(
-"nodeid".ljust(idlen), "p1".ljust(idlen)))
+"   rev linkrev %s %s p2\n"
+% ("nodeid".ljust(idlen), "p1".ljust(idlen))
+)
 elif format == 1:
 if ui.verbose:
-ui.write(("   rev flag   offset   length     size   link     p1"
+ui.write(
-"     p2 %s\n") % "nodeid".rjust(idlen))
+(
+"   rev flag   offset   length     size   link     p1"
+"     p2 %s\n"
+)
+% "nodeid".rjust(idlen)
+)
 else:
-ui.write(("   rev flag     size   link     p1     p2 %s\n") %
+ui.write(
-"nodeid".rjust(idlen))
+"   rev flag     size   link     p1     p2 %s\n"
+% "nodeid".rjust(idlen)
+)
 for i in r:
 node = r.node(i)
 if format == 0:
 try:
 pp = r.parents(node)
 except Exception:
 pp = [nullid, nullid]
 if ui.verbose:
-ui.write("% 6d % 9d % 7d % 7d %s %s %s\n" % (
+ui.write(
-i, r.start(i), r.length(i), r.linkrev(i),
+"% 6d % 9d % 7d % 7d %s %s %s\n"
-shortfn(node), shortfn(pp[0]), shortfn(pp[1])))
+% (
+i,
+r.start(i),
+r.length(i),
+r.linkrev(i),
+shortfn(node),
+shortfn(pp[0]),
+shortfn(pp[1]),
+)
+)
 else:
-ui.write("% 6d % 7d %s %s %s\n" % (
+ui.write(
-i, r.linkrev(i), shortfn(node), shortfn(pp[0]),
+"% 6d % 7d %s %s %s\n"
-shortfn(pp[1])))
+% (
+i,
+r.linkrev(i),
+shortfn(node),
+shortfn(pp[0]),
+shortfn(pp[1]),
+)
+)
 elif format == 1:
 pr = r.parentrevs(i)
 if ui.verbose:
-ui.write("% 6d %04x % 8d % 8d % 8d % 6d % 6d % 6d %s\n" % (
+ui.write(
-i, r.flags(i), r.start(i), r.length(i), r.rawsize(i),
+"% 6d %04x % 8d % 8d % 8d % 6d % 6d % 6d %s\n"
-r.linkrev(i), pr[0], pr[1], shortfn(node)))
+% (
+i,
+r.flags(i),
+r.start(i),
+r.length(i),
+r.rawsize(i),
+r.linkrev(i),
+pr[0],
+pr[1],
+shortfn(node),
+)
+)
 else:
-ui.write("% 6d %04x % 8d % 6d % 6d % 6d %s\n" % (
+ui.write(
-i, r.flags(i), r.rawsize(i), r.linkrev(i), pr[0], pr[1],
+"% 6d %04x % 8d % 6d % 6d % 6d %s\n"
-shortfn(node)))
+% (
+i,
-@command('debugrevspec',
+r.flags(i),
-[('', 'optimize', None,
+r.rawsize(i),
-_('print parsed tree after optimizing (DEPRECATED)')),
+r.linkrev(i),
-('', 'show-revs', True, _('print list of result revisions (default)')),
+pr[0],
-('s', 'show-set', None, _('print internal representation of result set')),
+pr[1],
-('p', 'show-stage', [],
+shortfn(node),
-_('print parsed tree at the given stage'), _('NAME')),
+)
-('', 'no-optimized', False, _('evaluate tree without optimization')),
+)
-('', 'verify-optimized', False, _('verify optimized result')),
-],
-('REVSPEC'))
+@command(
+'debugrevspec',
+[
+(
+'',
+'optimize',
+None,
+_('print parsed tree after optimizing (DEPRECATED)'),
+),
+('', 'show-revs', True, _('print list of result revisions (default)')),
+(
+'s',
+'show-set',
+None,
+_('print internal representation of result set'),
+),
+(
+'p',
+'show-stage',
+[],
+_('print parsed tree at the given stage'),
+_('NAME'),
+),
+('', 'no-optimized', False, _('evaluate tree without optimization')),
+('', 'verify-optimized', False, _('verify optimized result')),
+],
+'REVSPEC',
+)
 def debugrevspec(ui, repo, expr, **opts):
 """parse and apply a revision specification
 Use -p/--show-stage option to print the parsed tree at the given stages.
 Use -p all to print tree at every stage.
 """
 opts = pycompat.byteskwargs(opts)
 aliases = ui.configitems('revsetalias')
 stages = [
 ('parsed', lambda tree: tree),
-('expanded', lambda tree: revsetlang.expandaliases(tree, aliases,
+(
-ui.warn)),
+'expanded',
+lambda tree: revsetlang.expandaliases(tree, aliases, ui.warn),
+),
 ('concatenated', revsetlang.foldconcat),
 ('analyzed', revsetlang.analyze),
 ('optimized', revsetlang.optimize),
 ]
 if opts['no_optimized']:
 stages = stages[:-1]
 if opts['verify_optimized'] and opts['no_optimized']:
-raise error.Abort(_('cannot use --verify-optimized with '
+raise error.Abort(
-'--no-optimized'))
+_('cannot use --verify-optimized with ' '--no-optimized')
+)
 stagenames = set(n for n, f in stages)
 showalways = set()
 showchanged = set()
 if ui.verbose and not opts['show_stage']:
 tree = revsetlang.parse(expr, lookup=revset.lookupfn(repo))
 for n, f in stages:
 treebystage[n] = tree = f(tree)
 if n in showalways or (n in showchanged and tree != printedtree):
 if opts['show_stage'] or n != 'parsed':
-ui.write(("* %s:\n") % n)
+ui.write("* %s:\n" % n)
 ui.write(revsetlang.prettyformat(tree), "\n")
 printedtree = tree
 if opts['verify_optimized']:
 arevs = revset.makematcher(treebystage['analyzed'])(repo)
 brevs = revset.makematcher(treebystage['optimized'])(repo)
 if opts['show_set'] or (opts['show_set'] is None and ui.verbose):
-ui.write(("* analyzed set:\n"), stringutil.prettyrepr(arevs), "\n")
+ui.write("* analyzed set:\n", stringutil.prettyrepr(arevs), "\n")
-ui.write(("* optimized set:\n"), stringutil.prettyrepr(brevs), "\n")
+ui.write("* optimized set:\n", stringutil.prettyrepr(brevs), "\n")
 arevs = list(arevs)
 brevs = list(brevs)
 if arevs == brevs:
 return 0
-ui.write(('--- analyzed\n'), label='diff.file_a')
+ui.write('--- analyzed\n', label='diff.file_a')
-ui.write(('+++ optimized\n'), label='diff.file_b')
+ui.write('+++ optimized\n', label='diff.file_b')
 sm = difflib.SequenceMatcher(None, arevs, brevs)
 for tag, alo, ahi, blo, bhi in sm.get_opcodes():
 if tag in (r'delete', r'replace'):
 for c in arevs[alo:ahi]:
 ui.write('-%d\n' % c, label='diff.deleted')
 return 1
 func = revset.makematcher(tree)
 revs = func(repo)
 if opts['show_set'] or (opts['show_set'] is None and ui.verbose):
-ui.write(("* set:\n"), stringutil.prettyrepr(revs), "\n")
+ui.write("* set:\n", stringutil.prettyrepr(revs), "\n")
 if not opts['show_revs']:
 return
 for c in revs:
 ui.write("%d\n" % c)
-@command('debugserve', [
-('', 'sshstdio', False, _('run an SSH server bound to process handles')),
+@command(
-('', 'logiofd', '', _('file descriptor to log server I/O to')),
+'debugserve',
-('', 'logiofile', '', _('file to log server I/O to')),
+[
-], '')
+(
+'',
+'sshstdio',
+False,
+_('run an SSH server bound to process handles'),
+),
+('', 'logiofd', '', _('file descriptor to log server I/O to')),
+('', 'logiofile', '', _('file to log server I/O to')),
+],
+'',
+)
 def debugserve(ui, repo, **opts):
 """run a server with advanced settings
 This command is similar to :hg:`serve`. It exists partially as a
 workaround to the fact that ``hg serve --stdio`` must have specific
 logfh = open(opts['logiofile'], 'ab', 1)
 s = wireprotoserver.sshserver(ui, repo, logfh=logfh)
 s.serve_forever()
 @command('debugsetparents', [], _('REV1 [REV2]'))
 def debugsetparents(ui, repo, rev1, rev2=None):
 """manually set the parents of the current working directory
 This is useful for writing repository conversion tools, but should
 node1 = scmutil.revsingle(repo, rev1).node()
 node2 = scmutil.revsingle(repo, rev2, 'null').node()
 with repo.wlock():
 repo.setparents(node1, node2)
 @command('debugsidedata', cmdutil.debugrevlogopts, _('-c|-m|FILE REV'))
 def debugsidedata(ui, repo, file_, rev=None, **opts):
 """dump the side data for a cl/manifest/file revision"""
 opts = pycompat.byteskwargs(opts)
 for key, value in sidedata:
 ui.write((' entry-%04o size %d\n' % (key, len(value))))
 if ui.verbose:
 ui.write(('  %s\n' % stringutil.pprint(value)))
 @command('debugssl', [], '[SOURCE]', optionalrepo=True)
 def debugssl(ui, repo, source=None, **opts):
 '''test a secure connection to a server
 This builds the certificate chain for the server on Windows, installing the
 If the update succeeds, retry the original operation.  Otherwise, the cause
 of the SSL error is likely another issue.
 '''
 if not pycompat.iswindows:
-raise error.Abort(_('certificate chain building is only possible on '
+raise error.Abort(
-'Windows'))
+_('certificate chain building is only possible on ' 'Windows')
+)
 if not source:
 if not repo:
-raise error.Abort(_("there is no Mercurial repository here, and no "
+raise error.Abort(
-"server specified"))
+_(
+"there is no Mercurial repository here, and no "
+"server specified"
+)
+)
 source = "default"
 source, branches = hg.parseurl(ui.expandpath(source))
 url = util.url(source)
 else:
 raise error.Abort(_("only https and ssh connections are supported"))
 from . import win32
-s = ssl.wrap_socket(socket.socket(), ssl_version=ssl.PROTOCOL_TLS,
+s = ssl.wrap_socket(
-cert_reqs=ssl.CERT_NONE, ca_certs=None)
+socket.socket(),
+ssl_version=ssl.PROTOCOL_TLS,
+cert_reqs=ssl.CERT_NONE,
+ca_certs=None,
+)
 try:
 s.connect(addr)
 cert = s.getpeercert(True)
 else:
 ui.status(_('full certificate chain is available\n'))
 finally:
 s.close()
-@command('debugsub',
-[('r', 'rev', '',
+@command(
-_('revision to check'), _('REV'))],
+'debugsub',
-_('[-r REV] [REV]'))
+[('r', 'rev', '', _('revision to check'), _('REV'))],
+_('[-r REV] [REV]'),
+)
 def debugsub(ui, repo, rev=None):
 ctx = scmutil.revsingle(repo, rev, None)
 for k, v in sorted(ctx.substate.items()):
-ui.write(('path %s\n') % k)
+ui.write('path %s\n' % k)
-ui.write((' source   %s\n') % v[0])
+ui.write(' source   %s\n' % v[0])
-ui.write((' revision %s\n') % v[1])
+ui.write(' revision %s\n' % v[1])
-@command('debugsuccessorssets',
+@command(
+'debugsuccessorssets',
 [('', 'closest', False, _('return closest successors sets only'))],
-_('[REV]'))
+_('[REV]'),
+)
 def debugsuccessorssets(ui, repo, *revs, **opts):
 """show set of successors for revision
 A successors set of changeset A is a consistent group of revisions that
 succeed A. It contains non-obsolete changesets only unless closests
 cache = {}
 ctx2str = bytes
 node2str = short
 for rev in scmutil.revrange(repo, revs):
 ctx = repo[rev]
-ui.write('%s\n'% ctx2str(ctx))
+ui.write('%s\n' % ctx2str(ctx))
-for succsset in obsutil.successorssets(repo, ctx.node(),
+for succsset in obsutil.successorssets(
-closest=opts[r'closest'],
+repo, ctx.node(), closest=opts[r'closest'], cache=cache
-cache=cache):
+):
 if succsset:
 ui.write('    ')
 ui.write(node2str(succsset[0]))
 for node in succsset[1:]:
 ui.write(' ')
 ui.write(node2str(node))
 ui.write('\n')
-@command('debugtemplate',
-[('r', 'rev', [], _('apply template on changesets'), _('REV')),
+@command(
-('D', 'define', [], _('define template keyword'), _('KEY=VALUE'))],
+'debugtemplate',
+[
+('r', 'rev', [], _('apply template on changesets'), _('REV')),
+('D', 'define', [], _('define template keyword'), _('KEY=VALUE')),
+],
 _('[-r REV]... [-D KEY=VALUE]... TEMPLATE'),
-optionalrepo=True)
+optionalrepo=True,
+)
 def debugtemplate(ui, repo, tmpl, **opts):
 """parse and apply a template
 If -r/--rev is given, the template is processed as a log template and
 applied to the given changesets. Otherwise, it is processed as a generic
 Use --verbose to print the parsed tree.
 """
 revs = None
 if opts[r'rev']:
 if repo is None:
-raise error.RepoError(_('there is no Mercurial repository here '
+raise error.RepoError(
-'(.hg not found)'))
+_('there is no Mercurial repository here ' '(.hg not found)')
+)
 revs = scmutil.revrange(repo, opts[r'rev'])
 props = {}
 for d in opts[r'define']:
 try:
 aliases = ui.configitems('templatealias')
 tree = templater.parse(tmpl)
 ui.note(templater.prettyformat(tree), '\n')
 newtree = templater.expandaliases(tree, aliases)
 if newtree != tree:
-ui.note(("* expanded:\n"), templater.prettyformat(newtree), '\n')
+ui.note("* expanded:\n", templater.prettyformat(newtree), '\n')
 if revs is None:
 tres = formatter.templateresources(ui, repo)
 t = formatter.maketemplater(ui, tmpl, resources=tres)
 if ui.verbose:
 kwds, funcs = t.symbolsuseddefault()
-ui.write(("* keywords: %s\n") % ', '.join(sorted(kwds)))
+ui.write("* keywords: %s\n" % ', '.join(sorted(kwds)))
-ui.write(("* functions: %s\n") % ', '.join(sorted(funcs)))
+ui.write("* functions: %s\n" % ', '.join(sorted(funcs)))
 ui.write(t.renderdefault(props))
 else:
 displayer = logcmdutil.maketemplater(ui, repo, tmpl)
 if ui.verbose:
 kwds, funcs = displayer.t.symbolsuseddefault()
-ui.write(("* keywords: %s\n") % ', '.join(sorted(kwds)))
+ui.write("* keywords: %s\n" % ', '.join(sorted(kwds)))
-ui.write(("* functions: %s\n") % ', '.join(sorted(funcs)))
+ui.write("* functions: %s\n" % ', '.join(sorted(funcs)))
 for r in revs:
 displayer.show(repo[r], **pycompat.strkwargs(props))
 displayer.close()
-@command('debuguigetpass', [
-('p', 'prompt', '', _('prompt text'), _('TEXT')),
+@command(
-], _('[-p TEXT]'), norepo=True)
+'debuguigetpass',
+[('p', 'prompt', '', _('prompt text'), _('TEXT')),],
+_('[-p TEXT]'),
+norepo=True,
+)
 def debuguigetpass(ui, prompt=''):
 """show prompt to type password"""
 r = ui.getpass(prompt)
-ui.write(('respose: %s\n') % r)
+ui.write('respose: %s\n' % r)
-@command('debuguiprompt', [
-('p', 'prompt', '', _('prompt text'), _('TEXT')),
+@command(
-], _('[-p TEXT]'), norepo=True)
+'debuguiprompt',
+[('p', 'prompt', '', _('prompt text'), _('TEXT')),],
+_('[-p TEXT]'),
+norepo=True,
+)
 def debuguiprompt(ui, prompt=''):
 """show plain prompt"""
 r = ui.prompt(prompt)
-ui.write(('response: %s\n') % r)
+ui.write('response: %s\n' % r)
 @command('debugupdatecaches', [])
 def debugupdatecaches(ui, repo, *pats, **opts):
 """warm all known caches in the repository"""
 with repo.wlock(), repo.lock():
 repo.updatecaches(full=True)
-@command('debugupgraderepo', [
-('o', 'optimize', [], _('extra optimization to perform'), _('NAME')),
+@command(
-('', 'run', False, _('performs an upgrade')),
+'debugupgraderepo',
-('', 'backup', True, _('keep the old repository content around')),
+[
-('', 'changelog', None, _('select the changelog for upgrade')),
+('o', 'optimize', [], _('extra optimization to perform'), _('NAME')),
-('', 'manifest', None, _('select the manifest for upgrade')),
+('', 'run', False, _('performs an upgrade')),
-])
+('', 'backup', True, _('keep the old repository content around')),
+('', 'changelog', None, _('select the changelog for upgrade')),
+('', 'manifest', None, _('select the manifest for upgrade')),
+],
+)
 def debugupgraderepo(ui, repo, run=False, optimize=None, backup=True, **opts):
 """upgrade a repository to use different features
 If no arguments are specified, the repository is evaluated for upgrade
 and a list of problems and potential optimizations is printed.
 * `--manifest`: only optimize the manifest
 * `--no-manifest`: optimize all revlog but the manifest
 * `--changelog`: optimize the changelog only
 * `--no-changelog --no-manifest`: optimize filelogs only
 """
-return upgrade.upgraderepo(ui, repo, run=run, optimize=optimize,
+return upgrade.upgraderepo(
-backup=backup, **opts)
+ui, repo, run=run, optimize=optimize, backup=backup, **opts
+)
-@command('debugwalk', cmdutil.walkopts, _('[OPTION]... [FILE]...'),
-inferrepo=True)
+@command(
+'debugwalk', cmdutil.walkopts, _('[OPTION]... [FILE]...'), inferrepo=True
+)
 def debugwalk(ui, repo, *pats, **opts):
 """show how files match on given patterns"""
 opts = pycompat.byteskwargs(opts)
 m = scmutil.match(repo[None], pats, opts)
 if ui.verbose:
-ui.write(('* matcher:\n'), stringutil.prettyrepr(m), '\n')
+ui.write('* matcher:\n', stringutil.prettyrepr(m), '\n')
 items = list(repo[None].walk(m))
 if not items:
 return
 f = lambda fn: fn
 if ui.configbool('ui', 'slash') and pycompat.ossep != '/':
 f = lambda fn: util.normpath(fn)
 fmt = 'f  %%-%ds  %%-%ds  %%s' % (
 max([len(abs) for abs in items]),
-max([len(repo.pathto(abs)) for abs in items]))
+max([len(repo.pathto(abs)) for abs in items]),
+)
 for abs in items:
 line = fmt % (abs, f(repo.pathto(abs)), m.exact(abs) and 'exact' or '')
 ui.write("%s\n" % line.rstrip())
 @command('debugwhyunstable', [], _('REV'))
 def debugwhyunstable(ui, repo, rev):
 """explain instabilities of a changeset"""
 for entry in obsutil.whyunstable(repo, scmutil.revsingle(repo, rev)):
 dnodes = ''
 if entry.get('divergentnodes'):
-dnodes = ' '.join('%s (%s)' % (ctx.hex(), ctx.phasestr())
+dnodes = (
-for ctx in entry['divergentnodes']) + ' '
+' '.join(
-ui.write('%s: %s%s %s\n' % (entry['instability'], dnodes,
+'%s (%s)' % (ctx.hex(), ctx.phasestr())
-entry['reason'], entry['node']))
+for ctx in entry['divergentnodes']
+)
-@command('debugwireargs',
++ ' '
-[('', 'three', '', 'three'),
+)
-('', 'four', '', 'four'),
+ui.write(
-('', 'five', '', 'five'),
+'%s: %s%s %s\n'
-] + cmdutil.remoteopts,
+% (entry['instability'], dnodes, entry['reason'], entry['node'])
+)
+@command(
+'debugwireargs',
+[
+('', 'three', '', 'three'),
+('', 'four', '', 'four'),
+('', 'five', '', 'five'),
+]
++ cmdutil.remoteopts,
 _('REPO [OPTIONS]... [ONE [TWO]]'),
-norepo=True)
+norepo=True,
+)
 def debugwireargs(ui, repopath, *vals, **opts):
 opts = pycompat.byteskwargs(opts)
 repo = hg.peer(ui, opts, repopath)
 for opt in cmdutil.remoteopts:
 del opts[opt[1]]
 res2 = repo.debugwireargs(*vals, **args)
 ui.write("%s\n" % res1)
 if res1 != res2:
 ui.warn("%s\n" % res2)
 def _parsewirelangblocks(fh):
 activeaction = None
 blocklines = []
 lastindent = 0
 # Flush last block.
 if activeaction:
 yield activeaction, blocklines
-@command('debugwireproto',
+@command(
+'debugwireproto',
 [
 ('', 'localssh', False, _('start an SSH server for this repo')),
 ('', 'peer', '', _('construct a specific version of the peer')),
 ('', 'noreadstderr', False, _('do not read from stderr of the remote')),
-('', 'nologhandshake', False,
+(
-_('do not log I/O related to the peer handshake')),
+'',
-] + cmdutil.remoteopts,
+'nologhandshake',
+False,
+_('do not log I/O related to the peer handshake'),
+),
+]
++ cmdutil.remoteopts,
 _('[PATH]'),
-optionalrepo=True)
+optionalrepo=True,
+)
 def debugwireproto(ui, repo, path=None, **opts):
 """send wire protocol commands to a server
 This command can be used to issue wire protocol commands to remote
 peers and to debug the raw data being exchanged.
 if opts['localssh'] and not repo:
 raise error.Abort(_('--localssh requires a repository'))
 if opts['peer'] and opts['peer'] not in ('raw', 'http2', 'ssh1', 'ssh2'):
-raise error.Abort(_('invalid value for --peer'),
+raise error.Abort(
-hint=_('valid values are "raw", "ssh1", and "ssh2"'))
+_('invalid value for --peer'),
+hint=_('valid values are "raw", "ssh1", and "ssh2"'),
+)
 if path and opts['localssh']:
-raise error.Abort(_('cannot specify --localssh with an explicit '
+raise error.Abort(
-'path'))
+_('cannot specify --localssh with an explicit ' 'path')
+)
 if ui.interactive():
 ui.write(_('(waiting for commands on stdin)\n'))
 blocks = list(_parsewirelangblocks(ui.fin))
 if opts['localssh']:
 # We start the SSH server in its own process so there is process
 # separation. This prevents a whole class of potential bugs around
 # shared state from interfering with server operation.
 args = procutil.hgcmd() + [
-'-R', repo.root,
+'-R',
-'debugserve', '--sshstdio',
+repo.root,
+'debugserve',
+'--sshstdio',
 ]
-proc = subprocess.Popen(pycompat.rapply(procutil.tonativestr, args),
+proc = subprocess.Popen(
-stdin=subprocess.PIPE,
+pycompat.rapply(procutil.tonativestr, args),
-stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+stdin=subprocess.PIPE,
-bufsize=0)
+stdout=subprocess.PIPE,
+stderr=subprocess.PIPE,
+bufsize=0,
+)
 stdin = proc.stdin
 stdout = proc.stdout
 stderr = proc.stderr
 # We turn the pipes into observers so we can log I/O.
 if ui.verbose or opts['peer'] == 'raw':
-stdin = util.makeloggingfileobject(ui, proc.stdin, b'i',
+stdin = util.makeloggingfileobject(
-logdata=True)
+ui, proc.stdin, b'i', logdata=True
-stdout = util.makeloggingfileobject(ui, proc.stdout, b'o',
+)
-logdata=True)
+stdout = util.makeloggingfileobject(
-stderr = util.makeloggingfileobject(ui, proc.stderr, b'e',
+ui, proc.stdout, b'o', logdata=True
-logdata=True)
+)
+stderr = util.makeloggingfileobject(
+ui, proc.stderr, b'e', logdata=True
+)
 # --localssh also implies the peer connection settings.
 url = 'ssh://localserver'
 autoreadstderr = not opts['noreadstderr']
 if opts['peer'] == 'ssh1':
 ui.write(_('creating ssh peer for wire protocol version 1\n'))
-peer = sshpeer.sshv1peer(ui, url, proc, stdin, stdout, stderr,
+peer = sshpeer.sshv1peer(
-None, autoreadstderr=autoreadstderr)
+ui,
+url,
+proc,
+stdin,
+stdout,
+stderr,
+None,
+autoreadstderr=autoreadstderr,
+)
 elif opts['peer'] == 'ssh2':
 ui.write(_('creating ssh peer for wire protocol version 2\n'))
-peer = sshpeer.sshv2peer(ui, url, proc, stdin, stdout, stderr,
+peer = sshpeer.sshv2peer(
-None, autoreadstderr=autoreadstderr)
+ui,
+url,
+proc,
+stdin,
+stdout,
+stderr,
+None,
+autoreadstderr=autoreadstderr,
+)
 elif opts['peer'] == 'raw':
 ui.write(_('using raw connection to peer\n'))
 peer = None
 else:
 ui.write(_('creating ssh peer from handshake results\n'))
-peer = sshpeer.makepeer(ui, url, proc, stdin, stdout, stderr,
+peer = sshpeer.makepeer(
-autoreadstderr=autoreadstderr)
+ui,
+url,
+proc,
+stdin,
+stdout,
+stderr,
+autoreadstderr=autoreadstderr,
+)
 elif path:
 # We bypass hg.peer() so we can proxy the sockets.
 # TODO consider not doing this because we skip
 # ``hg.wirepeersetupfuncs`` and potentially other useful functionality.
 r'useragent': b'Mercurial debugwireproto',
 }
 # Turn pipes/sockets into observers so we can log I/O.
 if ui.verbose:
-openerargs.update({
+openerargs.update(
-r'loggingfh': ui,
+{
-r'loggingname': b's',
+r'loggingfh': ui,
-r'loggingopts': {
+r'loggingname': b's',
-r'logdata': True,
+r'loggingopts': {r'logdata': True, r'logdataapis': False,},
-r'logdataapis': False,
+}
-},
+)
-})
 if ui.debugflag:
 openerargs[r'loggingopts'][r'logdataapis'] = True
 # Don't send default headers when in raw mode. This allows us to
 if opts['peer'] == 'http2':
 ui.write(_('creating http peer for wire protocol version 2\n'))
 # We go through makepeer() because we need an API descriptor for
 # the peer instance to be useful.
-with ui.configoverride({
+with ui.configoverride(
-('experimental', 'httppeer.advertise-v2'): True}):
+{('experimental', 'httppeer.advertise-v2'): True}
+):
 if opts['nologhandshake']:
 ui.pushbuffer()
 peer = httppeer.makepeer(ui, path, opener=opener)
 if opts['nologhandshake']:
 ui.popbuffer()
 if not isinstance(peer, httppeer.httpv2peer):
-raise error.Abort(_('could not instantiate HTTP peer for '
+raise error.Abort(
-'wire protocol version 2'),
+_(
-hint=_('the server may not have the feature '
+'could not instantiate HTTP peer for '
-'enabled or is not allowing this '
+'wire protocol version 2'
-'client version'))
+),
+hint=_(
+'the server may not have the feature '
+'enabled or is not allowing this '
+'client version'
+),
+)
 elif opts['peer'] == 'raw':
 ui.write(_('using raw connection to peer\n'))
 peer = None
 elif opts['peer']:
-raise error.Abort(_('--peer %s not supported with HTTP peers') %
+raise error.Abort(
-opts['peer'])
+_('--peer %s not supported with HTTP peers') % opts['peer']
+)
 else:
 peer = httppeer.makepeer(ui, path, opener=opener)
 # We /could/ populate stdin/stdout with sock.makefile()...
 else:
 if not stdin:
 raise error.Abort(_('cannot call flush on this peer'))
 stdin.flush()
 elif action.startswith('command'):
 if not peer:
-raise error.Abort(_('cannot send commands unless peer instance '
+raise error.Abort(
-'is available'))
+_(
+'cannot send commands unless peer instance '
+'is available'
+)
+)
 command = action.split(' ', 1)[1]
 args = {}
 for line in lines:
 ui.status(_('sending %s command\n') % command)
 if 'PUSHFILE' in args:
 with open(args['PUSHFILE'], r'rb') as fh:
 del args['PUSHFILE']
-res, output = peer._callpush(command, fh,
+res, output = peer._callpush(
-**pycompat.strkwargs(args))
+command, fh, **pycompat.strkwargs(args)
+)
 ui.status(_('result: %s\n') % stringutil.escapestr(res))
-ui.status(_('remote output: %s\n') %
+ui.status(
-stringutil.escapestr(output))
+_('remote output: %s\n') % stringutil.escapestr(output)
+)
 else:
 with peer.commandexecutor() as e:
 res = e.callcommand(command, args).result()
 if isinstance(res, wireprotov2peer.commandresponse):
 val = res.objects()
-ui.status(_('response: %s\n') %
+ui.status(
-stringutil.pprint(val, bprefix=True, indent=2))
+_('response: %s\n')
+% stringutil.pprint(val, bprefix=True, indent=2)
+)
 else:
-ui.status(_('response: %s\n') %
+ui.status(
-stringutil.pprint(res, bprefix=True, indent=2))
+_('response: %s\n')
+% stringutil.pprint(res, bprefix=True, indent=2)
+)
 elif action == 'batchbegin':
 if batchedcommands is not None:
 raise error.Abort(_('nested batchbegin not allowed'))
 batchedcommands = []
 elif action == 'batchsubmit':
 # There is a batching API we could go through. But it would be
 # difficult to normalize requests into function calls. It is easier
 # to bypass this layer and normalize to commands + args.
-ui.status(_('sending batch with %d sub-commands\n') %
+ui.status(
-len(batchedcommands))
+_('sending batch with %d sub-commands\n') % len(batchedcommands)
+)
 for i, chunk in enumerate(peer._submitbatch(batchedcommands)):
-ui.status(_('response #%d: %s\n') %
+ui.status(
-(i, stringutil.escapestr(chunk)))
+_('response #%d: %s\n') % (i, stringutil.escapestr(chunk))
+)
 batchedcommands = None
 elif action.startswith('httprequest '):
 if not opener:
-raise error.Abort(_('cannot use httprequest without an HTTP '
+raise error.Abort(
-'peer'))
+_('cannot use httprequest without an HTTP ' 'peer')
+)
 request = action.split(' ', 2)
 if len(request) != 3:
-raise error.Abort(_('invalid httprequest: expected format is '
+raise error.Abort(
-'"httprequest <method> <path>'))
+_(
+'invalid httprequest: expected format is '
+'"httprequest <method> <path>'
+)
+)
 method, httppath = request[1:]
 headers = {}
 body = None
 frames = []
 if line.startswith(b'BODYFILE '):
 with open(line.split(b' ', 1), 'rb') as fh:
 body = fh.read()
 elif line.startswith(b'frame '):
 frame = wireprotoframing.makeframefromhumanstring(
-line[len(b'frame '):])
+line[len(b'frame ') :]
+)
 frames.append(frame)
 else:
-raise error.Abort(_('unknown argument to httprequest: %s') %
+raise error.Abort(
-line)
+_('unknown argument to httprequest: %s') % line
+)
 url = path + httppath
 if frames:
 body = b''.join(bytes(f) for f in frames)
 getattr(e, 'read', lambda: None)()
 continue
 ct = res.headers.get(r'Content-Type')
 if ct == r'application/mercurial-cbor':
-ui.write(_('cbor> %s\n') %
+ui.write(
-stringutil.pprint(cborutil.decodeall(body),
+_('cbor> %s\n')
-bprefix=True,
+% stringutil.pprint(
-indent=2))
+cborutil.decodeall(body), bprefix=True, indent=2
+)
+)
 elif action == 'close':
 peer.close()
 elif action == 'readavailable':
 if not stdout or not stderr:

changeset 43076	2372284d9457
parent 43067	0fde7d47ad6f
child 43077	687b865b95ad