black: blacken scripts

test-check-format.t doesn't appear to detect Python scripts with shebangs.
But my editor which is configured to auto run black on Python files does
and it appears some files are not blackened.

This commit blackens scripts that need it.

# skip-blame reformatting

Differential Revision: https://phab.mercurial-scm.org/D7420

contrib/check-commit

@@ -1,103 +1,115 b''
 #!/usr/bin/env python
 #
 # Copyright 2014 Matt Mackall <[e-mail]>
 #
 # A tool/hook to run basic sanity checks on commits/patches for
 # submission to Mercurial. Install by adding the following to your
 # .hg/hgrc:
 #
 # [hooks]
 # pretxncommit = contrib/check-commit
 #
 # The hook can be temporarily bypassed with:
 #
 # $ BYPASS= hg commit
 #
 # See also: https://mercurial-scm.org/wiki/ContributingChanges
 
 from __future__ import absolute_import, print_function
 
 import os
 import re
 import sys
 
 commitheader = r"^(?:# [^\n]*\n)*"
 afterheader = commitheader + r"(?!#)"
 beforepatch = afterheader + r"(?!\n(?!@@))"
 
 errors = [
     (beforepatch + r".*[(]bc[)]", "(BC) needs to be uppercase"),
-    (beforepatch + r".*[(]issue \d\d\d",
-     "no space allowed between issue and number"),
+    (
+        beforepatch + r".*[(]issue \d\d\d",
+        "no space allowed between issue and number",
+    ),
     (beforepatch + r".*[(]bug(\d|\s)", "use (issueDDDD) instead of bug"),
     (commitheader + r"# User [^@\n]+\n", "username is not an email address"),
-    (commitheader + r"(?!merge with )[^#]\S+[^:] ",
-     "summary line doesn't start with 'topic: '"),
+    (
+        commitheader + r"(?!merge with )[^#]\S+[^:] ",
+        "summary line doesn't start with 'topic: '",
+    ),
     (afterheader + r"[A-Z][a-z]\S+", "don't capitalize summary lines"),
     (afterheader + r"^\S+: *[A-Z][a-z]\S+", "don't capitalize summary lines"),
-    (afterheader + r"\S*[^A-Za-z0-9-_]\S*: ",
-     "summary keyword should be most user-relevant one-word command or topic"),
+    (
+        afterheader + r"\S*[^A-Za-z0-9-_]\S*: ",
+        "summary keyword should be most user-relevant one-word command or topic",
+    ),
     (afterheader + r".*\.\s*\n", "don't add trailing period on summary line"),
     (afterheader + r".{79,}", "summary line too long (limit is 78)"),
 ]
 
 word = re.compile(r'\S')
+
+
 def nonempty(first, second):
     if word.search(first):
         return first
     return second
 
+
 def checkcommit(commit, node=None):
     exitcode = 0
     printed = node is None
     hits = []
-    signtag = (afterheader +
-          r'Added (tag [^ ]+|signature) for changeset [a-f0-9]{12}')
+    signtag = (
+        afterheader + r'Added (tag [^ ]+|signature) for changeset [a-f0-9]{12}'
+    )
     if re.search(signtag, commit):
         return 0
     for exp, msg in errors:
         for m in re.finditer(exp, commit):
             end = m.end()
             trailing = re.search(r'(\\n)+$', exp)
             if trailing:
                 end -= len(trailing.group()) / 2
             hits.append((end, exp, msg))
     if hits:
         hits.sort()
         pos = 0
         last = ''
         for n, l in enumerate(commit.splitlines(True)):
             pos += len(l)
             while len(hits):
                 end, exp, msg = hits[0]
                 if pos < end:
                     break
                 if not printed:
                     printed = True
                     print("node: %s" % node)
                 print("%d: %s" % (n, msg))
                 print(" %s" % nonempty(l, last)[:-1])
                 if "BYPASS" not in os.environ:
                     exitcode = 1
                 del hits[0]
             last = nonempty(l, last)
 
     return exitcode
 
+
 def readcommit(node):
     return os.popen("hg export %s" % node).read()
 
+
 if __name__ == "__main__":
     exitcode = 0
     node = os.environ.get("HG_NODE")
 
     if node:
         commit = readcommit(node)
         exitcode = checkcommit(commit)
     elif sys.argv[1:]:
         for node in sys.argv[1:]:
             exitcode |= checkcommit(readcommit(node), node)
     else:
         commit = sys.stdin.read()
         exitcode = checkcommit(commit)
     sys.exit(exitcode)

contrib/dumprevlog

@@ -1,44 +1,47 b''
 #!/usr/bin/env python
 # Dump revlogs as raw data stream
 # $ find .hg/store/ -name "*.i" | xargs dumprevlog > repo.dump
 
 from __future__ import absolute_import, print_function
 
 import sys
 from mercurial import (
     encoding,
     node,
     pycompat,
     revlog,
 )
-from mercurial.utils import (
-    procutil,
-)
+from mercurial.utils import procutil
 
 for fp in (sys.stdin, sys.stdout, sys.stderr):
     procutil.setbinary(fp)
 
+
 def binopen(path, mode=b'rb'):
     if b'b' not in mode:
         mode = mode + b'b'
     return open(path, pycompat.sysstr(mode))
+
+
 binopen.options = {}
 
+
 def printb(data, end=b'\n'):
     sys.stdout.flush()
     pycompat.stdout.write(data + end)
 
+
 for f in sys.argv[1:]:
     r = revlog.revlog(binopen, encoding.strtolocal(f))
     print("file:", f)
     for i in r:
         n = r.node(i)
         p = r.parents(n)
         d = r.revision(n)
         printb(b"node: %s" % node.hex(n))
         printb(b"linkrev: %d" % r.linkrev(i))
         printb(b"parents: %s %s" % (node.hex(p[0]), node.hex(p[1])))
         printb(b"length: %d" % len(d))
         printb(b"-start-")
         printb(d)
         printb(b"-end-")

contrib/hg-ssh

@@ -1,97 +1,111 b''
 #!/usr/bin/env python
 #
 # Copyright 2005-2007 by Intevation GmbH <[e-mail]>
 #
 # Author(s):
 # Thomas Arendsen Hein <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 """
 hg-ssh - a wrapper for ssh access to a limited set of mercurial repos
 
 To be used in ~/.ssh/authorized_keys with the "command" option, see sshd(8):
 command="hg-ssh path/to/repo1 /path/to/repo2 ~/repo3 ~user/repo4" ssh-dss ...
 (probably together with these other useful options:
  no-port-forwarding,no-X11-forwarding,no-agent-forwarding)
 
 This allows pull/push over ssh from/to the repositories given as arguments.
 
 If all your repositories are subdirectories of a common directory, you can
 allow shorter paths with:
 command="cd path/to/my/repositories && hg-ssh repo1 subdir/repo2"
 
 You can use pattern matching of your normal shell, e.g.:
 command="cd repos && hg-ssh user/thomas/* projects/{mercurial,foo}"
 
 You can also add a --read-only flag to allow read-only access to a key, e.g.:
 command="hg-ssh --read-only repos/*"
 """
 from __future__ import absolute_import
 
 import os
 import shlex
 import sys
 
 # enable importing on demand to reduce startup time
-import hgdemandimport ; hgdemandimport.enable()
+import hgdemandimport
+
+hgdemandimport.enable()
 
 from mercurial import (
     dispatch,
     pycompat,
     ui as uimod,
 )
 
+
 def main():
     # Prevent insertion/deletion of CRs
     dispatch.initstdio()
 
     cwd = os.getcwd()
     readonly = False
     args = sys.argv[1:]
     while len(args):
         if args[0] == '--read-only':
             readonly = True
             args.pop(0)
         else:
             break
-    allowed_paths = [os.path.normpath(os.path.join(cwd,
-                                                   os.path.expanduser(path)))
-                     for path in args]
+    allowed_paths = [
+        os.path.normpath(os.path.join(cwd, os.path.expanduser(path)))
+        for path in args
+    ]
     orig_cmd = os.getenv('SSH_ORIGINAL_COMMAND', '?')
     try:
         cmdargv = shlex.split(orig_cmd)
     except ValueError as e:
         sys.stderr.write('Illegal command "%s": %s\n' % (orig_cmd, e))
         sys.exit(255)
 
     if cmdargv[:2] == ['hg', '-R'] and cmdargv[3:] == ['serve', '--stdio']:
         path = cmdargv[2]
         repo = os.path.normpath(os.path.join(cwd, os.path.expanduser(path)))
         if repo in allowed_paths:
             cmd = [b'-R', pycompat.fsencode(repo), b'serve', b'--stdio']
             req = dispatch.request(cmd)
             if readonly:
                 if not req.ui:
                     req.ui = uimod.ui.load()
-                req.ui.setconfig(b'hooks', b'pretxnopen.hg-ssh',
-                                 b'python:__main__.rejectpush', b'hg-ssh')
-                req.ui.setconfig(b'hooks', b'prepushkey.hg-ssh',
-                                 b'python:__main__.rejectpush', b'hg-ssh')
+                req.ui.setconfig(
+                    b'hooks',
+                    b'pretxnopen.hg-ssh',
+                    b'python:__main__.rejectpush',
+                    b'hg-ssh',
+                )
+                req.ui.setconfig(
+                    b'hooks',
+                    b'prepushkey.hg-ssh',
+                    b'python:__main__.rejectpush',
+                    b'hg-ssh',
+                )
             dispatch.dispatch(req)
         else:
             sys.stderr.write('Illegal repository "%s"\n' % repo)
             sys.exit(255)
     else:
         sys.stderr.write('Illegal command "%s"\n' % orig_cmd)
         sys.exit(255)
 
+
 def rejectpush(ui, **kwargs):
     ui.warn((b"Permission denied\n"))
     # mercurial hooks use unix process conventions for hook return values
     # so a truthy return means failure
     return True
 
+
 if __name__ == '__main__':
     main()

contrib/hgperf

@@ -1,97 +1,112 b''
 #!/usr/bin/env python
 #
 # hgperf - measure performance of Mercurial commands
 #
 # Copyright 2014 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 '''measure performance of Mercurial commands
 
 Using ``hgperf`` instead of ``hg`` measures performance of the target
 Mercurial command. For example, the execution below measures
 performance of :hg:`heads --topo`::
 
     $ hgperf heads --topo
 
 All command output via ``ui`` is suppressed, and just measurement
 result is displayed: see also "perf" extension in "contrib".
 
 Costs of processing before dispatching to the command function like
 below are not measured::
 
     - parsing command line (e.g. option validity check)
     - reading configuration files in
 
 But ``pre-`` and ``post-`` hook invocation for the target command is
 measured, even though these are invoked before or after dispatching to
 the command function, because these may be required to repeat
 execution of the target command correctly.
 '''
 
 import os
 import sys
 
 libdir = '@LIBDIR@'
 
 if libdir != '@' 'LIBDIR' '@':
     if not os.path.isabs(libdir):
-        libdir = os.path.join(os.path.dirname(os.path.realpath(__file__)),
-                              libdir)
+        libdir = os.path.join(
+            os.path.dirname(os.path.realpath(__file__)), libdir
+        )
         libdir = os.path.abspath(libdir)
     sys.path.insert(0, libdir)
 
 # enable importing on demand to reduce startup time
 try:
-    from mercurial import demandimport; demandimport.enable()
+    from mercurial import demandimport
+
+    demandimport.enable()
 except ImportError:
     import sys
-    sys.stderr.write("abort: couldn't find mercurial libraries in [%s]\n" %
-                     ' '.join(sys.path))
+
+    sys.stderr.write(
+        "abort: couldn't find mercurial libraries in [%s]\n"
+        % ' '.join(sys.path)
+    )
     sys.stderr.write("(check your install and PYTHONPATH)\n")
     sys.exit(-1)
 
 from mercurial import (
     dispatch,
     util,
 )
 
+
 def timer(func, title=None):
     results = []
     begin = util.timer()
     count = 0
     while True:
         ostart = os.times()
         cstart = util.timer()
         r = func()
         cstop = util.timer()
         ostop = os.times()
         count += 1
         a, b = ostart, ostop
-        results.append((cstop - cstart, b[0] - a[0], b[1]-a[1]))
+        results.append((cstop - cstart, b[0] - a[0], b[1] - a[1]))
         if cstop - begin > 3 and count >= 100:
             break
         if cstop - begin > 10 and count >= 3:
             break
     if title:
         sys.stderr.write("! %s\n" % title)
     if r:
         sys.stderr.write("! result: %s\n" % r)
     m = min(results)
-    sys.stderr.write("! wall %f comb %f user %f sys %f (best of %d)\n"
-                     % (m[0], m[1] + m[2], m[1], m[2], count))
+    sys.stderr.write(
+        "! wall %f comb %f user %f sys %f (best of %d)\n"
+        % (m[0], m[1] + m[2], m[1], m[2], count)
+    )
+
 
 orgruncommand = dispatch.runcommand
 
+
 def runcommand(lui, repo, cmd, fullargs, ui, options, d, cmdpats, cmdoptions):
     ui.pushbuffer()
     lui.pushbuffer()
-    timer(lambda : orgruncommand(lui, repo, cmd, fullargs, ui,
-                                 options, d, cmdpats, cmdoptions))
+    timer(
+        lambda: orgruncommand(
+            lui, repo, cmd, fullargs, ui, options, d, cmdpats, cmdoptions
+        )
+    )
     ui.popbuffer()
     lui.popbuffer()
 
+
 dispatch.runcommand = runcommand
 
 dispatch.run()

contrib/hgweb.fcgi

@@ -1,19 +1,22 b''
 #!/usr/bin/env python
 #
 # An example FastCGI script for use with flup, edit as necessary
 
 # Path to repo or hgweb config to serve (see 'hg help hgweb')
 config = "/path/to/repo/or/config"
 
 # Uncomment and adjust if Mercurial is not installed system-wide
 # (consult "installed modules" path from 'hg debuginstall'):
-#import sys; sys.path.insert(0, "/path/to/python/lib")
+# import sys; sys.path.insert(0, "/path/to/python/lib")
 
 # Uncomment to send python tracebacks to the browser if an error occurs:
-#import cgitb; cgitb.enable()
+# import cgitb; cgitb.enable()
 
-from mercurial import demandimport; demandimport.enable()
+from mercurial import demandimport
+
+demandimport.enable()
 from mercurial.hgweb import hgweb
 from flup.server.fcgi import WSGIServer
+
 application = hgweb(config)
 WSGIServer(application).run()

contrib/packaging/hg-docker

@@ -1,116 +1,129 b''
 #!/usr/bin/env python3
 #
 # Copyright 2018 Gregory Szorc <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 import argparse
 import pathlib
 import shutil
 import subprocess
 import sys
 
+
 def get_docker() -> str:
     docker = shutil.which('docker.io') or shutil.which('docker')
     if not docker:
         print('could not find docker executable')
         return 1
 
     try:
         out = subprocess.check_output([docker, '-h'], stderr=subprocess.STDOUT)
 
         if b'Jansens' in out:
-            print('%s is the Docking System Tray; try installing docker.io' %
-                  docker)
+            print(
+                '%s is the Docking System Tray; try installing docker.io'
+                % docker
+            )
             sys.exit(1)
     except subprocess.CalledProcessError as e:
         print('error calling `%s -h`: %s' % (docker, e.output))
         sys.exit(1)
 
-    out = subprocess.check_output([docker, 'version'],
-                                  stderr=subprocess.STDOUT)
+    out = subprocess.check_output([docker, 'version'], stderr=subprocess.STDOUT)
 
     lines = out.splitlines()
     if not any(l.startswith((b'Client:', b'Client version:')) for l in lines):
         print('`%s version` does not look like Docker' % docker)
         sys.exit(1)
 
     if not any(l.startswith((b'Server:', b'Server version:')) for l in lines):
         print('`%s version` does not look like Docker' % docker)
         sys.exit(1)
 
     return docker
 
+
 def get_dockerfile(path: pathlib.Path, args: list) -> bytes:
     with path.open('rb') as fh:
         df = fh.read()
 
     for k, v in args:
         df = df.replace(bytes('%%%s%%' % k.decode(), 'utf-8'), v)
 
     return df
 
+
 def build_docker_image(dockerfile: pathlib.Path, params: list, tag: str):
     """Build a Docker image from a templatized Dockerfile."""
     docker = get_docker()
 
     dockerfile_path = pathlib.Path(dockerfile)
 
     dockerfile = get_dockerfile(dockerfile_path, params)
 
     print('building Dockerfile:')
     print(dockerfile.decode('utf-8', 'replace'))
 
     args = [
         docker,
         'build',
-        '--build-arg', 'http_proxy',
-        '--build-arg', 'https_proxy',
-        '--tag', tag,
+        '--build-arg',
+        'http_proxy',
+        '--build-arg',
+        'https_proxy',
+        '--tag',
+        tag,
         '-',
     ]
 
     print('executing: %r' % args)
     p = subprocess.Popen(args, stdin=subprocess.PIPE)
     p.communicate(input=dockerfile)
     if p.returncode:
         raise subprocess.CalledProcessException(
-                p.returncode, 'failed to build docker image: %s %s'
-                % (p.stdout, p.stderr))
+            p.returncode,
+            'failed to build docker image: %s %s' % (p.stdout, p.stderr),
+        )
+
 
 def command_build(args):
     build_args = []
     for arg in args.build_arg:
         k, v = arg.split('=', 1)
         build_args.append((k.encode('utf-8'), v.encode('utf-8')))
 
-    build_docker_image(pathlib.Path(args.dockerfile),
-                       build_args,
-                       args.tag)
+    build_docker_image(pathlib.Path(args.dockerfile), build_args, args.tag)
+
 
 def command_docker(args):
     print(get_docker())
 
+
 def main() -> int:
     parser = argparse.ArgumentParser()
 
     subparsers = parser.add_subparsers(title='subcommands')
 
     build = subparsers.add_parser('build', help='Build a Docker image')
     build.set_defaults(func=command_build)
-    build.add_argument('--build-arg', action='append', default=[],
-                        help='Substitution to perform in Dockerfile; '
-                             'format: key=value')
+    build.add_argument(
+        '--build-arg',
+        action='append',
+        default=[],
+        help='Substitution to perform in Dockerfile; ' 'format: key=value',
+    )
     build.add_argument('dockerfile', help='path to Dockerfile to use')
     build.add_argument('tag', help='Tag to apply to created image')
 
     docker = subparsers.add_parser('docker-path', help='Resolve path to Docker')
     docker.set_defaults(func=command_docker)
 
     args = parser.parse_args()
 
     return args.func(args)
 
+
 if __name__ == '__main__':
     sys.exit(main())

contrib/relnotes

@@ -1,204 +1,207 b''
 #!/usr/bin/env python3
 """Generate release notes from our commit log.
 
 This uses the relnotes extension directives when they're available,
 and falls back to our old pre-relnotes logic that used to live in the
 release-tools repo.
 """
 import argparse
 import re
 import subprocess
 
 rules = {
     # keep
     r"\(issue": 100,
     r"\(BC\)": 100,
     r"\(API\)": 100,
     r"\(SEC\)": 100,
     # core commands, bump up
     r"(commit|files|log|pull|push|patch|status|tag|summary)(|s|es):": 20,
     r"(annotate|alias|branch|bookmark|clone|graft|import|verify).*:": 20,
     # extensions, bump up
     r"(mq|shelve|rebase):": 20,
     # newsy
     r": deprecate": 20,
     r": new.*(extension|flag|module)": 10,
     r"( ability|command|feature|option|support)": 10,
     # experimental
     r"hg-experimental": 20,
     r"(from|graduate).*experimental": 15,
     r"(hide|mark).*experimental": -10,
     # bug-like?
     r"(fix|don't break|improve)": 7,
     r"(not|n't|avoid|fix|prevent).*crash": 10,
     r"vulnerab": 10,
     # boring stuff, bump down
     r"^contrib": -5,
     r"debug": -5,
     r"help": -5,
     r"minor": -5,
     r"(doc|metavar|bundle2|obsolete|obsmarker|rpm|setup|debug\S+:)": -15,
     r"(check-code|check-commit|check-config|import-checker)": -20,
     r"(flake8|lintian|pyflakes|pylint)": -20,
     # cleanups and refactoring
     r"(clean ?up|white ?space|spelling|quoting)": -20,
     r"(flatten|dedent|indent|nesting|unnest)": -20,
     r"(typo|hint|note|comment|TODO|FIXME)": -20,
     r"(style:|convention|one-?liner)": -20,
     r"(argument|absolute_import|attribute|assignment|mutable)": -15,
     r"(scope|True|False)": -10,
     r"(unused|useless|unnecessar|superfluous|duplicate|deprecated)": -10,
     r"(redundant|pointless|confusing|uninitialized|meaningless|dead)": -10,
     r": (drop|remove|delete|rip out)": -10,
     r": (inherit|rename|simplify|naming|inline)": -10,
     r"(correct doc|docstring|document .* method)": -20,
     r"(abstract|factor|extract|prepare|split|replace| import)": -20,
     r": add.*(function|method|implementation|example)": -10,
     r": (move|extract) .* (to|into|from|out of)": -20,
     r": implement ": -5,
     r": use .* implementation": -20,
     r": use .* instead of": -20,
     # code
     r"_": -10,
     r"__": -5,
     r"\(\)": -5,
     r"\S\S\S+\.\S\S\S\S+": -5,
     # dumb keywords
     r"\S+/\S+:": -10,
     r"\S+\.\S+:": -10,
     # python compatibility
     r"[Pp]y(|thon) ?[23]": -20,
     r"pycompat": -20,
     r"(coerce|convert|encode) .*to (byte|sys|)(s|str|string)": -20,
     # tests
     r"^test(|s|ing|runner|-\S+):": -20,
     r"^(f|hghave|run-tests):": -20,
     r"add.* tests?": -20,
     r"(buildbot|fuzz|mock|ratchet)": -10,
     # drop
     r"^i18n-": -50,
     r"^i18n:.*(hint|comment)": -50,
     r"perf:": -50,
     r"Added.*for changeset": -50,
     r"^_": -50,
 }
 
 cutoff = 10
 commits = []
 
 groupings = [
     (r"util|parsers|repo|ctx|context|revlog|filelog|alias|cmdutil", "core"),
     (r"revset|template|ui|dirstate|hook|i18n|transaction|wire|vfs", "core"),
     (r"dispatch|exchange|localrepo|streamclone|color|pager", "core"),
     (r"hgweb|paper|coal|gitweb|monoblue|spartan", "hgweb"),
     (r"pull|push|revert|resolve|annotate|bookmark|branch|clone", "commands"),
     (r"commands|commit|config|files|graft|import|log|merge|patch", "commands"),
     (r"phases|status|summary|amend|tag|help|verify", "commands"),
     (r"rebase|mq|convert|eol|histedit|largefiles", "extensions"),
     (r"shelve|unshelve", "extensions"),
 ]
 
+
 def wikify(desc):
     desc = desc.replace("(issue", "(Bts:issue")
     desc = re.sub(r"\b([0-9a-f]{12})\b", r"Cset:\1", desc)
     # stop ParseError from being recognized as a (nonexistent) wiki page
     desc = re.sub(r" ([A-Z][a-z]+[A-Z][a-z]+)\b", r" !\1", desc)
     # prevent wiki markup of magic methods
     desc = re.sub(r"\b(\S*__\S*)\b", r"`\1`", desc)
     return desc
 
+
 def main():
     desc = "example: %(prog)s 4.7.2 --stoprev 4.8rc0"
     ap = argparse.ArgumentParser(description=desc)
     ap.add_argument(
         "startrev",
         metavar="REV",
         type=str,
         help=(
             "Starting revision for the release notes. This revision "
             "won't be included, but later revisions will."
         ),
     )
     ap.add_argument(
         "--stoprev",
         metavar="REV",
         type=str,
         default="@",
         help=(
             "Stop revision for release notes. This revision will be included,"
             " but no later revisions will. This revision needs to be "
             "a descendant of startrev."
         ),
     )
     args = ap.parse_args()
     fromext = subprocess.check_output(
         [
             "hg",
             "--config",
             "extensions.releasenotes=",
             "releasenotes",
             "-r",
             "only(%s, %s)" % (args.stoprev, args.startrev),
         ]
     ).decode("utf-8")
     # Find all release notes from un-relnotes-flagged commits.
     for entry in sorted(
         subprocess.check_output(
             [
                 "hg",
                 "log",
                 "-r",
                 "only(%s, %s) - merge()" % (args.stoprev, args.startrev),
                 "-T",
                 r"{desc|firstline}\n",
             ]
         )
         .decode("utf-8")
         .splitlines()
     ):
         desc = entry.replace("`", "'")
 
         score = 0
         for rule, val in rules.items():
             if re.search(rule, desc):
                 score += val
 
         if score >= cutoff:
             commits.append(wikify(desc))
     # Group unflagged notes.
     groups = {}
     bcs = []
     apis = []
 
     for d in commits:
         if "(BC)" in d:
             bcs.append(d)
         if "(API)" in d:
             apis.append(d)
         for rule, g in groupings:
             if re.match(rule, d):
                 groups.setdefault(g, []).append(d)
                 break
         else:
             groups.setdefault("unsorted", []).append(d)
     print(fromext)
     # print legacy release notes sections
     for g in sorted(groups):
         print("\n=== %s ===" % g)
         for d in sorted(groups[g]):
             print(" * %s" % d)
 
     if bcs:
         print("\n=== Behavior Changes ===\n")
 
     for d in sorted(bcs):
         print(" * %s" % d)
 
     if apis:
         print("\n=== Internal API Changes ===\n")
 
     for d in sorted(apis):
         print(" * %s" % d)
 
+
 if __name__ == "__main__":
     main()

contrib/simplemerge

@@ -1,87 +1,102 b''
 #!/usr/bin/env python
 from __future__ import absolute_import
 
 import getopt
 import sys
 
 import hgdemandimport
+
 hgdemandimport.enable()
 
 from mercurial.i18n import _
 from mercurial import (
     context,
     error,
     fancyopts,
     pycompat,
     simplemerge,
     ui as uimod,
 )
-from mercurial.utils import (
-    procutil,
-    stringutil
-)
+from mercurial.utils import procutil, stringutil
 
-options = [(b'L', b'label', [], _(b'labels to use on conflict markers')),
-           (b'a', b'text', None, _(b'treat all files as text')),
-           (b'p', b'print', None,
-            _(b'print results instead of overwriting LOCAL')),
-           (b'', b'no-minimal', None, _(b'no effect (DEPRECATED)')),
-           (b'h', b'help', None, _(b'display help and exit')),
-           (b'q', b'quiet', None, _(b'suppress output'))]
+options = [
+    (b'L', b'label', [], _(b'labels to use on conflict markers')),
+    (b'a', b'text', None, _(b'treat all files as text')),
+    (b'p', b'print', None, _(b'print results instead of overwriting LOCAL')),
+    (b'', b'no-minimal', None, _(b'no effect (DEPRECATED)')),
+    (b'h', b'help', None, _(b'display help and exit')),
+    (b'q', b'quiet', None, _(b'suppress output')),
+]
 
-usage = _(b'''simplemerge [OPTS] LOCAL BASE OTHER
+usage = _(
+    b'''simplemerge [OPTS] LOCAL BASE OTHER
 
     Simple three-way file merge utility with a minimal feature set.
 
     Apply to LOCAL the changes necessary to go from BASE to OTHER.
 
     By default, LOCAL is overwritten with the results of this operation.
-''')
+'''
+)
+
 
 class ParseError(Exception):
     """Exception raised on errors in parsing the command line."""
 
+
 def showhelp():
     pycompat.stdout.write(usage)
     pycompat.stdout.write(b'\noptions:\n')
 
     out_opts = []
     for shortopt, longopt, default, desc in options:
-        out_opts.append((b'%2s%s' % (shortopt and b'-%s' % shortopt,
-                                     longopt and b' --%s' % longopt),
-                         b'%s' % desc))
+        out_opts.append(
+            (
+                b'%2s%s'
+                % (
+                    shortopt and b'-%s' % shortopt,
+                    longopt and b' --%s' % longopt,
+                ),
+                b'%s' % desc,
+            )
+        )
     opts_len = max([len(opt[0]) for opt in out_opts])
     for first, second in out_opts:
         pycompat.stdout.write(b' %-*s  %s\n' % (opts_len, first, second))
 
+
 try:
     for fp in (sys.stdin, pycompat.stdout, sys.stderr):
         procutil.setbinary(fp)
 
     opts = {}
     try:
         bargv = [a.encode('utf8') for a in sys.argv[1:]]
         args = fancyopts.fancyopts(bargv, options, opts)
     except getopt.GetoptError as e:
         raise ParseError(e)
     if opts[b'help']:
         showhelp()
         sys.exit(0)
     if len(args) != 3:
-            raise ParseError(_(b'wrong number of arguments').decode('utf8'))
+        raise ParseError(_(b'wrong number of arguments').decode('utf8'))
     local, base, other = args
-    sys.exit(simplemerge.simplemerge(uimod.ui.load(),
-                                     context.arbitraryfilectx(local),
-                                     context.arbitraryfilectx(base),
-                                     context.arbitraryfilectx(other),
-                                     **pycompat.strkwargs(opts)))
+    sys.exit(
+        simplemerge.simplemerge(
+            uimod.ui.load(),
+            context.arbitraryfilectx(local),
+            context.arbitraryfilectx(base),
+            context.arbitraryfilectx(other),
+            **pycompat.strkwargs(opts)
+        )
+    )
 except ParseError as e:
     e = stringutil.forcebytestr(e)
     pycompat.stdout.write(b"%s: %s\n" % (sys.argv[0].encode('utf8'), e))
     showhelp()
     sys.exit(1)
 except error.Abort as e:
     pycompat.stderr.write(b"abort: %s\n" % e)
     sys.exit(255)
 except KeyboardInterrupt:
     sys.exit(255)

contrib/undumprevlog

@@ -1,50 +1,49 b''
 #!/usr/bin/env python
 # Undump a dump from dumprevlog
 # $ hg init
 # $ undumprevlog < repo.dump
 
 from __future__ import absolute_import, print_function
 
 import sys
 from mercurial import (
     encoding,
     node,
     pycompat,
     revlog,
     transaction,
     vfs as vfsmod,
 )
-from mercurial.utils import (
-    procutil,
-)
+from mercurial.utils import procutil
 
 for fp in (sys.stdin, sys.stdout, sys.stderr):
     procutil.setbinary(fp)
 
 opener = vfsmod.vfs(b'.', False)
-tr = transaction.transaction(sys.stderr.write, opener, {b'store': opener},
-                             b"undump.journal")
+tr = transaction.transaction(
+    sys.stderr.write, opener, {b'store': opener}, b"undump.journal"
+)
 while True:
     l = sys.stdin.readline()
     if not l:
         break
     if l.startswith("file:"):
         f = encoding.strtolocal(l[6:-1])
         r = revlog.revlog(opener, f)
         pycompat.stdout.write(b'%s\n' % f)
     elif l.startswith("node:"):
         n = node.bin(l[6:-1])
     elif l.startswith("linkrev:"):
         lr = int(l[9:-1])
     elif l.startswith("parents:"):
         p = l[9:-1].split()
         p1 = node.bin(p[0])
         p2 = node.bin(p[1])
     elif l.startswith("length:"):
         length = int(l[8:-1])
-        sys.stdin.readline() # start marker
+        sys.stdin.readline()  # start marker
         d = encoding.strtolocal(sys.stdin.read(length))
-        sys.stdin.readline() # end marker
+        sys.stdin.readline()  # end marker
         r.addrevision(d, tr, lr, p1, p2)
 
 tr.close()

hg

@@ -1,36 +1,43 b''
 #!/usr/bin/env python
 #
 # mercurial - scalable distributed SCM
 #
 # Copyright 2005-2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 from __future__ import absolute_import
 
 import os
 import sys
 
 libdir = '@LIBDIR@'
 
 if libdir != '@' 'LIBDIR' '@':
     if not os.path.isabs(libdir):
-        libdir = os.path.join(os.path.dirname(os.path.realpath(__file__)),
-                              libdir)
+        libdir = os.path.join(
+            os.path.dirname(os.path.realpath(__file__)), libdir
+        )
         libdir = os.path.abspath(libdir)
     sys.path.insert(0, libdir)
 
 from hgdemandimport import tracing
+
 with tracing.log('hg script'):
     # enable importing on demand to reduce startup time
     try:
         if sys.version_info[0] < 3 or sys.version_info >= (3, 6):
-            import hgdemandimport; hgdemandimport.enable()
+            import hgdemandimport
+
+            hgdemandimport.enable()
     except ImportError:
-        sys.stderr.write("abort: couldn't find mercurial libraries in [%s]\n" %
-                         ' '.join(sys.path))
+        sys.stderr.write(
+            "abort: couldn't find mercurial libraries in [%s]\n"
+            % ' '.join(sys.path)
+        )
         sys.stderr.write("(check your install and PYTHONPATH)\n")
         sys.exit(-1)
 
     from mercurial import dispatch
+
     dispatch.run()