formatting: blacken the codebase

This is using my patch to black
(https://github.com/psf/black/pull/826) so we don't un-wrap collection
literals.

Done with:

  hg files 'set:**.py - mercurial/thirdparty/** - "contrib/python-zstandard/**"' | xargs black -S

# skip-blame mass-reformatting only

# no-check-commit reformats foo_bar functions

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

contrib/automation/automation.py

@@ -36,8 +36,13 b' def bootstrap():'
         pip = venv_bin / 'pip'
         python = venv_bin / 'python'
 
-    args = [str(pip), 'install', '-r', str(REQUIREMENTS_TXT),
-            '--disable-pip-version-check']
+    args = [
+        str(pip),
+        'install',
+        '-r',
+        str(REQUIREMENTS_TXT),
+        '--disable-pip-version-check',
+    ]
 
     if not venv_created:
         args.append('-q')
@@ -45,8 +50,7 b' def bootstrap():'
     subprocess.run(args, check=True)
 
     os.environ['HGAUTOMATION_BOOTSTRAPPED'] = '1'
-    os.environ['PATH'] = '%s%s%s' % (
-        venv_bin, os.pathsep, os.environ['PATH'])
+    os.environ['PATH'] = '%s%s%s' % (venv_bin, os.pathsep, os.environ['PATH'])
 
     subprocess.run([str(python), __file__] + sys.argv[1:], check=True)
 

contrib/automation/hgautomation/__init__.py

@@ -10,9 +10,7 b''
 import pathlib
 import secrets
 
-from .aws import (
-    AWSConnection,
-)
+from .aws import AWSConnection
 
 
 class HGAutomation:

contrib/automation/hgautomation/aws.py

@@ -19,9 +19,7 b' import time'
 import boto3
 import botocore.exceptions
 
-from .linux import (
-    BOOTSTRAP_DEBIAN,
-)
+from .linux import BOOTSTRAP_DEBIAN
 from .ssh import (
     exec_command as ssh_exec_command,
     wait_for_ssh,
@@ -32,10 +30,13 b' from .winrm import ('
 )
 
 
-SOURCE_ROOT = pathlib.Path(os.path.abspath(__file__)).parent.parent.parent.parent
+SOURCE_ROOT = pathlib.Path(
+    os.path.abspath(__file__)
+).parent.parent.parent.parent
 
-INSTALL_WINDOWS_DEPENDENCIES = (SOURCE_ROOT / 'contrib' /
-                                'install-windows-dependencies.ps1')
+INSTALL_WINDOWS_DEPENDENCIES = (
+    SOURCE_ROOT / 'contrib' / 'install-windows-dependencies.ps1'
+)
 
 
 INSTANCE_TYPES_WITH_STORAGE = {
@@ -107,7 +108,6 b' SECURITY_GROUPS = {'
                         'Description': 'RDP from entire Internet',
                     },
                 ],
-
             },
             {
                 'FromPort': 5985,
@@ -119,7 +119,7 b' SECURITY_GROUPS = {'
                         'Description': 'PowerShell Remoting (Windows Remote Management)',
                     },
                 ],
-            }
+            },
         ],
     },
 }
@@ -152,11 +152,7 b" ASSUME_ROLE_POLICY_DOCUMENT = '''"
 
 
 IAM_INSTANCE_PROFILES = {
-    'ephemeral-ec2-1': {
-        'roles': [
-            'ephemeral-ec2-role-1',
-        ],
-    }
+    'ephemeral-ec2-1': {'roles': ['ephemeral-ec2-role-1',],}
 }
 
 
@@ -257,10 +253,19 b' def rsa_key_fingerprint(p: pathlib.Path)'
 
     # TODO use rsa package.
     res = subprocess.run(
-        ['openssl', 'pkcs8', '-in', str(p), '-nocrypt', '-topk8',
-         '-outform', 'DER'],
+        [
+            'openssl',
+            'pkcs8',
+            '-in',
+            str(p),
+            '-nocrypt',
+            '-topk8',
+            '-outform',
+            'DER',
+        ],
         capture_output=True,
-        check=True)
+        check=True,
+    )
 
     sha1 = hashlib.sha1(res.stdout).hexdigest()
     return ':'.join(a + b for a, b in zip(sha1[::2], sha1[1::2]))
@@ -306,8 +311,9 b' def ensure_key_pairs(state_path: pathlib'
             data = fh.read()
 
         if not data.startswith('ssh-rsa '):
-            print('unexpected format for key pair file: %s; removing' %
-                  pub_full)
+            print(
+                'unexpected format for key pair file: %s; removing' % pub_full
+            )
             pub_full.unlink()
             priv_full.unlink()
             continue
@@ -327,8 +333,10 b' def ensure_key_pairs(state_path: pathlib'
             del local_existing[name]
 
         elif remote_existing[name] != local_existing[name]:
-            print('key fingerprint mismatch for %s; '
-                  'removing from local and remote' % name)
+            print(
+                'key fingerprint mismatch for %s; '
+                'removing from local and remote' % name
+            )
             remove_local(name)
             remove_remote('%s%s' % (prefix, name))
             del local_existing[name]
@@ -356,15 +364,18 b' def ensure_key_pairs(state_path: pathlib'
             subprocess.run(
                 ['ssh-keygen', '-y', '-f', str(priv_full)],
                 stdout=fh,
-                check=True)
+                check=True,
+            )
 
         pub_full.chmod(0o0600)
 
 
 def delete_instance_profile(profile):
     for role in profile.roles:
-        print('removing role %s from instance profile %s' % (role.name,
-                                                             profile.name))
+        print(
+            'removing role %s from instance profile %s'
+            % (role.name, profile.name)
+        )
         profile.remove_role(RoleName=role.name)
 
     print('deleting instance profile %s' % profile.name)
@@ -404,7 +415,8 b' def ensure_iam_state(iamclient, iamresou'
         print('creating IAM instance profile %s' % actual)
 
         profile = iamresource.create_instance_profile(
-            InstanceProfileName=actual)
+            InstanceProfileName=actual
+        )
         remote_profiles[name] = profile
 
         waiter = iamclient.get_waiter('instance_profile_exists')
@@ -453,23 +465,12 b' def find_image(ec2resource, owner_id, na'
 
     images = ec2resource.images.filter(
         Filters=[
-            {
-                'Name': 'owner-id',
-                'Values': [owner_id],
-            },
-            {
-                'Name': 'state',
-                'Values': ['available'],
-            },
-            {
-                'Name': 'image-type',
-                'Values': ['machine'],
-            },
-            {
-                'Name': 'name',
-                'Values': [name],
-            },
-        ])
+            {'Name': 'owner-id', 'Values': [owner_id],},
+            {'Name': 'state', 'Values': ['available'],},
+            {'Name': 'image-type', 'Values': ['machine'],},
+            {'Name': 'name', 'Values': [name],},
+        ]
+    )
 
     for image in images:
         return image
@@ -507,13 +508,10 b' def ensure_security_groups(ec2resource, '
         print('adding security group %s' % actual)
 
         group_res = ec2resource.create_security_group(
-            Description=group['description'],
-            GroupName=actual,
+            Description=group['description'], GroupName=actual,
         )
 
-        group_res.authorize_ingress(
-            IpPermissions=group['ingress'],
-        )
+        group_res.authorize_ingress(IpPermissions=group['ingress'],)
 
         security_groups[name] = group_res
 
@@ -577,8 +575,10 b' def wait_for_ip_addresses(instances):'
                 instance.reload()
                 continue
 
-            print('public IP address for %s: %s' % (
-                instance.id, instance.public_ip_address))
+            print(
+                'public IP address for %s: %s'
+                % (instance.id, instance.public_ip_address)
+            )
             break
 
 
@@ -603,10 +603,7 b' def wait_for_ssm(ssmclient, instances):'
     while True:
         res = ssmclient.describe_instance_information(
             Filters=[
-                {
-                    'Key': 'InstanceIds',
-                    'Values': [i.id for i in instances],
-                },
+                {'Key': 'InstanceIds', 'Values': [i.id for i in instances],},
             ],
         )
 
@@ -628,9 +625,7 b' def run_ssm_command(ssmclient, instances'
         InstanceIds=[i.id for i in instances],
         DocumentName=document_name,
         Parameters=parameters,
-        CloudWatchOutputConfig={
-            'CloudWatchOutputEnabled': True,
-        },
+        CloudWatchOutputConfig={'CloudWatchOutputEnabled': True,},
     )
 
     command_id = res['Command']['CommandId']
@@ -639,8 +634,7 b' def run_ssm_command(ssmclient, instances'
         while True:
             try:
                 res = ssmclient.get_command_invocation(
-                    CommandId=command_id,
-                    InstanceId=instance.id,
+                    CommandId=command_id, InstanceId=instance.id,
                 )
             except botocore.exceptions.ClientError as e:
                 if e.response['Error']['Code'] == 'InvocationDoesNotExist':
@@ -655,8 +649,9 b' def run_ssm_command(ssmclient, instances'
             elif res['Status'] in ('Pending', 'InProgress', 'Delayed'):
                 time.sleep(2)
             else:
-                raise Exception('command failed on %s: %s' % (
-                    instance.id, res['Status']))
+                raise Exception(
+                    'command failed on %s: %s' % (instance.id, res['Status'])
+                )
 
 
 @contextlib.contextmanager
@@ -711,10 +706,12 b' def create_temp_windows_ec2_instances(c:'
     config['IamInstanceProfile'] = {
         'Name': 'hg-ephemeral-ec2-1',
     }
-    config.setdefault('TagSpecifications', []).append({
+    config.setdefault('TagSpecifications', []).append(
+        {
         'ResourceType': 'instance',
         'Tags': [{'Key': 'Name', 'Value': 'hg-temp-windows'}],
-    })
+        }
+    )
     config['UserData'] = WINDOWS_USER_DATA % password
 
     with temporary_ec2_instances(c.ec2resource, config) as instances:
@@ -723,7 +720,9 b' def create_temp_windows_ec2_instances(c:'
         print('waiting for Windows Remote Management service...')
 
         for instance in instances:
-            client = wait_for_winrm(instance.public_ip_address, 'Administrator', password)
+            client = wait_for_winrm(
+                instance.public_ip_address, 'Administrator', password
+            )
             print('established WinRM connection to %s' % instance.id)
             instance.winrm_client = client
 
@@ -748,14 +747,17 b' def find_and_reconcile_image(ec2resource'
     # Store a reference to a good image so it can be returned one the
     # image state is reconciled.
     images = ec2resource.images.filter(
-        Filters=[{'Name': 'name', 'Values': [name]}])
+        Filters=[{'Name': 'name', 'Values': [name]}]
+    )
 
     existing_image = None
 
     for image in images:
         if image.tags is None:
-            print('image %s for %s lacks required tags; removing' % (
-                image.id, image.name))
+            print(
+                'image %s for %s lacks required tags; removing'
+                % (image.id, image.name)
+            )
             remove_ami(ec2resource, image)
         else:
             tags = {t['Key']: t['Value'] for t in image.tags}
@@ -763,15 +765,18 b' def find_and_reconcile_image(ec2resource'
             if tags.get('HGIMAGEFINGERPRINT') == fingerprint:
                 existing_image = image
             else:
-                print('image %s for %s has wrong fingerprint; removing' % (
-                      image.id, image.name))
+                print(
+                    'image %s for %s has wrong fingerprint; removing'
+                    % (image.id, image.name)
+                )
                 remove_ami(ec2resource, image)
 
     return existing_image
 
 
-def create_ami_from_instance(ec2client, instance, name, description,
-                             fingerprint):
+def create_ami_from_instance(
+    ec2client, instance, name, description, fingerprint
+):
     """Create an AMI from a running instance.
 
     Returns the ``ec2resource.Image`` representing the created AMI.
@@ -779,29 +784,19 b' def create_ami_from_instance(ec2client, '
     instance.stop()
 
     ec2client.get_waiter('instance_stopped').wait(
-        InstanceIds=[instance.id],
-        WaiterConfig={
-            'Delay': 5,
-        })
+        InstanceIds=[instance.id], WaiterConfig={'Delay': 5,}
+    )
     print('%s is stopped' % instance.id)
 
-    image = instance.create_image(
-        Name=name,
-        Description=description,
-    )
+    image = instance.create_image(Name=name, Description=description,)
 
-    image.create_tags(Tags=[
-        {
-            'Key': 'HGIMAGEFINGERPRINT',
-            'Value': fingerprint,
-        },
-    ])
+    image.create_tags(
+        Tags=[{'Key': 'HGIMAGEFINGERPRINT', 'Value': fingerprint,},]
+    )
 
     print('waiting for image %s' % image.id)
 
-    ec2client.get_waiter('image_available').wait(
-        ImageIds=[image.id],
-    )
+    ec2client.get_waiter('image_available').wait(ImageIds=[image.id],)
 
     print('image %s available as %s' % (image.id, image.name))
 
@@ -827,9 +822,7 b' def ensure_linux_dev_ami(c: AWSConnectio'
         ssh_username = 'admin'
     elif distro == 'debian10':
         image = find_image(
-            ec2resource,
-            DEBIAN_ACCOUNT_ID_2,
-            'debian-10-amd64-20190909-10',
+            ec2resource, DEBIAN_ACCOUNT_ID_2, 'debian-10-amd64-20190909-10',
         )
         ssh_username = 'admin'
     elif distro == 'ubuntu18.04':
@@ -871,10 +864,12 b' def ensure_linux_dev_ami(c: AWSConnectio'
         'SecurityGroupIds': [c.security_groups['linux-dev-1'].id],
     }
 
-    requirements2_path = (pathlib.Path(__file__).parent.parent /
-                          'linux-requirements-py2.txt')
-    requirements3_path = (pathlib.Path(__file__).parent.parent /
-                          'linux-requirements-py3.txt')
+    requirements2_path = (
+        pathlib.Path(__file__).parent.parent / 'linux-requirements-py2.txt'
+    )
+    requirements3_path = (
+        pathlib.Path(__file__).parent.parent / 'linux-requirements-py3.txt'
+    )
     with requirements2_path.open('r', encoding='utf-8') as fh:
         requirements2 = fh.read()
     with requirements3_path.open('r', encoding='utf-8') as fh:
@@ -882,12 +877,14 b' def ensure_linux_dev_ami(c: AWSConnectio'
 
     # Compute a deterministic fingerprint to determine whether image needs to
     # be regenerated.
-    fingerprint = resolve_fingerprint({
+    fingerprint = resolve_fingerprint(
+        {
         'instance_config': config,
         'bootstrap_script': BOOTSTRAP_DEBIAN,
         'requirements_py2': requirements2,
         'requirements_py3': requirements3,
-    })
+        }
+    )
 
     existing_image = find_and_reconcile_image(ec2resource, name, fingerprint)
 
@@ -902,9 +899,11 b' def ensure_linux_dev_ami(c: AWSConnectio'
         instance = instances[0]
 
         client = wait_for_ssh(
-            instance.public_ip_address, 22,
+            instance.public_ip_address,
+            22,
             username=ssh_username,
-            key_filename=str(c.key_pair_path_private('automation')))
+            key_filename=str(c.key_pair_path_private('automation')),
+        )
 
         home = '/home/%s' % ssh_username
 
@@ -926,8 +925,9 b' def ensure_linux_dev_ami(c: AWSConnectio'
                 fh.chmod(0o0700)
 
             print('executing bootstrap')
-            chan, stdin, stdout = ssh_exec_command(client,
-                                                   '%s/bootstrap' % home)
+            chan, stdin, stdout = ssh_exec_command(
+                client, '%s/bootstrap' % home
+            )
             stdin.close()
 
             for line in stdout:
@@ -937,17 +937,28 b' def ensure_linux_dev_ami(c: AWSConnectio'
             if res:
                 raise Exception('non-0 exit from bootstrap: %d' % res)
 
-            print('bootstrap completed; stopping %s to create %s' % (
-                  instance.id, name))
+            print(
+                'bootstrap completed; stopping %s to create %s'
+                % (instance.id, name)
+            )
 
-        return create_ami_from_instance(ec2client, instance, name,
+        return create_ami_from_instance(
+            ec2client,
+            instance,
+            name,
                                         'Mercurial Linux development environment',
-                                        fingerprint)
+            fingerprint,
+        )
 
 
 @contextlib.contextmanager
-def temporary_linux_dev_instances(c: AWSConnection, image, instance_type,
-                                  prefix='hg-', ensure_extra_volume=False):
+def temporary_linux_dev_instances(
+    c: AWSConnection,
+    image,
+    instance_type,
+    prefix='hg-',
+    ensure_extra_volume=False,
+):
     """Create temporary Linux development EC2 instances.
 
     Context manager resolves to a list of ``ec2.Instance`` that were created
@@ -979,8 +990,9 b' def temporary_linux_dev_instances(c: AWS'
 
     # This is not an exhaustive list of instance types having instance storage.
     # But
-    if (ensure_extra_volume
-        and not instance_type.startswith(tuple(INSTANCE_TYPES_WITH_STORAGE))):
+    if ensure_extra_volume and not instance_type.startswith(
+        tuple(INSTANCE_TYPES_WITH_STORAGE)
+    ):
         main_device = block_device_mappings[0]['DeviceName']
 
         if main_device == 'xvda':
@@ -988,17 +1000,20 b' def temporary_linux_dev_instances(c: AWS'
         elif main_device == '/dev/sda1':
             second_device = '/dev/sdb'
         else:
-            raise ValueError('unhandled primary EBS device name: %s' %
-                             main_device)
+            raise ValueError(
+                'unhandled primary EBS device name: %s' % main_device
+            )
 
-        block_device_mappings.append({
+        block_device_mappings.append(
+            {
             'DeviceName': second_device,
             'Ebs': {
                 'DeleteOnTermination': True,
                 'VolumeSize': 8,
                 'VolumeType': 'gp2',
+                },
             }
-        })
+        )
 
     config = {
         'BlockDeviceMappings': block_device_mappings,
@@ -1019,9 +1034,11 b' def temporary_linux_dev_instances(c: AWS'
 
         for instance in instances:
             client = wait_for_ssh(
-                instance.public_ip_address, 22,
+                instance.public_ip_address,
+                22,
                 username='hg',
-                key_filename=ssh_private_key_path)
+                key_filename=ssh_private_key_path,
+            )
 
             instance.ssh_client = client
             instance.ssh_private_key_path = ssh_private_key_path
@@ -1033,8 +1050,9 b' def temporary_linux_dev_instances(c: AWS'
                 instance.ssh_client.close()
 
 
-def ensure_windows_dev_ami(c: AWSConnection, prefix='hg-',
-                           base_image_name=WINDOWS_BASE_IMAGE_NAME):
+def ensure_windows_dev_ami(
+    c: AWSConnection, prefix='hg-', base_image_name=WINDOWS_BASE_IMAGE_NAME
+):
     """Ensure Windows Development AMI is available and up-to-date.
 
     If necessary, a modern AMI will be built by starting a temporary EC2
@@ -1100,13 +1118,15 b' def ensure_windows_dev_ami(c: AWSConnect'
 
     # Compute a deterministic fingerprint to determine whether image needs
     # to be regenerated.
-    fingerprint = resolve_fingerprint({
+    fingerprint = resolve_fingerprint(
+        {
         'instance_config': config,
         'user_data': WINDOWS_USER_DATA,
         'initial_bootstrap': WINDOWS_BOOTSTRAP_POWERSHELL,
         'bootstrap_commands': commands,
         'base_image_name': base_image_name,
-    })
+        }
+    )
 
     existing_image = find_and_reconcile_image(ec2resource, name, fingerprint)
 
@@ -1131,9 +1151,7 b' def ensure_windows_dev_ami(c: AWSConnect'
             ssmclient,
             [instance],
             'AWS-RunPowerShellScript',
-            {
-                'commands': WINDOWS_BOOTSTRAP_POWERSHELL.split('\n'),
-            },
+            {'commands': WINDOWS_BOOTSTRAP_POWERSHELL.split('\n'),},
         )
 
         # Reboot so all updates are fully applied.
@@ -1145,10 +1163,8 b' def ensure_windows_dev_ami(c: AWSConnect'
         print('rebooting instance %s' % instance.id)
         instance.stop()
         ec2client.get_waiter('instance_stopped').wait(
-            InstanceIds=[instance.id],
-            WaiterConfig={
-                'Delay': 5,
-            })
+            InstanceIds=[instance.id], WaiterConfig={'Delay': 5,}
+        )
 
         instance.start()
         wait_for_ip_addresses([instance])
@@ -1159,8 +1175,11 b' def ensure_windows_dev_ami(c: AWSConnect'
         # TODO figure out a workaround.
 
         print('waiting for Windows Remote Management to come back...')
-        client = wait_for_winrm(instance.public_ip_address, 'Administrator',
-                                c.automation.default_password())
+        client = wait_for_winrm(
+            instance.public_ip_address,
+            'Administrator',
+            c.automation.default_password(),
+        )
         print('established WinRM connection to %s' % instance.id)
         instance.winrm_client = client
 
@@ -1168,14 +1187,23 b' def ensure_windows_dev_ami(c: AWSConnect'
         run_powershell(instance.winrm_client, '\n'.join(commands))
 
         print('bootstrap completed; stopping %s to create image' % instance.id)
-        return create_ami_from_instance(ec2client, instance, name,
+        return create_ami_from_instance(
+            ec2client,
+            instance,
+            name,
                                         'Mercurial Windows development environment',
-                                        fingerprint)
+            fingerprint,
+        )
 
 
 @contextlib.contextmanager
-def temporary_windows_dev_instances(c: AWSConnection, image, instance_type,
-                                    prefix='hg-', disable_antivirus=False):
+def temporary_windows_dev_instances(
+    c: AWSConnection,
+    image,
+    instance_type,
+    prefix='hg-',
+    disable_antivirus=False,
+):
     """Create a temporary Windows development EC2 instance.
 
     Context manager resolves to the list of ``EC2.Instance`` that were created.
@@ -1205,6 +1233,7 b' def temporary_windows_dev_instances(c: A'
             for instance in instances:
                 run_powershell(
                     instance.winrm_client,
-                    'Set-MpPreference -DisableRealtimeMonitoring $true')
+                    'Set-MpPreference -DisableRealtimeMonitoring $true',
+                )
 
         yield instances

contrib/automation/hgautomation/cli.py

@@ -22,12 +22,15 b' from . import ('
 )
 
 
-SOURCE_ROOT = pathlib.Path(os.path.abspath(__file__)).parent.parent.parent.parent
+SOURCE_ROOT = pathlib.Path(
+    os.path.abspath(__file__)
+).parent.parent.parent.parent
 DIST_PATH = SOURCE_ROOT / 'dist'
 
 
-def bootstrap_linux_dev(hga: HGAutomation, aws_region, distros=None,
-                        parallel=False):
+def bootstrap_linux_dev(
+    hga: HGAutomation, aws_region, distros=None, parallel=False
+):
     c = hga.aws_connection(aws_region)
 
     if distros:
@@ -59,8 +62,9 b' def bootstrap_windows_dev(hga: HGAutomat'
     print('Windows development AMI available as %s' % image.id)
 
 
-def build_inno(hga: HGAutomation, aws_region, arch, revision, version,
-               base_image_name):
+def build_inno(
+    hga: HGAutomation, aws_region, arch, revision, version, base_image_name
+):
     c = hga.aws_connection(aws_region)
     image = aws.ensure_windows_dev_ami(c, base_image_name=base_image_name)
     DIST_PATH.mkdir(exist_ok=True)
@@ -71,13 +75,14 b' def build_inno(hga: HGAutomation, aws_re'
         windows.synchronize_hg(SOURCE_ROOT, revision, instance)
 
         for a in arch:
-            windows.build_inno_installer(instance.winrm_client, a,
-                                         DIST_PATH,
-                                         version=version)
+            windows.build_inno_installer(
+                instance.winrm_client, a, DIST_PATH, version=version
+            )
 
 
-def build_wix(hga: HGAutomation, aws_region, arch, revision, version,
-              base_image_name):
+def build_wix(
+    hga: HGAutomation, aws_region, arch, revision, version, base_image_name
+):
     c = hga.aws_connection(aws_region)
     image = aws.ensure_windows_dev_ami(c, base_image_name=base_image_name)
     DIST_PATH.mkdir(exist_ok=True)
@@ -88,12 +93,14 b' def build_wix(hga: HGAutomation, aws_reg'
         windows.synchronize_hg(SOURCE_ROOT, revision, instance)
 
         for a in arch:
-            windows.build_wix_installer(instance.winrm_client, a,
-                                        DIST_PATH, version=version)
+            windows.build_wix_installer(
+                instance.winrm_client, a, DIST_PATH, version=version
+            )
 
 
-def build_windows_wheel(hga: HGAutomation, aws_region, arch, revision,
-                        base_image_name):
+def build_windows_wheel(
+    hga: HGAutomation, aws_region, arch, revision, base_image_name
+):
     c = hga.aws_connection(aws_region)
     image = aws.ensure_windows_dev_ami(c, base_image_name=base_image_name)
     DIST_PATH.mkdir(exist_ok=True)
@@ -107,8 +114,9 b' def build_windows_wheel(hga: HGAutomatio'
             windows.build_wheel(instance.winrm_client, a, DIST_PATH)
 
 
-def build_all_windows_packages(hga: HGAutomation, aws_region, revision,
-                               version, base_image_name):
+def build_all_windows_packages(
+    hga: HGAutomation, aws_region, revision, version, base_image_name
+):
     c = hga.aws_connection(aws_region)
     image = aws.ensure_windows_dev_ami(c, base_image_name=base_image_name)
     DIST_PATH.mkdir(exist_ok=True)
@@ -124,11 +132,13 b' def build_all_windows_packages(hga: HGAu'
             windows.purge_hg(winrm_client)
             windows.build_wheel(winrm_client, arch, DIST_PATH)
             windows.purge_hg(winrm_client)
-            windows.build_inno_installer(winrm_client, arch, DIST_PATH,
-                                         version=version)
+            windows.build_inno_installer(
+                winrm_client, arch, DIST_PATH, version=version
+            )
             windows.purge_hg(winrm_client)
-            windows.build_wix_installer(winrm_client, arch, DIST_PATH,
-                                        version=version)
+            windows.build_wix_installer(
+                winrm_client, arch, DIST_PATH, version=version
+            )
 
 
 def terminate_ec2_instances(hga: HGAutomation, aws_region):
@@ -141,8 +151,15 b' def purge_ec2_resources(hga: HGAutomatio'
     aws.remove_resources(c)
 
 
-def run_tests_linux(hga: HGAutomation, aws_region, instance_type,
-                    python_version, test_flags, distro, filesystem):
+def run_tests_linux(
+    hga: HGAutomation,
+    aws_region,
+    instance_type,
+    python_version,
+    test_flags,
+    distro,
+    filesystem,
+):
     c = hga.aws_connection(aws_region)
     image = aws.ensure_linux_dev_ami(c, distro=distro)
 
@@ -151,17 +168,17 b' def run_tests_linux(hga: HGAutomation, a'
     ensure_extra_volume = filesystem not in ('default', 'tmpfs')
 
     with aws.temporary_linux_dev_instances(
-        c, image, instance_type,
-        ensure_extra_volume=ensure_extra_volume) as insts:
+        c, image, instance_type, ensure_extra_volume=ensure_extra_volume
+    ) as insts:
 
         instance = insts[0]
 
-        linux.prepare_exec_environment(instance.ssh_client,
-                                       filesystem=filesystem)
+        linux.prepare_exec_environment(
+            instance.ssh_client, filesystem=filesystem
+        )
         linux.synchronize_hg(SOURCE_ROOT, instance, '.')
         t_prepared = time.time()
-        linux.run_tests(instance.ssh_client, python_version,
-                        test_flags)
+        linux.run_tests(instance.ssh_client, python_version, test_flags)
         t_done = time.time()
 
     t_setup = t_prepared - t_start
@@ -169,29 +186,48 b' def run_tests_linux(hga: HGAutomation, a'
 
     print(
         'total time: %.1fs; setup: %.1fs; tests: %.1fs; setup overhead: %.1f%%'
-        % (t_all, t_setup, t_done - t_prepared, t_setup / t_all * 100.0))
+        % (t_all, t_setup, t_done - t_prepared, t_setup / t_all * 100.0)
+    )
 
 
-def run_tests_windows(hga: HGAutomation, aws_region, instance_type,
-                      python_version, arch, test_flags, base_image_name):
+def run_tests_windows(
+    hga: HGAutomation,
+    aws_region,
+    instance_type,
+    python_version,
+    arch,
+    test_flags,
+    base_image_name,
+):
     c = hga.aws_connection(aws_region)
     image = aws.ensure_windows_dev_ami(c, base_image_name=base_image_name)
 
-    with aws.temporary_windows_dev_instances(c, image, instance_type,
-                                             disable_antivirus=True) as insts:
+    with aws.temporary_windows_dev_instances(
+        c, image, instance_type, disable_antivirus=True
+    ) as insts:
         instance = insts[0]
 
         windows.synchronize_hg(SOURCE_ROOT, '.', instance)
-        windows.run_tests(instance.winrm_client, python_version, arch,
-                          test_flags)
+        windows.run_tests(
+            instance.winrm_client, python_version, arch, test_flags
+        )
 
 
-def publish_windows_artifacts(hg: HGAutomation, aws_region, version: str,
-                              pypi: bool, mercurial_scm_org: bool,
-                              ssh_username: str):
-    windows.publish_artifacts(DIST_PATH, version,
-                              pypi=pypi, mercurial_scm_org=mercurial_scm_org,
-                              ssh_username=ssh_username)
+def publish_windows_artifacts(
+    hg: HGAutomation,
+    aws_region,
+    version: str,
+    pypi: bool,
+    mercurial_scm_org: bool,
+    ssh_username: str,
+):
+    windows.publish_artifacts(
+        DIST_PATH,
+        version,
+        pypi=pypi,
+        mercurial_scm_org=mercurial_scm_org,
+        ssh_username=ssh_username,
+    )
 
 
 def run_try(hga: HGAutomation, aws_region: str, rev: str):
@@ -208,25 +244,21 b' def get_parser():'
         help='Path for local state files',
     )
     parser.add_argument(
-        '--aws-region',
-        help='AWS region to use',
-        default='us-west-2',
+        '--aws-region', help='AWS region to use', default='us-west-2',
     )
 
     subparsers = parser.add_subparsers()
 
     sp = subparsers.add_parser(
-        'bootstrap-linux-dev',
-        help='Bootstrap Linux development environments',
+        'bootstrap-linux-dev', help='Bootstrap Linux development environments',
     )
     sp.add_argument(
-        '--distros',
-        help='Comma delimited list of distros to bootstrap',
+        '--distros', help='Comma delimited list of distros to bootstrap',
     )
     sp.add_argument(
         '--parallel',
         action='store_true',
-        help='Generate AMIs in parallel (not CTRL-c safe)'
+        help='Generate AMIs in parallel (not CTRL-c safe)',
     )
     sp.set_defaults(func=bootstrap_linux_dev)
 
@@ -242,17 +274,13 b' def get_parser():'
     sp.set_defaults(func=bootstrap_windows_dev)
 
     sp = subparsers.add_parser(
-        'build-all-windows-packages',
-        help='Build all Windows packages',
+        'build-all-windows-packages', help='Build all Windows packages',
     )
     sp.add_argument(
-        '--revision',
-        help='Mercurial revision to build',
-        default='.',
+        '--revision', help='Mercurial revision to build', default='.',
     )
     sp.add_argument(
-        '--version',
-        help='Mercurial version string to use',
+        '--version', help='Mercurial version string to use',
     )
     sp.add_argument(
         '--base-image-name',
@@ -262,8 +290,7 b' def get_parser():'
     sp.set_defaults(func=build_all_windows_packages)
 
     sp = subparsers.add_parser(
-        'build-inno',
-        help='Build Inno Setup installer(s)',
+        'build-inno', help='Build Inno Setup installer(s)',
     )
     sp.add_argument(
         '--arch',
@@ -273,13 +300,10 b' def get_parser():'
         default=['x64'],
     )
     sp.add_argument(
-        '--revision',
-        help='Mercurial revision to build',
-        default='.',
+        '--revision', help='Mercurial revision to build', default='.',
     )
     sp.add_argument(
-        '--version',
-        help='Mercurial version string to use in installer',
+        '--version', help='Mercurial version string to use in installer',
     )
     sp.add_argument(
         '--base-image-name',
@@ -289,8 +313,7 b' def get_parser():'
     sp.set_defaults(func=build_inno)
 
     sp = subparsers.add_parser(
-        'build-windows-wheel',
-        help='Build Windows wheel(s)',
+        'build-windows-wheel', help='Build Windows wheel(s)',
     )
     sp.add_argument(
         '--arch',
@@ -300,9 +323,7 b' def get_parser():'
         default=['x64'],
     )
     sp.add_argument(
-        '--revision',
-        help='Mercurial revision to build',
-        default='.',
+        '--revision', help='Mercurial revision to build', default='.',
     )
     sp.add_argument(
         '--base-image-name',
@@ -311,10 +332,7 b' def get_parser():'
     )
     sp.set_defaults(func=build_windows_wheel)
 
-    sp = subparsers.add_parser(
-        'build-wix',
-        help='Build WiX installer(s)'
-    )
+    sp = subparsers.add_parser('build-wix', help='Build WiX installer(s)')
     sp.add_argument(
         '--arch',
         help='Architecture to build for',
@@ -323,13 +341,10 b' def get_parser():'
         default=['x64'],
     )
     sp.add_argument(
-        '--revision',
-        help='Mercurial revision to build',
-        default='.',
+        '--revision', help='Mercurial revision to build', default='.',
     )
     sp.add_argument(
-        '--version',
-        help='Mercurial version string to use in installer',
+        '--version', help='Mercurial version string to use in installer',
     )
     sp.add_argument(
         '--base-image-name',
@@ -345,15 +360,11 b' def get_parser():'
     sp.set_defaults(func=terminate_ec2_instances)
 
     sp = subparsers.add_parser(
-        'purge-ec2-resources',
-        help='Purge all EC2 resources managed by us',
+        'purge-ec2-resources', help='Purge all EC2 resources managed by us',
     )
     sp.set_defaults(func=purge_ec2_resources)
 
-    sp = subparsers.add_parser(
-        'run-tests-linux',
-        help='Run tests on Linux',
-    )
+    sp = subparsers.add_parser('run-tests-linux', help='Run tests on Linux',)
     sp.add_argument(
         '--distro',
         help='Linux distribution to run tests on',
@@ -374,8 +385,18 b' def get_parser():'
     sp.add_argument(
         '--python-version',
         help='Python version to use',
-        choices={'system2', 'system3', '2.7', '3.5', '3.6', '3.7', '3.8',
-                 'pypy', 'pypy3.5', 'pypy3.6'},
+        choices={
+            'system2',
+            'system3',
+            '2.7',
+            '3.5',
+            '3.6',
+            '3.7',
+            '3.8',
+            'pypy',
+            'pypy3.5',
+            'pypy3.6',
+        },
         default='system2',
     )
     sp.add_argument(
@@ -386,13 +407,10 b' def get_parser():'
     sp.set_defaults(func=run_tests_linux)
 
     sp = subparsers.add_parser(
-        'run-tests-windows',
-        help='Run tests on Windows',
+        'run-tests-windows', help='Run tests on Windows',
     )
     sp.add_argument(
-        '--instance-type',
-        help='EC2 instance type to use',
-        default='t3.medium',
+        '--instance-type', help='EC2 instance type to use', default='t3.medium',
     )
     sp.add_argument(
         '--python-version',
@@ -407,8 +425,7 b' def get_parser():'
         default='x64',
     )
     sp.add_argument(
-        '--test-flags',
-        help='Extra command line flags to pass to run-tests.py',
+        '--test-flags', help='Extra command line flags to pass to run-tests.py',
     )
     sp.add_argument(
         '--base-image-name',
@@ -419,7 +436,7 b' def get_parser():'
 
     sp = subparsers.add_parser(
         'publish-windows-artifacts',
-        help='Publish built Windows artifacts (wheels, installers, etc)'
+        help='Publish built Windows artifacts (wheels, installers, etc)',
     )
     sp.add_argument(
         '--no-pypi',
@@ -436,22 +453,17 b' def get_parser():'
         help='Skip uploading to www.mercurial-scm.org',
     )
     sp.add_argument(
-        '--ssh-username',
-        help='SSH username for mercurial-scm.org',
+        '--ssh-username', help='SSH username for mercurial-scm.org',
     )
     sp.add_argument(
-        'version',
-        help='Mercurial version string to locate local packages',
+        'version', help='Mercurial version string to locate local packages',
     )
     sp.set_defaults(func=publish_windows_artifacts)
 
     sp = subparsers.add_parser(
-        'try',
-        help='Run CI automation against a custom changeset'
+        'try', help='Run CI automation against a custom changeset'
     )
-    sp.add_argument('-r', '--rev',
-                    default='.',
-                    help='Revision to run CI on')
+    sp.add_argument('-r', '--rev', default='.', help='Revision to run CI on')
     sp.set_defaults(func=run_try)
 
     return parser

contrib/automation/hgautomation/linux.py

@@ -13,9 +13,7 b' import shlex'
 import subprocess
 import tempfile
 
-from .ssh import (
-    exec_command,
-)
+from .ssh import exec_command
 
 
 # Linux distributions that are supported.
@@ -62,7 +60,9 b' for v in ${PYENV3_VERSIONS}; do'
 done
 
 pyenv global ${PYENV2_VERSIONS} ${PYENV3_VERSIONS} system
-'''.lstrip().replace('\r\n', '\n')
+'''.lstrip().replace(
+    '\r\n', '\n'
+)
 
 
 INSTALL_RUST = r'''
@@ -87,10 +87,13 b' wget -O ${HG_TARBALL} --progress dot:meg'
 echo "${HG_SHA256} ${HG_TARBALL}" | sha256sum --check -
 
 /hgdev/venv-bootstrap/bin/pip install ${HG_TARBALL}
-'''.lstrip().replace('\r\n', '\n')
+'''.lstrip().replace(
+    '\r\n', '\n'
+)
 
 
-BOOTSTRAP_DEBIAN = r'''
+BOOTSTRAP_DEBIAN = (
+    r'''
 #!/bin/bash
 
 set -ex
@@ -323,11 +326,14 b' publish = false'
 EOF
 
 sudo chown -R hg:hg /hgdev
-'''.lstrip().format(
+'''.lstrip()
+    .format(
     install_rust=INSTALL_RUST,
     install_pythons=INSTALL_PYTHONS,
-    bootstrap_virtualenv=BOOTSTRAP_VIRTUALENV
-).replace('\r\n', '\n')
+        bootstrap_virtualenv=BOOTSTRAP_VIRTUALENV,
+    )
+    .replace('\r\n', '\n')
+)
 
 
 # Prepares /hgdev for operations.
@@ -409,7 +415,9 b' mkdir /hgwork/tmp'
 chown hg:hg /hgwork/tmp
 
 rsync -a /hgdev/src /hgwork/
-'''.lstrip().replace('\r\n', '\n')
+'''.lstrip().replace(
+    '\r\n', '\n'
+)
 
 
 HG_UPDATE_CLEAN = '''
@@ -421,7 +429,9 b' cd /hgwork/src'
 ${HG} --config extensions.purge= purge --all
 ${HG} update -C $1
 ${HG} log -r .
-'''.lstrip().replace('\r\n', '\n')
+'''.lstrip().replace(
+    '\r\n', '\n'
+)
 
 
 def prepare_exec_environment(ssh_client, filesystem='default'):
@@ -456,11 +466,12 b' def prepare_exec_environment(ssh_client,'
     res = chan.recv_exit_status()
 
     if res:
-        raise Exception('non-0 exit code updating working directory; %d'
-                        % res)
+        raise Exception('non-0 exit code updating working directory; %d' % res)
 
 
-def synchronize_hg(source_path: pathlib.Path, ec2_instance, revision: str=None):
+def synchronize_hg(
+    source_path: pathlib.Path, ec2_instance, revision: str = None
+):
     """Synchronize a local Mercurial source path to remote EC2 instance."""
 
     with tempfile.TemporaryDirectory() as temp_dir:
@@ -482,8 +493,10 b' def synchronize_hg(source_path: pathlib.'
             fh.write('  IdentityFile %s\n' % ec2_instance.ssh_private_key_path)
 
         if not (source_path / '.hg').is_dir():
-            raise Exception('%s is not a Mercurial repository; synchronization '
-                            'not yet supported' % source_path)
+            raise Exception(
+                '%s is not a Mercurial repository; synchronization '
+                'not yet supported' % source_path
+            )
 
         env = dict(os.environ)
         env['HGPLAIN'] = '1'
@@ -493,17 +506,29 b' def synchronize_hg(source_path: pathlib.'
 
         res = subprocess.run(
             ['python2.7', str(hg_bin), 'log', '-r', revision, '-T', '{node}'],
-            cwd=str(source_path), env=env, check=True, capture_output=True)
+            cwd=str(source_path),
+            env=env,
+            check=True,
+            capture_output=True,
+        )
 
         full_revision = res.stdout.decode('ascii')
 
         args = [
-            'python2.7', str(hg_bin),
-            '--config', 'ui.ssh=ssh -F %s' % ssh_config,
-            '--config', 'ui.remotecmd=/hgdev/venv-bootstrap/bin/hg',
+            'python2.7',
+            str(hg_bin),
+            '--config',
+            'ui.ssh=ssh -F %s' % ssh_config,
+            '--config',
+            'ui.remotecmd=/hgdev/venv-bootstrap/bin/hg',
             # Also ensure .hgtags changes are present so auto version
             # calculation works.
-            'push', '-f', '-r', full_revision, '-r', 'file(.hgtags)',
+            'push',
+            '-f',
+            '-r',
+            full_revision,
+            '-r',
+            'file(.hgtags)',
             'ssh://%s//hgwork/src' % public_ip,
         ]
 
@@ -522,7 +547,8 b' def synchronize_hg(source_path: pathlib.'
             fh.chmod(0o0700)
 
         chan, stdin, stdout = exec_command(
-            ec2_instance.ssh_client, '/hgdev/hgup %s' % full_revision)
+            ec2_instance.ssh_client, '/hgdev/hgup %s' % full_revision
+        )
         stdin.close()
 
         for line in stdout:
@@ -531,8 +557,9 b' def synchronize_hg(source_path: pathlib.'
         res = chan.recv_exit_status()
 
         if res:
-            raise Exception('non-0 exit code updating working directory; %d'
-                            % res)
+            raise Exception(
+                'non-0 exit code updating working directory; %d' % res
+            )
 
 
 def run_tests(ssh_client, python_version, test_flags=None):
@@ -554,8 +581,8 b' def run_tests(ssh_client, python_version'
 
     command = (
         '/bin/sh -c "export TMPDIR=/hgwork/tmp; '
-        'cd /hgwork/src/tests && %s run-tests.py %s"' % (
-            python, test_flags))
+        'cd /hgwork/src/tests && %s run-tests.py %s"' % (python, test_flags)
+    )
 
     chan, stdin, stdout = exec_command(ssh_client, command)
 

contrib/automation/hgautomation/pypi.py

@@ -7,12 +7,8 b''
 
 # no-check-code because Python 3 native.
 
-from twine.commands.upload import (
-    upload as twine_upload,
-)
-from twine.settings import (
-    Settings,
-)
+from twine.commands.upload import upload as twine_upload
+from twine.settings import Settings
 
 
 def upload(paths):

contrib/automation/hgautomation/ssh.py

@@ -11,14 +11,13 b' import socket'
 import time
 import warnings
 
-from cryptography.utils import (
-    CryptographyDeprecationWarning,
-)
+from cryptography.utils import CryptographyDeprecationWarning
 import paramiko
 
 
 def wait_for_ssh(hostname, port, timeout=60, username=None, key_filename=None):
     """Wait for an SSH server to start on the specified host and port."""
+
     class IgnoreHostKeyPolicy(paramiko.MissingHostKeyPolicy):
         def missing_host_key(self, client, hostname, key):
             return
@@ -28,17 +27,23 b' def wait_for_ssh(hostname, port, timeout'
     # paramiko triggers a CryptographyDeprecationWarning in the cryptography
     # package. Let's suppress
     with warnings.catch_warnings():
-        warnings.filterwarnings('ignore',
-                                category=CryptographyDeprecationWarning)
+        warnings.filterwarnings(
+            'ignore', category=CryptographyDeprecationWarning
+        )
 
         while True:
             client = paramiko.SSHClient()
             client.set_missing_host_key_policy(IgnoreHostKeyPolicy())
             try:
-                client.connect(hostname, port=port, username=username,
+                client.connect(
+                    hostname,
+                    port=port,
+                    username=username,
                                key_filename=key_filename,
-                               timeout=5.0, allow_agent=False,
-                               look_for_keys=False)
+                    timeout=5.0,
+                    allow_agent=False,
+                    look_for_keys=False,
+                )
 
                 return client
             except socket.error:

contrib/automation/hgautomation/windows.py

@@ -15,12 +15,8 b' import re'
 import subprocess
 import tempfile
 
-from .pypi import (
-    upload as pypi_upload,
-)
-from .winrm import (
-    run_powershell,
-)
+from .pypi import upload as pypi_upload
+from .winrm import run_powershell
 
 
 # PowerShell commands to activate a Visual Studio 2008 environment.
@@ -117,14 +113,21 b" MERCURIAL_SCM_BASE_URL = 'https://mercur"
 X86_USER_AGENT_PATTERN = '.*Windows.*'
 X64_USER_AGENT_PATTERN = '.*Windows.*(WOW|x)64.*'
 
-X86_EXE_DESCRIPTION = ('Mercurial {version} Inno Setup installer - x86 Windows '
-                       '- does not require admin rights')
-X64_EXE_DESCRIPTION = ('Mercurial {version} Inno Setup installer - x64 Windows '
-                       '- does not require admin rights')
-X86_MSI_DESCRIPTION = ('Mercurial {version} MSI installer - x86 Windows '
-                       '- requires admin rights')
-X64_MSI_DESCRIPTION = ('Mercurial {version} MSI installer - x64 Windows '
-                       '- requires admin rights')
+X86_EXE_DESCRIPTION = (
+    'Mercurial {version} Inno Setup installer - x86 Windows '
+    '- does not require admin rights'
+)
+X64_EXE_DESCRIPTION = (
+    'Mercurial {version} Inno Setup installer - x64 Windows '
+    '- does not require admin rights'
+)
+X86_MSI_DESCRIPTION = (
+    'Mercurial {version} MSI installer - x86 Windows ' '- requires admin rights'
+)
+X64_MSI_DESCRIPTION = (
+    'Mercurial {version} MSI installer - x64 Windows ' '- requires admin rights'
+)
+
 
 def get_vc_prefix(arch):
     if arch == 'x86':
@@ -158,10 +161,21 b' def synchronize_hg(hg_repo: pathlib.Path'
         ssh_dir.chmod(0o0700)
 
         # Generate SSH key to use for communication.
-        subprocess.run([
-            'ssh-keygen', '-t', 'rsa', '-b', '4096', '-N', '',
-            '-f', str(ssh_dir / 'id_rsa')],
-            check=True, capture_output=True)
+        subprocess.run(
+            [
+                'ssh-keygen',
+                '-t',
+                'rsa',
+                '-b',
+                '4096',
+                '-N',
+                '',
+                '-f',
+                str(ssh_dir / 'id_rsa'),
+            ],
+            check=True,
+            capture_output=True,
+        )
 
         # Add it to ~/.ssh/authorized_keys on remote.
         # This assumes the file doesn't already exist.
@@ -182,8 +196,10 b' def synchronize_hg(hg_repo: pathlib.Path'
             fh.write('  IdentityFile %s\n' % (ssh_dir / 'id_rsa'))
 
         if not (hg_repo / '.hg').is_dir():
-            raise Exception('%s is not a Mercurial repository; '
-                            'synchronization not yet supported' % hg_repo)
+            raise Exception(
+                '%s is not a Mercurial repository; '
+                'synchronization not yet supported' % hg_repo
+            )
 
         env = dict(os.environ)
         env['HGPLAIN'] = '1'
@@ -193,17 +209,29 b' def synchronize_hg(hg_repo: pathlib.Path'
 
         res = subprocess.run(
             ['python2.7', str(hg_bin), 'log', '-r', revision, '-T', '{node}'],
-            cwd=str(hg_repo), env=env, check=True, capture_output=True)
+            cwd=str(hg_repo),
+            env=env,
+            check=True,
+            capture_output=True,
+        )
 
         full_revision = res.stdout.decode('ascii')
 
         args = [
-            'python2.7', hg_bin,
-            '--config', 'ui.ssh=ssh -F %s' % ssh_config,
-            '--config', 'ui.remotecmd=c:/hgdev/venv-bootstrap/Scripts/hg.exe',
+            'python2.7',
+            hg_bin,
+            '--config',
+            'ui.ssh=ssh -F %s' % ssh_config,
+            '--config',
+            'ui.remotecmd=c:/hgdev/venv-bootstrap/Scripts/hg.exe',
             # Also ensure .hgtags changes are present so auto version
             # calculation works.
-            'push', '-f', '-r', full_revision, '-r', 'file(.hgtags)',
+            'push',
+            '-f',
+            '-r',
+            full_revision,
+            '-r',
+            'file(.hgtags)',
             'ssh://%s/c:/hgdev/src' % public_ip,
         ]
 
@@ -213,8 +241,9 b' def synchronize_hg(hg_repo: pathlib.Path'
         if res.returncode not in (0, 1):
             res.check_returncode()
 
-        run_powershell(winrm_client,
-                       HG_UPDATE_CLEAN.format(revision=full_revision))
+        run_powershell(
+            winrm_client, HG_UPDATE_CLEAN.format(revision=full_revision)
+        )
 
         # TODO detect dirty local working directory and synchronize accordingly.
 
@@ -250,8 +279,9 b' def copy_latest_dist(winrm_client, patte'
     winrm_client.fetch(source, str(dest))
 
 
-def build_inno_installer(winrm_client, arch: str, dest_path: pathlib.Path,
-                         version=None):
+def build_inno_installer(
+    winrm_client, arch: str, dest_path: pathlib.Path, version=None
+):
     """Build the Inno Setup installer on a remote machine.
 
     Using a WinRM client, remote commands are executed to build
@@ -263,8 +293,9 b' def build_inno_installer(winrm_client, a'
     if version:
         extra_args.extend(['--version', version])
 
-    ps = get_vc_prefix(arch) + BUILD_INNO.format(arch=arch,
-                                                 extra_args=' '.join(extra_args))
+    ps = get_vc_prefix(arch) + BUILD_INNO.format(
+        arch=arch, extra_args=' '.join(extra_args)
+    )
     run_powershell(winrm_client, ps)
     copy_latest_dist(winrm_client, '*.exe', dest_path)
 
@@ -281,8 +312,9 b' def build_wheel(winrm_client, arch: str,'
     copy_latest_dist(winrm_client, '*.whl', dest_path)
 
 
-def build_wix_installer(winrm_client, arch: str, dest_path: pathlib.Path,
-                        version=None):
+def build_wix_installer(
+    winrm_client, arch: str, dest_path: pathlib.Path, version=None
+):
     """Build the WiX installer on a remote machine.
 
     Using a WinRM client, remote commands are executed to build a WiX installer.
@@ -292,8 +324,9 b' def build_wix_installer(winrm_client, ar'
     if version:
         extra_args.extend(['--version', version])
 
-    ps = get_vc_prefix(arch) + BUILD_WIX.format(arch=arch,
-                                                extra_args=' '.join(extra_args))
+    ps = get_vc_prefix(arch) + BUILD_WIX.format(
+        arch=arch, extra_args=' '.join(extra_args)
+    )
     run_powershell(winrm_client, ps)
     copy_latest_dist(winrm_client, '*.msi', dest_path)
 
@@ -307,18 +340,16 b' def run_tests(winrm_client, python_versi'
     ``run-tests.py``.
     """
     if not re.match(r'\d\.\d', python_version):
-        raise ValueError(r'python_version must be \d.\d; got %s' %
-                         python_version)
+        raise ValueError(
+            r'python_version must be \d.\d; got %s' % python_version
+        )
 
     if arch not in ('x86', 'x64'):
         raise ValueError('arch must be x86 or x64; got %s' % arch)
 
     python_path = 'python%s-%s' % (python_version.replace('.', ''), arch)
 
-    ps = RUN_TESTS.format(
-        python_path=python_path,
-        test_flags=test_flags or '',
-    )
+    ps = RUN_TESTS.format(python_path=python_path, test_flags=test_flags or '',)
 
     run_powershell(winrm_client, ps)
 
@@ -374,8 +405,8 b' def generate_latest_dat(version: str):'
             version,
             X64_USER_AGENT_PATTERN,
             '%s/%s' % (MERCURIAL_SCM_BASE_URL, x64_msi_filename),
-            X64_MSI_DESCRIPTION.format(version=version)
-        )
+            X64_MSI_DESCRIPTION.format(version=version),
+        ),
     )
 
     lines = ['\t'.join(e) for e in entries]
@@ -396,8 +427,9 b' def publish_artifacts_pypi(dist_path: pa'
     pypi_upload(wheel_paths)
 
 
-def publish_artifacts_mercurial_scm_org(dist_path: pathlib.Path, version: str,
-                                        ssh_username=None):
+def publish_artifacts_mercurial_scm_org(
+    dist_path: pathlib.Path, version: str, ssh_username=None
+):
     """Publish Windows release artifacts to mercurial-scm.org."""
     all_paths = resolve_all_artifacts(dist_path, version)
 
@@ -436,7 +468,8 b' def publish_artifacts_mercurial_scm_org('
 
     now = datetime.datetime.utcnow()
     backup_path = dist_path / (
-        'latest-windows-%s.dat' % now.strftime('%Y%m%dT%H%M%S'))
+        'latest-windows-%s.dat' % now.strftime('%Y%m%dT%H%M%S')
+    )
     print('backing up %s to %s' % (latest_dat_path, backup_path))
 
     with sftp.open(latest_dat_path, 'rb') as fh:
@@ -453,9 +486,13 b' def publish_artifacts_mercurial_scm_org('
         fh.write(latest_dat_content.encode('ascii'))
 
 
-def publish_artifacts(dist_path: pathlib.Path, version: str,
-                      pypi=True, mercurial_scm_org=True,
-                      ssh_username=None):
+def publish_artifacts(
+    dist_path: pathlib.Path,
+    version: str,
+    pypi=True,
+    mercurial_scm_org=True,
+    ssh_username=None,
+):
     """Publish Windows release artifacts.
 
     Files are found in `dist_path`. We will look for files with version string
@@ -468,5 +505,6 b' def publish_artifacts(dist_path: pathlib'
         publish_artifacts_pypi(dist_path, version)
 
     if mercurial_scm_org:
-        publish_artifacts_mercurial_scm_org(dist_path, version,
-                                            ssh_username=ssh_username)
+        publish_artifacts_mercurial_scm_org(
+            dist_path, version, ssh_username=ssh_username
+        )

contrib/automation/hgautomation/winrm.py

@@ -11,9 +11,7 b' import logging'
 import pprint
 import time
 
-from pypsrp.client import (
-    Client,
-)
+from pypsrp.client import Client
 from pypsrp.powershell import (
     PowerShell,
     PSInvocationState,
@@ -35,8 +33,13 b' def wait_for_winrm(host, username, passw'
 
     while True:
         try:
-            client = Client(host, username=username, password=password,
-                            ssl=ssl, connection_timeout=5)
+            client = Client(
+                host,
+                username=username,
+                password=password,
+                ssl=ssl,
+                connection_timeout=5,
+            )
             client.execute_ps("Write-Host 'Hello, World!'")
             return client
         except requests.exceptions.ConnectionError:
@@ -78,5 +81,7 b' def run_powershell(client, script):'
             print(format_object(o))
 
         if ps.state == PSInvocationState.FAILED:
-            raise Exception('PowerShell execution failed: %s' %
-                            ' '.join(map(format_object, ps.streams.error)))
+            raise Exception(
+                'PowerShell execution failed: %s'
+                % ' '.join(map(format_object, ps.streams.error))
+            )

contrib/bdiff-torture.py

@@ -9,15 +9,20 b' from mercurial import ('
     pycompat,
 )
 
+
 def reducetest(a, b):
     tries = 0
     reductions = 0
     print("reducing...")
     while tries < 1000:
-        a2 = "\n".join(l for l in a.splitlines()
-                       if random.randint(0, 100) > 0) + "\n"
-        b2 = "\n".join(l for l in b.splitlines()
-                       if random.randint(0, 100) > 0) + "\n"
+        a2 = (
+            "\n".join(l for l in a.splitlines() if random.randint(0, 100) > 0)
+            + "\n"
+        )
+        b2 = (
+            "\n".join(l for l in b.splitlines() if random.randint(0, 100) > 0)
+            + "\n"
+        )
         if a2 == a and b2 == b:
             continue
         if a2 == b2:
@@ -32,8 +37,7 b' def reducetest(a, b):'
             a = a2
             b = b2
 
-    print("reduced:", reductions, len(a) + len(b),
-          repr(a), repr(b))
+    print("reduced:", reductions, len(a) + len(b), repr(a), repr(b))
     try:
         test1(a, b)
     except Exception as inst:
@@ -41,6 +45,7 b' def reducetest(a, b):'
 
     sys.exit(0)
 
+
 def test1(a, b):
     d = mdiff.textdiff(a, b)
     if not d:
@@ -49,6 +54,7 b' def test1(a, b):'
     if c != b:
         raise ValueError("bad")
 
+
 def testwrap(a, b):
     try:
         test1(a, b)
@@ -57,10 +63,12 b' def testwrap(a, b):'
         print("exception:", inst)
     reducetest(a, b)
 
+
 def test(a, b):
     testwrap(a, b)
     testwrap(b, a)
 
+
 def rndtest(size, noise):
     a = []
     src = "                aaaaaaaabbbbccd"
@@ -82,6 +90,7 b' def rndtest(size, noise):'
 
     test(a, b)
 
+
 maxvol = 10000
 startsize = 2
 while True:

contrib/benchmarks/__init__.py

@@ -44,15 +44,24 b' from mercurial import ('
     util,
 )
 
-basedir = os.path.abspath(os.path.join(os.path.dirname(__file__),
-                          os.path.pardir, os.path.pardir))
+basedir = os.path.abspath(
+    os.path.join(os.path.dirname(__file__), os.path.pardir, os.path.pardir)
+)
 reposdir = os.environ['REPOS_DIR']
-reposnames = [name for name in os.listdir(reposdir)
-              if os.path.isdir(os.path.join(reposdir, name, ".hg"))]
+reposnames = [
+    name
+    for name in os.listdir(reposdir)
+    if os.path.isdir(os.path.join(reposdir, name, ".hg"))
+]
 if not reposnames:
     raise ValueError("No repositories found in $REPO_DIR")
-outputre = re.compile((r'! wall (\d+.\d+) comb \d+.\d+ user \d+.\d+ sys '
-                       r'\d+.\d+ \(best of \d+\)'))
+outputre = re.compile(
+    (
+        r'! wall (\d+.\d+) comb \d+.\d+ user \d+.\d+ sys '
+        r'\d+.\d+ \(best of \d+\)'
+    )
+)
+
 
 def runperfcommand(reponame, command, *args, **kwargs):
     os.environ["HGRCPATH"] = os.environ.get("ASVHGRCPATH", "")
@@ -63,8 +72,9 b' def runperfcommand(reponame, command, *a'
     else:
         ui = uimod.ui()
     repo = hg.repository(ui, os.path.join(reposdir, reponame))
-    perfext = extensions.load(ui, 'perfext',
-                              os.path.join(basedir, 'contrib', 'perf.py'))
+    perfext = extensions.load(
+        ui, 'perfext', os.path.join(basedir, 'contrib', 'perf.py')
+    )
     cmd = getattr(perfext, command)
     ui.pushbuffer()
     cmd(ui, repo, *args, **kwargs)
@@ -74,6 +84,7 b' def runperfcommand(reponame, command, *a'
         raise ValueError("Invalid output {0}".format(output))
     return float(match.group(1))
 
+
 def perfbench(repos=reposnames, name=None, params=None):
     """decorator to declare ASV benchmark based on contrib/perf.py extension
 
@@ -104,10 +115,12 b' def perfbench(repos=reposnames, name=Non'
         def wrapped(repo, *args):
             def perf(command, *a, **kw):
                 return runperfcommand(repo, command, *a, **kw)
+
             return func(perf, *args)
 
         wrapped.params = [p[1] for p in params]
         wrapped.param_names = [p[0] for p in params]
         wrapped.pretty_name = name
         return wrapped
+
     return decorator

contrib/benchmarks/perf.py

@@ -9,18 +9,22 b' from __future__ import absolute_import'
 
 from . import perfbench
 
+
 @perfbench()
 def track_tags(perf):
     return perf("perftags")
 
+
 @perfbench()
 def track_status(perf):
     return perf("perfstatus", unknown=False)
 
+
 @perfbench(params=[('rev', ['1000', '10000', 'tip'])])
 def track_manifest(perf, rev):
     return perf("perfmanifest", rev)
 
+
 @perfbench()
 def track_heads(perf):
     return perf("perfheads")

contrib/benchmarks/revset.py

@@ -18,15 +18,16 b' import sys'
 
 from . import basedir, perfbench
 
+
 def createrevsetbenchmark(baseset, variants=None):
     if variants is None:
         # Default variants
-        variants = ["plain", "first", "last", "sort", "sort+first",
-                    "sort+last"]
-    fname = "track_" + "_".join("".join([
-        c if c in string.digits + string.letters else " "
-        for c in baseset
-    ]).split())
+        variants = ["plain", "first", "last", "sort", "sort+first", "sort+last"]
+    fname = "track_" + "_".join(
+        "".join(
+            [c if c in string.digits + string.letters else " " for c in baseset]
+        ).split()
+    )
 
     def wrap(fname, baseset):
         @perfbench(name=baseset, params=[("variant", variants)])
@@ -36,18 +37,21 b' def createrevsetbenchmark(baseset, varia'
                 for var in variant.split("+"):
                     revset = "%s(%s)" % (var, revset)
             return perf("perfrevset", revset)
+
         f.__name__ = fname
         return f
+
     return wrap(fname, baseset)
 
+
 def initializerevsetbenchmarks():
     mod = sys.modules[__name__]
-    with open(os.path.join(basedir, 'contrib', 'base-revsets.txt'),
-              'rb') as fh:
+    with open(os.path.join(basedir, 'contrib', 'base-revsets.txt'), 'rb') as fh:
         for line in fh:
             baseset = line.strip()
             if baseset and not baseset.startswith('#'):
                 func = createrevsetbenchmark(baseset)
                 setattr(mod, func.__name__, func)
 
+
 initializerevsetbenchmarks()

contrib/byteify-strings.py

@@ -18,10 +18,13 b' import tempfile'
 import token
 import tokenize
 
+
 def adjusttokenpos(t, ofs):
     """Adjust start/end column of the given token"""
-    return t._replace(start=(t.start[0], t.start[1] + ofs),
-                      end=(t.end[0], t.end[1] + ofs))
+    return t._replace(
+        start=(t.start[0], t.start[1] + ofs), end=(t.end[0], t.end[1] + ofs)
+    )
+
 
 def replacetokens(tokens, opts):
     """Transform a stream of tokens from raw to Python 3.
@@ -82,9 +85,8 b' def replacetokens(tokens, opts):'
         currtoken = tokens[k]
         while currtoken.type in (token.STRING, token.NEWLINE, tokenize.NL):
             k += 1
-            if (
-                currtoken.type == token.STRING
-                and currtoken.string.startswith(("'", '"'))
+            if currtoken.type == token.STRING and currtoken.string.startswith(
+                ("'", '"')
             ):
                 sysstrtokens.add(currtoken)
             try:
@@ -135,9 +137,9 b' def replacetokens(tokens, opts):'
             lastparen = parens[-1]
             if t.start[1] == lastparen[1]:
                 coloffset = lastparen[2]
-            elif (
-                t.start[1] + 1 == lastparen[1]
-                and lastparen[3] not in (token.NEWLINE, tokenize.NL)
+            elif t.start[1] + 1 == lastparen[1] and lastparen[3] not in (
+                token.NEWLINE,
+                tokenize.NL,
             ):
                 # fix misaligned indent of s/util.Abort/error.Abort/
                 coloffset = lastparen[2] + (lastparen[1] - t.start[1])
@@ -202,8 +204,7 b' def replacetokens(tokens, opts):'
                 continue
 
             # String literal. Prefix to make a b'' string.
-            yield adjusttokenpos(t._replace(string='b%s' % t.string),
-                                 coloffset)
+            yield adjusttokenpos(t._replace(string='b%s' % t.string), coloffset)
             coldelta += 1
             continue
 
@@ -213,8 +214,13 b' def replacetokens(tokens, opts):'
 
             # *attr() builtins don't accept byte strings to 2nd argument.
             if fn in (
-                'getattr', 'setattr', 'hasattr', 'safehasattr', 'wrapfunction',
-                'wrapclass', 'addattr'
+                'getattr',
+                'setattr',
+                'hasattr',
+                'safehasattr',
+                'wrapfunction',
+                'wrapclass',
+                'addattr',
             ) and (opts['allow-attr-methods'] or not _isop(i - 1, '.')):
                 arg1idx = _findargnofcall(1)
                 if arg1idx is not None:
@@ -241,18 +247,23 b' def replacetokens(tokens, opts):'
                 _ensuresysstr(i + 4)
 
         # Looks like "if __name__ == '__main__'".
-        if (t.type == token.NAME and t.string == '__name__'
-            and _isop(i + 1, '==')):
+        if (
+            t.type == token.NAME
+            and t.string == '__name__'
+            and _isop(i + 1, '==')
+        ):
             _ensuresysstr(i + 2)
 
         # Emit unmodified token.
         yield adjusttokenpos(t, coloffset)
 
+
 def process(fin, fout, opts):
     tokens = tokenize.tokenize(fin.readline)
     tokens = replacetokens(list(tokens), opts)
     fout.write(tokenize.untokenize(tokens))
 
+
 def tryunlink(fname):
     try:
         os.unlink(fname)
@@ -260,12 +271,14 b' def tryunlink(fname):'
         if err.errno != errno.ENOENT:
             raise
 
+
 @contextlib.contextmanager
 def editinplace(fname):
     n = os.path.basename(fname)
     d = os.path.dirname(fname)
-    fp = tempfile.NamedTemporaryFile(prefix='.%s-' % n, suffix='~', dir=d,
-                                     delete=False)
+    fp = tempfile.NamedTemporaryFile(
+        prefix='.%s-' % n, suffix='~', dir=d, delete=False
+    )
     try:
         yield fp
         fp.close()
@@ -276,19 +289,37 b' def editinplace(fname):'
         fp.close()
         tryunlink(fp.name)
 
+
 def main():
     ap = argparse.ArgumentParser()
-    ap.add_argument('--version', action='version',
-                    version='Byteify strings 1.0')
-    ap.add_argument('-i', '--inplace', action='store_true', default=False,
-                    help='edit files in place')
-    ap.add_argument('--dictiter', action='store_true', default=False,
-                    help='rewrite iteritems() and itervalues()'),
-    ap.add_argument('--allow-attr-methods', action='store_true',
+    ap.add_argument(
+        '--version', action='version', version='Byteify strings 1.0'
+    )
+    ap.add_argument(
+        '-i',
+        '--inplace',
+        action='store_true',
+        default=False,
+        help='edit files in place',
+    )
+    ap.add_argument(
+        '--dictiter',
+        action='store_true',
                     default=False,
-                    help='also handle attr*() when they are methods'),
-    ap.add_argument('--treat-as-kwargs', nargs="+", default=[],
-                    help="ignore kwargs-like objects"),
+        help='rewrite iteritems() and itervalues()',
+    ),
+    ap.add_argument(
+        '--allow-attr-methods',
+        action='store_true',
+        default=False,
+        help='also handle attr*() when they are methods',
+    ),
+    ap.add_argument(
+        '--treat-as-kwargs',
+        nargs="+",
+        default=[],
+        help="ignore kwargs-like objects",
+    ),
     ap.add_argument('files', metavar='FILE', nargs='+', help='source file')
     args = ap.parse_args()
     opts = {
@@ -306,6 +337,7 b' def main():'
                 fout = sys.stdout.buffer
                 process(fin, fout, opts)
 
+
 if __name__ == '__main__':
     if sys.version_info.major < 3:
         print('This script must be run under Python 3.')

contrib/casesmash.py

@@ -1,12 +1,12 b''
 from __future__ import absolute_import
 import __builtin__
 import os
-from mercurial import (
-    util,
-)
+from mercurial import util
+
 
 def lowerwrap(scope, funcname):
     f = getattr(scope, funcname)
+
     def wrap(fname, *args, **kwargs):
         d, base = os.path.split(fname)
         try:
@@ -19,11 +19,14 b' def lowerwrap(scope, funcname):'
             if fn.lower() == base.lower():
                 return f(os.path.join(d, fn), *args, **kwargs)
         return f(fname, *args, **kwargs)
+
     scope.__dict__[funcname] = wrap
 
+
 def normcase(path):
     return path.lower()
 
+
 os.path.normcase = normcase
 
 for f in 'file open'.split():

contrib/catapipe.py

@@ -53,15 +53,28 b' import timeit'
 # Python version and OS
 timer = timeit.default_timer
 
+
 def main():
     parser = argparse.ArgumentParser()
-    parser.add_argument('pipe', type=str, nargs=1,
-                        help='Path of named pipe to create and listen on.')
-    parser.add_argument('output', default='trace.json', type=str, nargs='?',
-                        help='Path of json file to create where the traces '
-                             'will be stored.')
-    parser.add_argument('--debug', default=False, action='store_true',
-                        help='Print useful debug messages')
+    parser.add_argument(
+        'pipe',
+        type=str,
+        nargs=1,
+        help='Path of named pipe to create and listen on.',
+    )
+    parser.add_argument(
+        'output',
+        default='trace.json',
+        type=str,
+        nargs='?',
+        help='Path of json file to create where the traces ' 'will be stored.',
+    )
+    parser.add_argument(
+        '--debug',
+        default=False,
+        action='store_true',
+        help='Print useful debug messages',
+    )
     args = parser.parse_args()
     fn = args.pipe[0]
     os.mkfifo(fn)
@@ -86,7 +99,8 b' def main():'
                     payload_args = {}
                 pid = _threadmap[session]
                 ts_micros = (now - start) * 1000000
-                out.write(json.dumps(
+                out.write(
+                    json.dumps(
                     {
                         "name": label,
                         "cat": "misc",
@@ -95,10 +109,13 b' def main():'
                         "pid": pid,
                         "tid": 1,
                         "args": payload_args,
-                    }))
+                        }
+                    )
+                )
                 out.write(',\n')
     finally:
         os.unlink(fn)
 
+
 if __name__ == '__main__':
     main()

contrib/check-code.py

@@ -26,11 +26,15 b' import optparse'
 import os
 import re
 import sys
+
 if sys.version_info[0] < 3:
     opentext = open
 else:
+
     def opentext(f):
         return open(f, encoding='latin1')
+
+
 try:
     xrange
 except NameError:
@@ -42,6 +46,7 b' except ImportError:'
 
 import testparseutil
 
+
 def compilere(pat, multiline=False):
     if multiline:
         pat = '(?m)' + pat
@@ -52,10 +57,22 b' def compilere(pat, multiline=False):'
             pass
     return re.compile(pat)
 
+
 # check "rules depending on implementation of repquote()" in each
 # patterns (especially pypats), before changing around repquote()
-_repquotefixedmap = {' ': ' ', '\n': '\n', '.': 'p', ':': 'q',
-                     '%': '%', '\\': 'b', '*': 'A', '+': 'P', '-': 'M'}
+_repquotefixedmap = {
+    ' ': ' ',
+    '\n': '\n',
+    '.': 'p',
+    ':': 'q',
+    '%': '%',
+    '\\': 'b',
+    '*': 'A',
+    '+': 'P',
+    '-': 'M',
+}
+
+
 def _repquoteencodechr(i):
     if i > 255:
         return 'u'
@@ -67,13 +84,17 b' def _repquoteencodechr(i):'
     if c.isdigit():
         return 'n'
     return 'o'
+
+
 _repquotett = ''.join(_repquoteencodechr(i) for i in xrange(256))
 
+
 def repquote(m):
     t = m.group('text')
     t = t.translate(_repquotett)
     return m.group('quote') + t + m.group('quote')
 
+
 def reppython(m):
     comment = m.group('comment')
     if comment:
@@ -81,20 +102,25 b' def reppython(m):'
         return "#" * l + comment[l:]
     return repquote(m)
 
+
 def repcomment(m):
     return m.group(1) + "#" * len(m.group(2))
 
+
 def repccomment(m):
     t = re.sub(r"((?<=\n) )|\S", "x", m.group(2))
     return m.group(1) + t + "*/"
 
+
 def repcallspaces(m):
     t = re.sub(r"\n\s+", "\n", m.group(2))
     return m.group(1) + t
 
+
 def repinclude(m):
     return m.group(1) + "<foo>"
 
+
 def rephere(m):
     t = re.sub(r"\S", "x", m.group(2))
     return m.group(1) + t
@@ -117,9 +143,14 b' testpats = ['
     (r'printf.*[^\\]\\([1-9]|0\d)', r"don't use 'printf \NNN', use Python"),
     (r'printf.*[^\\]\\x', "don't use printf \\x, use Python"),
     (r'rm -rf \*', "don't use naked rm -rf, target a directory"),
-    (r'\[[^\]]+==', '[ foo == bar ] is a bashism, use [ foo = bar ] instead'),
-    (r'(^|\|\s*)grep (-\w\s+)*[^|]*[(|]\w',
-     "use egrep for extended grep syntax"),
+        (
+            r'\[[^\]]+==',
+            '[ foo == bar ] is a bashism, use [ foo = bar ] instead',
+        ),
+        (
+            r'(^|\|\s*)grep (-\w\s+)*[^|]*[(|]\w',
+            "use egrep for extended grep syntax",
+        ),
     (r'(^|\|\s*)e?grep .*\\S', "don't use \\S in regular expression"),
     (r'(?<!!)/bin/', "don't use explicit paths for tools"),
     (r'#!.*/bash', "don't use bash in shebang, use sh"),
@@ -136,8 +167,10 b' testpats = ['
     (r'if\s*!', "don't use '!' to negate exit status"),
     (r'/dev/u?random', "don't use entropy, use /dev/zero"),
     (r'do\s*true;\s*done', "don't use true as loop body, use sleep 0"),
-    (r'sed (-e )?\'(\d+|/[^/]*/)i(?!\\\n)',
-     "put a backslash-escaped newline after sed 'i' command"),
+        (
+            r'sed (-e )?\'(\d+|/[^/]*/)i(?!\\\n)',
+            "put a backslash-escaped newline after sed 'i' command",
+        ),
     (r'^diff *-\w*[uU].*$\n(^  \$ |^$)', "prefix diff -u/-U with cmp"),
     (r'^\s+(if)? diff *-\w*[uU]', "prefix diff -u/-U with cmp"),
     (r'[\s="`\']python\s(?!bindings)', "don't use 'python', use '$PYTHON'"),
@@ -145,12 +178,17 b' testpats = ['
     (r'\butil\.Abort\b', "directly use error.Abort"),
     (r'\|&', "don't use |&, use 2>&1"),
     (r'\w =  +\w', "only one space after = allowed"),
-    (r'\bsed\b.*[^\\]\\n', "don't use 'sed ... \\n', use a \\ and a newline"),
+        (
+            r'\bsed\b.*[^\\]\\n',
+            "don't use 'sed ... \\n', use a \\ and a newline",
+        ),
     (r'env.*-u', "don't use 'env -u VAR', use 'unset VAR'"),
     (r'cp.* -r ', "don't use 'cp -r', use 'cp -R'"),
     (r'grep.* -[ABC]', "don't use grep's context flags"),
-    (r'find.*-printf',
-     "don't use 'find -printf', it doesn't exist on BSD find(1)"),
+        (
+            r'find.*-printf',
+            "don't use 'find -printf', it doesn't exist on BSD find(1)",
+        ),
     (r'\$RANDOM ', "don't use bash-only $RANDOM to generate random values"),
   ],
   # warnings
@@ -159,8 +197,8 b' testpats = ['
     (r'^diff.*-\w*N', "don't use 'diff -N'"),
     (r'\$PWD|\${PWD}', "don't use $PWD, use `pwd`"),
     (r'^([^"\'\n]|("[^"\n]*")|(\'[^\'\n]*\'))*\^', "^ must be quoted"),
-    (r'kill (`|\$\()', "don't use kill, use killdaemons.py")
-  ]
+        (r'kill (`|\$\()', "don't use kill, use killdaemons.py"),
+    ],
 ]
 
 testfilters = [
@@ -172,43 +210,70 b' uprefix = r"^ \\$ "'
 utestpats = [
   [
     (r'^(\S.*||  [$>] \S.*)[ \t]\n', "trailing whitespace on non-output"),
-    (uprefix + r'.*\|\s*sed[^|>\n]*\n',
-     "use regex test output patterns instead of sed"),
+        (
+            uprefix + r'.*\|\s*sed[^|>\n]*\n',
+            "use regex test output patterns instead of sed",
+        ),
     (uprefix + r'(true|exit 0)', "explicit zero exit unnecessary"),
     (uprefix + r'.*(?<!\[)\$\?', "explicit exit code checks unnecessary"),
-    (uprefix + r'.*\|\| echo.*(fail|error)',
-     "explicit exit code checks unnecessary"),
+        (
+            uprefix + r'.*\|\| echo.*(fail|error)',
+            "explicit exit code checks unnecessary",
+        ),
     (uprefix + r'set -e', "don't use set -e"),
     (uprefix + r'(\s|fi\b|done\b)', "use > for continued lines"),
-    (uprefix + r'.*:\.\S*/', "x:.y in a path does not work on msys, rewrite "
-     "as x://.y, or see `hg log -k msys` for alternatives", r'-\S+:\.|' #-Rxxx
-     '# no-msys'), # in test-pull.t which is skipped on windows
-    (r'^  [^$>].*27\.0\.0\.1',
-     'use $LOCALIP not an explicit loopback address'),
-    (r'^  (?![>$] ).*\$LOCALIP.*[^)]$',
-     'mark $LOCALIP output lines with (glob) to help tests in BSD jails'),
-    (r'^  (cat|find): .*: \$ENOENT\$',
-     'use test -f to test for file existence'),
-    (r'^  diff -[^ -]*p',
-     "don't use (external) diff with -p for portability"),
+        (
+            uprefix + r'.*:\.\S*/',
+            "x:.y in a path does not work on msys, rewrite "
+            "as x://.y, or see `hg log -k msys` for alternatives",
+            r'-\S+:\.|' '# no-msys',  # -Rxxx
+        ),  # in test-pull.t which is skipped on windows
+        (
+            r'^  [^$>].*27\.0\.0\.1',
+            'use $LOCALIP not an explicit loopback address',
+        ),
+        (
+            r'^  (?![>$] ).*\$LOCALIP.*[^)]$',
+            'mark $LOCALIP output lines with (glob) to help tests in BSD jails',
+        ),
+        (
+            r'^  (cat|find): .*: \$ENOENT\$',
+            'use test -f to test for file existence',
+        ),
+        (
+            r'^  diff -[^ -]*p',
+            "don't use (external) diff with -p for portability",
+        ),
     (r' readlink ', 'use readlink.py instead of readlink'),
-    (r'^  [-+][-+][-+] .* [-+]0000 \(glob\)',
-     "glob timezone field in diff output for portability"),
-    (r'^  @@ -[0-9]+ [+][0-9]+,[0-9]+ @@',
-     "use '@@ -N* +N,n @@ (glob)' style chunk header for portability"),
-    (r'^  @@ -[0-9]+,[0-9]+ [+][0-9]+ @@',
-     "use '@@ -N,n +N* @@ (glob)' style chunk header for portability"),
-    (r'^  @@ -[0-9]+ [+][0-9]+ @@',
-     "use '@@ -N* +N* @@ (glob)' style chunk header for portability"),
-    (uprefix + r'hg( +-[^ ]+( +[^ ]+)?)* +extdiff'
+        (
+            r'^  [-+][-+][-+] .* [-+]0000 \(glob\)',
+            "glob timezone field in diff output for portability",
+        ),
+        (
+            r'^  @@ -[0-9]+ [+][0-9]+,[0-9]+ @@',
+            "use '@@ -N* +N,n @@ (glob)' style chunk header for portability",
+        ),
+        (
+            r'^  @@ -[0-9]+,[0-9]+ [+][0-9]+ @@',
+            "use '@@ -N,n +N* @@ (glob)' style chunk header for portability",
+        ),
+        (
+            r'^  @@ -[0-9]+ [+][0-9]+ @@',
+            "use '@@ -N* +N* @@ (glob)' style chunk header for portability",
+        ),
+        (
+            uprefix + r'hg( +-[^ ]+( +[^ ]+)?)* +extdiff'
      r'( +(-[^ po-]+|--(?!program|option)[^ ]+|[^-][^ ]*))*$',
-     "use $RUNTESTDIR/pdiff via extdiff (or -o/-p for false-positives)"),
+            "use $RUNTESTDIR/pdiff via extdiff (or -o/-p for false-positives)",
+        ),
   ],
   # warnings
   [
-    (r'^  (?!.*\$LOCALIP)[^*?/\n]* \(glob\)$',
-     "glob match with no glob string (?, *, /, and $LOCALIP)"),
-  ]
+        (
+            r'^  (?!.*\$LOCALIP)[^*?/\n]* \(glob\)$',
+            "glob match with no glob string (?, *, /, and $LOCALIP)",
+        ),
+    ],
 ]
 
 # transform plain test rules to unified test's
@@ -236,14 +301,21 b' utestfilters = ['
 commonpypats = [
   [
     (r'\\$', 'Use () to wrap long lines in Python, not \\'),
-    (r'^\s*def\s*\w+\s*\(.*,\s*\(',
-     "tuple parameter unpacking not available in Python 3+"),
-    (r'lambda\s*\(.*,.*\)',
-     "tuple parameter unpacking not available in Python 3+"),
+        (
+            r'^\s*def\s*\w+\s*\(.*,\s*\(',
+            "tuple parameter unpacking not available in Python 3+",
+        ),
+        (
+            r'lambda\s*\(.*,.*\)',
+            "tuple parameter unpacking not available in Python 3+",
+        ),
     (r'(?<!def)\s+(cmp)\(', "cmp is not available in Python 3+"),
     (r'(?<!\.)\breduce\s*\(.*', "reduce is not available in Python 3+"),
-    (r'\bdict\(.*=', 'dict() is different in Py2 and 3 and is slower than {}',
-     'dict-from-generator'),
+        (
+            r'\bdict\(.*=',
+            'dict() is different in Py2 and 3 and is slower than {}',
+            'dict-from-generator',
+        ),
     (r'\.has_key\b', "dict.has_key is not available in Python 3+"),
     (r'\s<>\s', '<> operator is not available in Python 3+, use !='),
     (r'^\s*\t', "don't use tabs"),
@@ -253,7 +325,8 b' commonpypats = ['
     (r'(\w|\)),\w', "missing whitespace after ,"),
     (r'(\w|\))[+/*\-<>]\w', "missing whitespace in expression"),
     (r'\w\s=\s\s+\w', "gratuitous whitespace after ="),
-    ((
+        (
+            (
         # a line ending with a colon, potentially with trailing comments
         r':([ \t]*#[^\n]*)?\n'
         # one that is not a pass and not only a comment
@@ -262,93 +335,142 b' commonpypats = ['
         r'((?P=indent)[^\n]+\n)*'
         # a pass at the same indent level, which is bogus
         r'(?P=indent)pass[ \t\n#]'
-      ), 'omit superfluous pass'),
+            ),
+            'omit superfluous pass',
+        ),
     (r'[^\n]\Z', "no trailing newline"),
     (r'(\S[ \t]+|^[ \t]+)\n', "trailing whitespace"),
 #    (r'^\s+[^_ \n][^_. \n]+_[^_\n]+\s*=',
 #     "don't use underbars in identifiers"),
-    (r'^\s+(self\.)?[A-Za-z][a-z0-9]+[A-Z]\w* = ',
-     "don't use camelcase in identifiers", r'#.*camelcase-required'),
-    (r'^\s*(if|while|def|class|except|try)\s[^[\n]*:\s*[^\\n]#\s]+',
-     "linebreak after :"),
-    (r'class\s[^( \n]+:', "old-style class, use class foo(object)",
-     r'#.*old-style'),
-    (r'class\s[^( \n]+\(\):',
+        (
+            r'^\s+(self\.)?[A-Za-z][a-z0-9]+[A-Z]\w* = ',
+            "don't use camelcase in identifiers",
+            r'#.*camelcase-required',
+        ),
+        (
+            r'^\s*(if|while|def|class|except|try)\s[^[\n]*:\s*[^\\n]#\s]+',
+            "linebreak after :",
+        ),
+        (
+            r'class\s[^( \n]+:',
+            "old-style class, use class foo(object)",
+            r'#.*old-style',
+        ),
+        (
+            r'class\s[^( \n]+\(\):',
      "class foo() creates old style object, use class foo(object)",
-     r'#.*old-style'),
-    (r'\b(%s)\(' % '|'.join(k for k in keyword.kwlist
-                            if k not in ('print', 'exec')),
-     "Python keyword is not a function"),
+            r'#.*old-style',
+        ),
+        (
+            r'\b(%s)\('
+            % '|'.join(k for k in keyword.kwlist if k not in ('print', 'exec')),
+            "Python keyword is not a function",
+        ),
 #    (r'class\s[A-Z][^\(]*\((?!Exception)',
 #     "don't capitalize non-exception classes"),
 #    (r'in range\(', "use xrange"),
 #    (r'^\s*print\s+', "avoid using print in core and extensions"),
     (r'[\x80-\xff]', "non-ASCII character literal"),
     (r'("\')\.format\(', "str.format() has no bytes counterpart, use %"),
-    (r'([\(\[][ \t]\S)|(\S[ \t][\)\]])', "gratuitous whitespace in () or []"),
+        (
+            r'([\(\[][ \t]\S)|(\S[ \t][\)\]])',
+            "gratuitous whitespace in () or []",
+        ),
 #    (r'\s\s=', "gratuitous whitespace before ="),
-    (r'[^>< ](\+=|-=|!=|<>|<=|>=|<<=|>>=|%=)\S',
-     "missing whitespace around operator"),
-    (r'[^>< ](\+=|-=|!=|<>|<=|>=|<<=|>>=|%=)\s',
-     "missing whitespace around operator"),
-    (r'\s(\+=|-=|!=|<>|<=|>=|<<=|>>=|%=)\S',
-     "missing whitespace around operator"),
-    (r'[^^+=*/!<>&| %-](\s=|=\s)[^= ]',
-     "wrong whitespace around ="),
-    (r'\([^()]*( =[^=]|[^<>!=]= )',
-     "no whitespace around = for named parameters"),
-    (r'raise [^,(]+, (\([^\)]+\)|[^,\(\)]+)$',
-     "don't use old-style two-argument raise, use Exception(message)"),
+        (
+            r'[^>< ](\+=|-=|!=|<>|<=|>=|<<=|>>=|%=)\S',
+            "missing whitespace around operator",
+        ),
+        (
+            r'[^>< ](\+=|-=|!=|<>|<=|>=|<<=|>>=|%=)\s',
+            "missing whitespace around operator",
+        ),
+        (
+            r'\s(\+=|-=|!=|<>|<=|>=|<<=|>>=|%=)\S',
+            "missing whitespace around operator",
+        ),
+        (r'[^^+=*/!<>&| %-](\s=|=\s)[^= ]', "wrong whitespace around ="),
+        (
+            r'\([^()]*( =[^=]|[^<>!=]= )',
+            "no whitespace around = for named parameters",
+        ),
+        (
+            r'raise [^,(]+, (\([^\)]+\)|[^,\(\)]+)$',
+            "don't use old-style two-argument raise, use Exception(message)",
+        ),
     (r' is\s+(not\s+)?["\'0-9-]', "object comparison with literal"),
-    (r' [=!]=\s+(True|False|None)',
-     "comparison with singleton, use 'is' or 'is not' instead"),
-    (r'^\s*(while|if) [01]:',
-     "use True/False for constant Boolean expression"),
+        (
+            r' [=!]=\s+(True|False|None)',
+            "comparison with singleton, use 'is' or 'is not' instead",
+        ),
+        (
+            r'^\s*(while|if) [01]:',
+            "use True/False for constant Boolean expression",
+        ),
     (r'^\s*if False(:| +and)', 'Remove code instead of using `if False`'),
-    (r'(?:(?<!def)\s+|\()hasattr\(',
+        (
+            r'(?:(?<!def)\s+|\()hasattr\(',
      'hasattr(foo, bar) is broken on py2, use util.safehasattr(foo, bar) '
-     'instead', r'#.*hasattr-py3-only'),
-    (r'opener\([^)]*\).read\(',
-     "use opener.read() instead"),
-    (r'opener\([^)]*\).write\(',
-     "use opener.write() instead"),
+            'instead',
+            r'#.*hasattr-py3-only',
+        ),
+        (r'opener\([^)]*\).read\(', "use opener.read() instead"),
+        (r'opener\([^)]*\).write\(', "use opener.write() instead"),
     (r'(?i)descend[e]nt', "the proper spelling is descendAnt"),
     (r'\.debug\(\_', "don't mark debug messages for translation"),
     (r'\.strip\(\)\.split\(\)', "no need to strip before splitting"),
     (r'^\s*except\s*:', "naked except clause", r'#.*re-raises'),
-    (r'^\s*except\s([^\(,]+|\([^\)]+\))\s*,',
-     'legacy exception syntax; use "as" instead of ","'),
+        (
+            r'^\s*except\s([^\(,]+|\([^\)]+\))\s*,',
+            'legacy exception syntax; use "as" instead of ","',
+        ),
     (r'release\(.*wlock, .*lock\)', "wrong lock release order"),
     (r'\bdef\s+__bool__\b', "__bool__ should be __nonzero__ in Python 2"),
-    (r'os\.path\.join\(.*, *(""|\'\')\)',
-     "use pathutil.normasprefix(path) instead of os.path.join(path, '')"),
+        (
+            r'os\.path\.join\(.*, *(""|\'\')\)',
+            "use pathutil.normasprefix(path) instead of os.path.join(path, '')",
+        ),
     (r'\s0[0-7]+\b', 'legacy octal syntax; use "0o" prefix instead of "0"'),
     # XXX only catch mutable arguments on the first line of the definition
     (r'def.*[( ]\w+=\{\}', "don't use mutable default arguments"),
     (r'\butil\.Abort\b', "directly use error.Abort"),
-    (r'^@(\w*\.)?cachefunc', "module-level @cachefunc is risky, please avoid"),
-    (r'^import Queue', "don't use Queue, use pycompat.queue.Queue + "
-                       "pycompat.queue.Empty"),
-    (r'^import cStringIO', "don't use cStringIO.StringIO, use util.stringio"),
+        (
+            r'^@(\w*\.)?cachefunc',
+            "module-level @cachefunc is risky, please avoid",
+        ),
+        (
+            r'^import Queue',
+            "don't use Queue, use pycompat.queue.Queue + "
+            "pycompat.queue.Empty",
+        ),
+        (
+            r'^import cStringIO',
+            "don't use cStringIO.StringIO, use util.stringio",
+        ),
     (r'^import urllib', "don't use urllib, use util.urlreq/util.urlerr"),
-    (r'^import SocketServer', "don't use SockerServer, use util.socketserver"),
+        (
+            r'^import SocketServer',
+            "don't use SockerServer, use util.socketserver",
+        ),
     (r'^import urlparse', "don't use urlparse, use util.urlreq"),
     (r'^import xmlrpclib', "don't use xmlrpclib, use util.xmlrpclib"),
     (r'^import cPickle', "don't use cPickle, use util.pickle"),
     (r'^import pickle', "don't use pickle, use util.pickle"),
     (r'^import httplib', "don't use httplib, use util.httplib"),
     (r'^import BaseHTTPServer', "use util.httpserver instead"),
-    (r'^(from|import) mercurial\.(cext|pure|cffi)',
-     "use mercurial.policy.importmod instead"),
+        (
+            r'^(from|import) mercurial\.(cext|pure|cffi)',
+            "use mercurial.policy.importmod instead",
+        ),
     (r'\.next\(\)', "don't use .next(), use next(...)"),
-    (r'([a-z]*).revision\(\1\.node\(',
-     "don't convert rev to node before passing to revision(nodeorrev)"),
+        (
+            r'([a-z]*).revision\(\1\.node\(',
+            "don't convert rev to node before passing to revision(nodeorrev)",
+        ),
     (r'platform\.system\(\)', "don't use platform.system(), use pycompat"),
-
   ],
   # warnings
-  [
-  ]
+    [],
 ]
 
 # patterns to check normal *.py files
@@ -361,21 +483,28 b' pypats = ['
     # scripts for these patterns requires many changes, and has less
     # profit than effort.
     (r'raise Exception', "don't raise generic exceptions"),
-    (r'[\s\(](open|file)\([^)]*\)\.read\(',
-     "use util.readfile() instead"),
-    (r'[\s\(](open|file)\([^)]*\)\.write\(',
-     "use util.writefile() instead"),
-    (r'^[\s\(]*(open(er)?|file)\([^)]*\)(?!\.close\(\))',
-     "always assign an opened file to a variable, and close it afterwards"),
-    (r'[\s\(](open|file)\([^)]*\)\.(?!close\(\))',
-     "always assign an opened file to a variable, and close it afterwards"),
+        (r'[\s\(](open|file)\([^)]*\)\.read\(', "use util.readfile() instead"),
+        (
+            r'[\s\(](open|file)\([^)]*\)\.write\(',
+            "use util.writefile() instead",
+        ),
+        (
+            r'^[\s\(]*(open(er)?|file)\([^)]*\)(?!\.close\(\))',
+            "always assign an opened file to a variable, and close it afterwards",
+        ),
+        (
+            r'[\s\(](open|file)\([^)]*\)\.(?!close\(\))',
+            "always assign an opened file to a variable, and close it afterwards",
+        ),
     (r':\n(    )*( ){1,3}[^ ]', "must indent 4 spaces"),
     (r'^import atexit', "don't use atexit, use ui.atexit"),
-
     # rules depending on implementation of repquote()
-    (r' x+[xpqo%APM][\'"]\n\s+[\'"]x',
-     'string join across lines with no space'),
-    (r'''(?x)ui\.(status|progress|write|note|warn)\(
+        (
+            r' x+[xpqo%APM][\'"]\n\s+[\'"]x',
+            'string join across lines with no space',
+        ),
+        (
+            r'''(?x)ui\.(status|progress|write|note|warn)\(
          [ \t\n#]*
          (?# any strings/comments might precede a string, which
            # contains translatable message)
@@ -389,51 +518,55 b' pypats = ['
          (?# this regexp can't use [^...] style,
            # because _preparepats forcibly adds "\n" into [^...],
            # even though this regexp wants match it against "\n")''',
-     "missing _() in ui message (use () to hide false-positives)"),
-  ] + commonpypats[0],
+            "missing _() in ui message (use () to hide false-positives)",
+        ),
+    ]
+    + commonpypats[0],
   # warnings
   [
     # rules depending on implementation of repquote()
     (r'(^| )pp +xxxxqq[ \n][^\n]', "add two newlines after '.. note::'"),
-  ] + commonpypats[1]
+    ]
+    + commonpypats[1],
 ]
 
 # patterns to check *.py for embedded ones in test script
 embeddedpypats = [
-  [
-  ] + commonpypats[0],
+    [] + commonpypats[0],
   # warnings
-  [
-  ] + commonpypats[1]
+    [] + commonpypats[1],
 ]
 
 # common filters to convert *.py
 commonpyfilters = [
-    (r"""(?msx)(?P<comment>\#.*?$)|
+    (
+        r"""(?msx)(?P<comment>\#.*?$)|
          ((?P<quote>('''|\"\"\"|(?<!')'(?!')|(?<!")"(?!")))
           (?P<text>(([^\\]|\\.)*?))
-          (?P=quote))""", reppython),
+          (?P=quote))""",
+        reppython,
+    ),
 ]
 
 # filters to convert normal *.py files
-pyfilters = [
-] + commonpyfilters
+pyfilters = [] + commonpyfilters
 
 # non-filter patterns
 pynfpats = [
     [
     (r'pycompat\.osname\s*[=!]=\s*[\'"]nt[\'"]', "use pycompat.iswindows"),
     (r'pycompat\.osname\s*[=!]=\s*[\'"]posix[\'"]', "use pycompat.isposix"),
-    (r'pycompat\.sysplatform\s*[!=]=\s*[\'"]darwin[\'"]',
-     "use pycompat.isdarwin"),
+        (
+            r'pycompat\.sysplatform\s*[!=]=\s*[\'"]darwin[\'"]',
+            "use pycompat.isdarwin",
+        ),
     ],
     # warnings
     [],
 ]
 
 # filters to convert *.py for embedded ones in test script
-embeddedpyfilters = [
-] + commonpyfilters
+embeddedpyfilters = [] + commonpyfilters
 
 # extension non-filter patterns
 pyextnfpats = [
@@ -447,9 +580,9 b' txtfilters = []'
 txtpats = [
   [
     (r'\s$', 'trailing whitespace'),
-    ('.. note::[ \n][^\n]', 'add two newlines after note::')
+        ('.. note::[ \n][^\n]', 'add two newlines after note::'),
   ],
-  []
+    [],
 ]
 
 cpats = [
@@ -473,13 +606,12 b' cpats = ['
     (r'^\s*#import\b', "use only #include in standard C code"),
     (r'strcpy\(', "don't use strcpy, use strlcpy or memcpy"),
     (r'strcat\(', "don't use strcat"),
-
     # rules depending on implementation of repquote()
   ],
   # warnings
   [
     # rules depending on implementation of repquote()
-  ]
+    ],
 ]
 
 cfilters = [
@@ -490,19 +622,15 b' cfilters = ['
 ]
 
 inutilpats = [
-  [
-    (r'\bui\.', "don't use ui in util"),
-  ],
+    [(r'\bui\.', "don't use ui in util"),],
   # warnings
-  []
+    [],
 ]
 
 inrevlogpats = [
-  [
-    (r'\brepo\.', "don't use repo in revlog"),
-  ],
+    [(r'\brepo\.', "don't use repo in revlog"),],
   # warnings
-  []
+    [],
 ]
 
 webtemplatefilters = []
@@ -510,21 +638,29 b' webtemplatefilters = []'
 webtemplatepats = [
   [],
   [
-    (r'{desc(\|(?!websub|firstline)[^\|]*)+}',
-     'follow desc keyword with either firstline or websub'),
-  ]
+        (
+            r'{desc(\|(?!websub|firstline)[^\|]*)+}',
+            'follow desc keyword with either firstline or websub',
+        ),
+    ],
 ]
 
 allfilesfilters = []
 
 allfilespats = [
   [
-    (r'(http|https)://[a-zA-Z0-9./]*selenic.com/',
-     'use mercurial-scm.org domain URL'),
-    (r'mercurial@selenic\.com',
-     'use mercurial-scm.org domain for mercurial ML address'),
-    (r'mercurial-devel@selenic\.com',
-     'use mercurial-scm.org domain for mercurial-devel ML address'),
+        (
+            r'(http|https)://[a-zA-Z0-9./]*selenic.com/',
+            'use mercurial-scm.org domain URL',
+        ),
+        (
+            r'mercurial@selenic\.com',
+            'use mercurial-scm.org domain for mercurial ML address',
+        ),
+        (
+            r'mercurial-devel@selenic\.com',
+            'use mercurial-scm.org domain for mercurial-devel ML address',
+        ),
   ],
   # warnings
   [],
@@ -532,7 +668,11 b' allfilespats = ['
 
 py3pats = [
   [
-    (r'os\.environ', "use encoding.environ instead (py3)", r'#.*re-exports'),
+        (
+            r'os\.environ',
+            "use encoding.environ instead (py3)",
+            r'#.*re-exports',
+        ),
     (r'os\.name', "use pycompat.osname instead (py3)"),
     (r'os\.getcwd', "use encoding.getcwd instead (py3)", r'#.*re-exports'),
     (r'os\.sep', "use pycompat.ossep instead (py3)"),
@@ -552,20 +692,39 b' checks = ['
     ('python', r'.*\.(py|cgi)$', r'^#!.*python', pyfilters, pypats),
     ('python', r'.*\.(py|cgi)$', r'^#!.*python', [], pynfpats),
     ('python', r'.*hgext.*\.py$', '', [], pyextnfpats),
-    ('python 3', r'.*(hgext|mercurial)/(?!demandimport|policy|pycompat).*\.py',
-     '', pyfilters, py3pats),
+    (
+        'python 3',
+        r'.*(hgext|mercurial)/(?!demandimport|policy|pycompat).*\.py',
+        '',
+        pyfilters,
+        py3pats,
+    ),
     ('test script', r'(.*/)?test-[^.~]*$', '', testfilters, testpats),
     ('c', r'.*\.[ch]$', '', cfilters, cpats),
     ('unified test', r'.*\.t$', '', utestfilters, utestpats),
-    ('layering violation repo in revlog', r'mercurial/revlog\.py', '',
-     pyfilters, inrevlogpats),
-    ('layering violation ui in util', r'mercurial/util\.py', '', pyfilters,
-     inutilpats),
+    (
+        'layering violation repo in revlog',
+        r'mercurial/revlog\.py',
+        '',
+        pyfilters,
+        inrevlogpats,
+    ),
+    (
+        'layering violation ui in util',
+        r'mercurial/util\.py',
+        '',
+        pyfilters,
+        inutilpats,
+    ),
     ('txt', r'.*\.txt$', '', txtfilters, txtpats),
-    ('web template', r'mercurial/templates/.*\.tmpl', '',
-     webtemplatefilters, webtemplatepats),
-    ('all except for .po', r'.*(?<!\.po)$', '',
-     allfilesfilters, allfilespats),
+    (
+        'web template',
+        r'mercurial/templates/.*\.tmpl',
+        '',
+        webtemplatefilters,
+        webtemplatepats,
+    ),
+    ('all except for .po', r'.*(?<!\.po)$', '', allfilesfilters, allfilespats),
 ]
 
 # (desc,
@@ -573,10 +732,15 b' checks = ['
 #  list of patterns to convert target files
 #  list of patterns to detect errors/warnings)
 embeddedchecks = [
-    ('embedded python',
-     testparseutil.pyembedded, embeddedpyfilters, embeddedpypats)
+    (
+        'embedded python',
+        testparseutil.pyembedded,
+        embeddedpyfilters,
+        embeddedpypats,
+    )
 ]
 
+
 def _preparepats():
     def preparefailandwarn(failandwarn):
         for pats in failandwarn:
@@ -605,6 +769,7 b' def _preparepats():'
             filters = c[-2]
             preparefilters(filters)
 
+
 class norepeatlogger(object):
     def __init__(self):
         self._lastseen = None
@@ -630,8 +795,10 b' class norepeatlogger(object):'
             self._lastseen = msgid
         print(" " + msg)
 
+
 _defaultlogger = norepeatlogger()
 
+
 def getblame(f):
     lines = []
     for l in os.popen('hg annotate -un %s' % f):
@@ -640,8 +807,16 b' def getblame(f):'
         lines.append((line[1:-1], user, rev))
     return lines
 
-def checkfile(f, logfunc=_defaultlogger.log, maxerr=None, warnings=False,
-              blame=False, debug=False, lineno=True):
+
+def checkfile(
+    f,
+    logfunc=_defaultlogger.log,
+    maxerr=None,
+    warnings=False,
+    blame=False,
+    debug=False,
+    lineno=True,
+):
     """checks style and portability of a given file
 
     :f: filepath
@@ -673,8 +848,9 b' def checkfile(f, logfunc=_defaultlogger.'
             print(name, f)
         if not (re.match(match, f) or (magic and re.search(magic, pre))):
             if debug:
-                print("Skipping %s for %s it doesn't match %s" % (
-                       name, match, f))
+                print(
+                    "Skipping %s for %s it doesn't match %s" % (name, match, f)
+                )
             continue
         if "no-" "check-code" in pre:
             # If you're looking at this line, it's because a file has:
@@ -686,14 +862,26 b' def checkfile(f, logfunc=_defaultlogger.'
             print("Skipping %s it has no-che?k-code (glob)" % f)
             return "Skip" # skip checking this file
 
-        fc = _checkfiledata(name, f, pre, filters, pats, context,
-                            logfunc, maxerr, warnings, blame, debug, lineno)
+        fc = _checkfiledata(
+            name,
+            f,
+            pre,
+            filters,
+            pats,
+            context,
+            logfunc,
+            maxerr,
+            warnings,
+            blame,
+            debug,
+            lineno,
+        )
         if fc:
             result = False
 
     if f.endswith('.t') and "no-" "check-code" not in pre:
         if debug:
-            print("Checking embedded code in %s" % (f))
+            print("Checking embedded code in %s" % f)
 
         prelines = pre.splitlines()
         embeddederros = []
@@ -705,9 +893,21 b' def checkfile(f, logfunc=_defaultlogger.'
 
             for found in embedded(f, prelines, embeddederros):
                 filename, starts, ends, code = found
-                fc = _checkfiledata(name, f, code, filters, pats, context,
-                                    logfunc, curmaxerr, warnings, blame, debug,
-                                    lineno, offset=starts - 1)
+                fc = _checkfiledata(
+                    name,
+                    f,
+                    code,
+                    filters,
+                    pats,
+                    context,
+                    logfunc,
+                    curmaxerr,
+                    warnings,
+                    blame,
+                    debug,
+                    lineno,
+                    offset=starts - 1,
+                )
                 if fc:
                     result = False
                     if curmaxerr:
@@ -717,9 +917,22 b' def checkfile(f, logfunc=_defaultlogger.'
 
     return result
 
-def _checkfiledata(name, f, filedata, filters, pats, context,
-                   logfunc, maxerr, warnings, blame, debug, lineno,
-                   offset=None):
+
+def _checkfiledata(
+    name,
+    f,
+    filedata,
+    filters,
+    pats,
+    context,
+    logfunc,
+    maxerr,
+    warnings,
+    blame,
+    debug,
+    lineno,
+    offset=None,
+):
     """Execute actual error check for file data
 
     :name: of the checking category
@@ -794,8 +1007,10 b' def _checkfiledata(name, f, filedata, fi'
 
                 if ignore and re.search(ignore, l, re.MULTILINE):
                     if debug:
-                        print("Skipping %s for %s:%s (ignore pattern)" % (
-                            name, f, (n + lineoffset)))
+                        print(
+                            "Skipping %s for %s:%s (ignore pattern)"
+                            % (name, f, (n + lineoffset))
+                        )
                     continue
                 bd = ""
                 if blame:
@@ -830,21 +1045,38 b' def _checkfiledata(name, f, filedata, fi'
 
     return fc
 
+
 def main():
     parser = optparse.OptionParser("%prog [options] [files | -]")
-    parser.add_option("-w", "--warnings", action="store_true",
-                      help="include warning-level checks")
-    parser.add_option("-p", "--per-file", type="int",
-                      help="max warnings per file")
-    parser.add_option("-b", "--blame", action="store_true",
-                      help="use annotate to generate blame info")
-    parser.add_option("", "--debug", action="store_true",
-                      help="show debug information")
-    parser.add_option("", "--nolineno", action="store_false",
-                      dest='lineno', help="don't show line numbers")
+    parser.add_option(
+        "-w",
+        "--warnings",
+        action="store_true",
+        help="include warning-level checks",
+    )
+    parser.add_option(
+        "-p", "--per-file", type="int", help="max warnings per file"
+    )
+    parser.add_option(
+        "-b",
+        "--blame",
+        action="store_true",
+        help="use annotate to generate blame info",
+    )
+    parser.add_option(
+        "", "--debug", action="store_true", help="show debug information"
+    )
+    parser.add_option(
+        "",
+        "--nolineno",
+        action="store_false",
+        dest='lineno',
+        help="don't show line numbers",
+    )
 
-    parser.set_defaults(per_file=15, warnings=False, blame=False, debug=False,
-                        lineno=True)
+    parser.set_defaults(
+        per_file=15, warnings=False, blame=False, debug=False, lineno=True
+    )
     (options, args) = parser.parse_args()
 
     if len(args) == 0:
@@ -859,11 +1091,17 b' def main():'
 
     ret = 0
     for f in check:
-        if not checkfile(f, maxerr=options.per_file, warnings=options.warnings,
-                         blame=options.blame, debug=options.debug,
-                         lineno=options.lineno):
+        if not checkfile(
+            f,
+            maxerr=options.per_file,
+            warnings=options.warnings,
+            blame=options.blame,
+            debug=options.debug,
+            lineno=options.lineno,
+        ):
             ret = 1
     return ret
 
+
 if __name__ == "__main__":
     sys.exit(main())

contrib/check-config.py

@@ -15,7 +15,8 b' foundopts = {}'
 documented = {}
 allowinconsistent = set()
 
-configre = re.compile(br'''
+configre = re.compile(
+    br'''
     # Function call
     ui\.config(?P<ctype>|int|bool|list)\(
         # First argument.
@@ -23,9 +24,12 b" configre = re.compile(br'''"
         # Second argument
         ['"](?P<option>\S+)['"](,\s+
         (?:default=)?(?P<default>\S+?))?
-    \)''', re.VERBOSE | re.MULTILINE)
+    \)''',
+    re.VERBOSE | re.MULTILINE,
+)
 
-configwithre = re.compile(br'''
+configwithre = re.compile(
+    br'''
     ui\.config(?P<ctype>with)\(
         # First argument is callback function. This doesn't parse robustly
         # if it is e.g. a function call.
@@ -33,23 +37,32 b" configwithre = re.compile(br'''"
         ['"](?P<section>\S+)['"],\s*
         ['"](?P<option>\S+)['"](,\s+
         (?:default=)?(?P<default>\S+?))?
-    \)''', re.VERBOSE | re.MULTILINE)
+    \)''',
+    re.VERBOSE | re.MULTILINE,
+)
 
-configpartialre = (br"""ui\.config""")
+configpartialre = br"""ui\.config"""
 
-ignorere = re.compile(br'''
+ignorere = re.compile(
+    br'''
     \#\s(?P<reason>internal|experimental|deprecated|developer|inconsistent)\s
     config:\s(?P<config>\S+\.\S+)$
-    ''', re.VERBOSE | re.MULTILINE)
+    ''',
+    re.VERBOSE | re.MULTILINE,
+)
 
 if sys.version_info[0] > 2:
+
     def mkstr(b):
         if isinstance(b, str):
             return b
         return b.decode('utf8')
+
+
 else:
     mkstr = lambda x: x
 
+
 def main(args):
     for f in args:
         sect = b''
@@ -115,18 +128,32 b' def main(args):'
                 name = m.group('section') + b"." + m.group('option')
                 default = m.group('default')
                 if default in (
-                        None, b'False', b'None', b'0', b'[]', b'""', b"''"):
+                    None,
+                    b'False',
+                    b'None',
+                    b'0',
+                    b'[]',
+                    b'""',
+                    b"''",
+                ):
                     default = b''
                 if re.match(b'[a-z.]+$', default):
                     default = b'<variable>'
-                if (name in foundopts and (ctype, default) != foundopts[name]
-                    and name not in allowinconsistent):
+                if (
+                    name in foundopts
+                    and (ctype, default) != foundopts[name]
+                    and name not in allowinconsistent
+                ):
                     print(mkstr(l.rstrip()))
                     fctype, fdefault = foundopts[name]
-                    print("conflict on %s: %r != %r" % (
+                    print(
+                        "conflict on %s: %r != %r"
+                        % (
                         mkstr(name),
                         (mkstr(ctype), mkstr(default)),
-                        (mkstr(fctype), mkstr(fdefault))))
+                            (mkstr(fctype), mkstr(fdefault)),
+                        )
+                    )
                     print("at %s:%d:" % (mkstr(f), linenum))
                 foundopts[name] = (ctype, default)
                 carryover = b''
@@ -139,9 +166,11 b' def main(args):'
 
     for name in sorted(foundopts):
         if name not in documented:
-            if not (name.startswith(b"devel.") or
-                    name.startswith(b"experimental.") or
-                    name.startswith(b"debug.")):
+            if not (
+                name.startswith(b"devel.")
+                or name.startswith(b"experimental.")
+                or name.startswith(b"debug.")
+            ):
                 ctype, default = foundopts[name]
                 if default:
                     if isinstance(default, bytes):
@@ -149,8 +178,11 b' def main(args):'
                     default = ' [%s]' % default
                 elif isinstance(default, bytes):
                     default = mkstr(default)
-                print("undocumented: %s (%s)%s" % (
-                    mkstr(name), mkstr(ctype), default))
+                print(
+                    "undocumented: %s (%s)%s"
+                    % (mkstr(name), mkstr(ctype), default)
+                )
+
 
 if __name__ == "__main__":
     if len(sys.argv) > 1:

contrib/check-py3-compat.py

@@ -16,6 +16,7 b' import sys'
 import traceback
 import warnings
 
+
 def check_compat_py2(f):
     """Check Python 3 compatibility for a file with Python 2"""
     with open(f, 'rb') as fh:
@@ -40,6 +41,7 b' def check_compat_py2(f):'
     if haveprint and 'print_function' not in futures:
         print('%s requires print_function' % f)
 
+
 def check_compat_py3(f):
     """Check Python 3 compatibility of a file with Python 3."""
     with open(f, 'rb') as fh:
@@ -54,8 +56,9 b' def check_compat_py3(f):'
     # Try to import the module.
     # For now we only support modules in packages because figuring out module
     # paths for things not in a package can be confusing.
-    if (f.startswith(('hgdemandimport/', 'hgext/', 'mercurial/'))
-        and not f.endswith('__init__.py')):
+    if f.startswith(
+        ('hgdemandimport/', 'hgext/', 'mercurial/')
+    ) and not f.endswith('__init__.py'):
         assert f.endswith('.py')
         name = f.replace('/', '.')[:-3]
         try:
@@ -79,11 +82,16 b' def check_compat_py3(f):'
 
             if frame.filename:
                 filename = os.path.basename(frame.filename)
-                print('%s: error importing: <%s> %s (error at %s:%d)' % (
-                      f, type(e).__name__, e, filename, frame.lineno))
+                print(
+                    '%s: error importing: <%s> %s (error at %s:%d)'
+                    % (f, type(e).__name__, e, filename, frame.lineno)
+                )
             else:
-                print('%s: error importing module: <%s> %s (line %d)' % (
-                      f, type(e).__name__, e, frame.lineno))
+                print(
+                    '%s: error importing module: <%s> %s (line %d)'
+                    % (f, type(e).__name__, e, frame.lineno)
+                )
+
 
 if __name__ == '__main__':
     if sys.version_info[0] == 2:
@@ -96,7 +104,10 b" if __name__ == '__main__':"
             fn(f)
 
         for w in warns:
-            print(warnings.formatwarning(w.message, w.category,
-                                         w.filename, w.lineno).rstrip())
+            print(
+                warnings.formatwarning(
+                    w.message, w.category, w.filename, w.lineno
+                ).rstrip()
+            )
 
     sys.exit(0)

contrib/debugcmdserver.py

@@ -23,6 +23,7 b" if sys.argv[1] == '-':"
 else:
     log = open(sys.argv[1], 'a')
 
+
 def read(size):
     data = sys.stdin.read(size)
     if not data:
@@ -31,6 +32,7 b' def read(size):'
     sys.stdout.flush()
     return data
 
+
 try:
     while True:
         header = read(outputfmtsize)

contrib/debugshell.py

@@ -14,6 +14,7 b' from mercurial import ('
 cmdtable = {}
 command = registrar.command(cmdtable)
 
+
 def pdb(ui, repo, msg, **opts):
     objects = {
         'mercurial': mercurial,
@@ -24,6 +25,7 b' def pdb(ui, repo, msg, **opts):'
 
     code.interact(msg, local=objects)
 
+
 def ipdb(ui, repo, msg, **opts):
     import IPython
 
@@ -33,16 +35,15 b' def ipdb(ui, repo, msg, **opts):'
 
     IPython.embed()
 
+
 @command(b'debugshell|dbsh', [])
 def debugshell(ui, repo, **opts):
-    bannermsg = ("loaded repo : %s\n"
-                 "using source: %s" % (pycompat.sysstr(repo.root),
-                                       mercurial.__path__[0]))
+    bannermsg = "loaded repo : %s\n" "using source: %s" % (
+        pycompat.sysstr(repo.root),
+        mercurial.__path__[0],
+    )
 
-    pdbmap = {
-        'pdb'  : 'code',
-        'ipdb' : 'IPython'
-    }
+    pdbmap = {'pdb': 'code', 'ipdb': 'IPython'}
 
     debugger = ui.config(b"ui", b"debugger")
     if not debugger:
@@ -55,8 +56,10 b' def debugshell(ui, repo, **opts):'
         with demandimport.deactivated():
             __import__(pdbmap[debugger])
     except ImportError:
-        ui.warn((b"%s debugger specified but %s module was not found\n")
-                % (debugger, pdbmap[debugger]))
+        ui.warn(
+            b"%s debugger specified but %s module was not found\n"
+            % (debugger, pdbmap[debugger])
+        )
         debugger = b'pdb'
 
     getattr(sys.modules[__name__], debugger)(ui, repo, bannermsg, **opts)

contrib/dirstatenonnormalcheck.py

@@ -13,6 +13,7 b' from mercurial import ('
     extensions,
 )
 
+
 def nonnormalentries(dmap):
     """Compute nonnormal entries from dirstate's dmap"""
     res = set()
@@ -21,6 +22,7 b' def nonnormalentries(dmap):'
             res.add(f)
     return res
 
+
 def checkconsistency(ui, orig, dmap, _nonnormalset, label):
     """Compute nonnormalset from dmap, check that it matches _nonnormalset"""
     nonnormalcomputedmap = nonnormalentries(dmap)
@@ -30,15 +32,19 b' def checkconsistency(ui, orig, dmap, _no'
         ui.develwarn(b"[nonnormalset] %s\n" % _nonnormalset, config=b'dirstate')
         ui.develwarn(b"[map] %s\n" % nonnormalcomputedmap, config=b'dirstate')
 
+
 def _checkdirstate(orig, self, arg):
     """Check nonnormal set consistency before and after the call to orig"""
-    checkconsistency(self._ui, orig, self._map, self._map.nonnormalset,
-                     b"before")
+    checkconsistency(
+        self._ui, orig, self._map, self._map.nonnormalset, b"before"
+    )
     r = orig(self, arg)
-    checkconsistency(self._ui, orig, self._map, self._map.nonnormalset,
-                     b"after")
+    checkconsistency(
+        self._ui, orig, self._map, self._map.nonnormalset, b"after"
+    )
     return r
 
+
 def extsetup(ui):
     """Wrap functions modifying dirstate to check nonnormalset consistency"""
     dirstatecl = dirstate.dirstate

contrib/fuzz/dirstate_corpus.py

@@ -8,8 +8,7 b' ap = argparse.ArgumentParser()'
 ap.add_argument("out", metavar="some.zip", type=str, nargs=1)
 args = ap.parse_args()
 
-reporoot = os.path.normpath(os.path.join(os.path.dirname(__file__),
-                                         '..', '..'))
+reporoot = os.path.normpath(os.path.join(os.path.dirname(__file__), '..', '..'))
 dirstate = os.path.join(reporoot, '.hg', 'dirstate')
 
 with zipfile.ZipFile(args.out[0], "w", zipfile.ZIP_STORED) as zf:

contrib/fuzz/fm1readmarkers_corpus.py

@@ -33,4 +33,6 b' with zipfile.ZipFile(args.out[0], "w", z'
             'nhistedituserAugie Fackler <[e-mail]>\x00\x00\x00yA\xd7\x02'
             'MtA\xd4\xe1\x01,\x00\x00\x01\x03\x03"\xa5\xcb\x86\xb6\xf4\xbaO\xa0'
             'sH\xe7?\xcb\x9b\xc2n\xcfI\x9e\x14\xf0D\xf0!\x18DN\xcd\x97\x016\xa5'
-            '\xef\xa06\xcb\x884\x8a\x03\x01\t\x08\x04\x1fef14operationhisted'))
+            '\xef\xa06\xcb\x884\x8a\x03\x01\t\x08\x04\x1fef14operationhisted'
+        ),
+    )

contrib/fuzz/manifest_corpus.py

@@ -8,7 +8,8 b' ap.add_argument("out", metavar="some.zip'
 args = ap.parse_args()
 
 with zipfile.ZipFile(args.out[0], "w", zipfile.ZIP_STORED) as zf:
-    zf.writestr("manifest_zero",
+    zf.writestr(
+        "manifest_zero",
 '''PKG-INFO\09b3ed8f2b81095a13064402e930565f083346e9a
 README\080b6e76643dcb44d4bc729e932fc464b3e36dbe3
 hg\0b6444347c629cc058d478023905cfb83b7f5bb9d
@@ -22,9 +23,11 b' mercurial/transaction.py\\09d180df101dc14'
 notes.txt\0703afcec5edb749cf5cec67831f554d6da13f2fb
 setup.py\0ccf3f6daf0f13101ca73631f7a1769e328b472c9
 tkmerge\03c922edb43a9c143682f7bc7b00f98b3c756ebe7
-''')
-    zf.writestr("badmanifest_shorthashes",
-                "narf\0aa\nnarf2\0aaa\n")
-    zf.writestr("badmanifest_nonull",
+''',
+    )
+    zf.writestr("badmanifest_shorthashes", "narf\0aa\nnarf2\0aaa\n")
+    zf.writestr(
+        "badmanifest_nonull",
                 "narf\0cccccccccccccccccccccccccccccccccccccccc\n"
-                "narf2aaaaaaaaaaaaaaaaaaaa\n")
+        "narf2aaaaaaaaaaaaaaaaaaaa\n",
+    )

contrib/fuzz/mpatch_corpus.py

@@ -13,6 +13,7 b' ap = argparse.ArgumentParser()'
 ap.add_argument("out", metavar="some.zip", type=str, nargs=1)
 args = ap.parse_args()
 
+
 class deltafrag(object):
     def __init__(self, start, end, data):
         self.start = start
@@ -20,8 +21,11 b' class deltafrag(object):'
         self.data = data
 
     def __str__(self):
-        return struct.pack(
-            ">lll", self.start, self.end, len(self.data)) + self.data
+        return (
+            struct.pack(">lll", self.start, self.end, len(self.data))
+            + self.data
+        )
+
 
 class delta(object):
     def __init__(self, frags):
@@ -30,8 +34,8 b' class delta(object):'
     def __str__(self):
         return ''.join(str(f) for f in self.frags)
 
+
 class corpus(object):
-
     def __init__(self, base, deltas):
         self.base = base
         self.deltas = deltas
@@ -49,19 +53,19 b' class corpus(object):'
         )
         return "".join(parts)
 
+
 with zipfile.ZipFile(args.out[0], "w", zipfile.ZIP_STORED) as zf:
     # Manually constructed entries
     zf.writestr(
-        "one_delta_applies",
-        str(corpus('a', [delta([deltafrag(0, 1, 'b')])]))
+        "one_delta_applies", str(corpus('a', [delta([deltafrag(0, 1, 'b')])]))
     )
     zf.writestr(
         "one_delta_starts_late",
-        str(corpus('a', [delta([deltafrag(3, 1, 'b')])]))
+        str(corpus('a', [delta([deltafrag(3, 1, 'b')])])),
     )
     zf.writestr(
         "one_delta_ends_late",
-        str(corpus('a', [delta([deltafrag(0, 20, 'b')])]))
+        str(corpus('a', [delta([deltafrag(0, 20, 'b')])])),
     )
 
     try:
@@ -70,8 +74,7 b' with zipfile.ZipFile(args.out[0], "w", z'
         fl = r.file('mercurial/manifest.py')
         rl = getattr(fl, '_revlog', fl)
         bins = rl._chunks(rl._deltachain(10)[0])
-        zf.writestr('manifest_py_rev_10',
-                    str(corpus(bins[0], bins[1:])))
+        zf.writestr('manifest_py_rev_10', str(corpus(bins[0], bins[1:])))
     except: # skip this, so no re-raises
         print('skipping seed file from repo data')
     # Automatically discovered by running the fuzzer
@@ -81,7 +84,8 b' with zipfile.ZipFile(args.out[0], "w", z'
     # https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8876
     zf.writestr(
         "mpatch_ossfuzz_getbe32_ubsan",
-        "\x02\x00\x00\x00\x0c    \xff\xff\xff\xff    ")
+        "\x02\x00\x00\x00\x0c    \xff\xff\xff\xff    ",
+    )
     zf.writestr(
         "mpatch_apply_over_memcpy",
         '\x13\x01\x00\x05\xd0\x00\x00\x00\x00\x00\x00\x00\x00\n \x00\x00\x00'
@@ -342,4 +346,5 b' with zipfile.ZipFile(args.out[0], "w", z'
         '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
         '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00se\x00\x00'
         '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        '\x00\x00\x00\x00')
+        '\x00\x00\x00\x00',
+    )

contrib/fuzz/revlog_corpus.py

@@ -8,13 +8,13 b' ap = argparse.ArgumentParser()'
 ap.add_argument("out", metavar="some.zip", type=str, nargs=1)
 args = ap.parse_args()
 
-reporoot = os.path.normpath(os.path.join(os.path.dirname(__file__),
-                                         '..', '..'))
+reporoot = os.path.normpath(os.path.join(os.path.dirname(__file__), '..', '..'))
 # typically a standalone index
 changelog = os.path.join(reporoot, '.hg', 'store', '00changelog.i')
 # an inline revlog with only a few revisions
 contributing = os.path.join(
-    reporoot, '.hg', 'store', 'data', 'contrib', 'fuzz', 'mpatch.cc.i')
+    reporoot, '.hg', 'store', 'data', 'contrib', 'fuzz', 'mpatch.cc.i'
+)
 
 print(changelog, os.path.exists(changelog))
 print(contributing, os.path.exists(contributing))

contrib/genosxversion.py

@@ -7,21 +7,25 b' import subprocess'
 import sys
 
 # Always load hg libraries from the hg we can find on $PATH.
-hglib = subprocess.check_output(
-    ['hg', 'debuginstall', '-T', '{hgmodules}'])
+hglib = subprocess.check_output(['hg', 'debuginstall', '-T', '{hgmodules}'])
 sys.path.insert(0, os.path.dirname(hglib))
 
 from mercurial import util
 
 ap = argparse.ArgumentParser()
-ap.add_argument('--paranoid',
+ap.add_argument(
+    '--paranoid',
                 action='store_true',
-                help=("Be paranoid about how version numbers compare and "
+    help=(
+        "Be paranoid about how version numbers compare and "
                       "produce something that's more likely to sort "
-                      "reasonably."))
+        "reasonably."
+    ),
+)
 ap.add_argument('--selftest', action='store_true', help='Run self-tests.')
 ap.add_argument('versionfile', help='Path to a valid mercurial __version__.py')
 
+
 def paranoidver(ver):
     """Given an hg version produce something that distutils can sort.
 
@@ -108,10 +112,12 b' def paranoidver(ver):'
         extra = ''
     return '%d.%d.%d%s' % (major, minor, micro, extra)
 
+
 def main(argv):
     opts = ap.parse_args(argv[1:])
     if opts.selftest:
         import doctest
+
         doctest.testmod()
         return
     with open(opts.versionfile) as f:
@@ -125,5 +131,6 b' def main(argv):'
     else:
         print(ver)
 
+
 if __name__ == '__main__':
     main(sys.argv)

contrib/hgclient.py

@@ -16,17 +16,22 b' if sys.version_info[0] >= 3:'
     stdout = sys.stdout.buffer
     stderr = sys.stderr.buffer
     stringio = io.BytesIO
+
     def bprint(*args):
         # remove b'' as well for ease of test migration
         pargs = [re.sub(br'''\bb(['"])''', br'\1', b'%s' % a) for a in args]
         stdout.write(b' '.join(pargs) + b'\n')
+
+
 else:
     import cStringIO
+
     stdout = sys.stdout
     stderr = sys.stderr
     stringio = cStringIO.StringIO
     bprint = print
 
+
 def connectpipe(path=None, extraargs=()):
     cmdline = [b'hg', b'serve', b'--cmdserver', b'pipe']
     if path:
@@ -38,11 +43,13 b' def connectpipe(path=None, extraargs=())'
             return cmdline
         return [arg.decode("utf-8") for arg in cmdline]
 
-    server = subprocess.Popen(tonative(cmdline), stdin=subprocess.PIPE,
-                              stdout=subprocess.PIPE)
+    server = subprocess.Popen(
+        tonative(cmdline), stdin=subprocess.PIPE, stdout=subprocess.PIPE
+    )
 
     return server
 
+
 class unixconnection(object):
     def __init__(self, sockpath):
         self.sock = sock = socket.socket(socket.AF_UNIX)
@@ -55,6 +62,7 b' class unixconnection(object):'
         self.stdout.close()
         self.sock.close()
 
+
 class unixserver(object):
     def __init__(self, sockpath, logpath=None, repopath=None):
         self.sockpath = sockpath
@@ -80,11 +88,13 b' class unixserver(object):'
         os.kill(self.server.pid, signal.SIGTERM)
         self.server.wait()
 
+
 def writeblock(server, data):
     server.stdin.write(struct.pack(b'>I', len(data)))
     server.stdin.write(data)
     server.stdin.flush()
 
+
 def readchannel(server):
     data = server.stdout.read(5)
     if not data:
@@ -95,11 +105,14 b' def readchannel(server):'
     else:
         return channel, server.stdout.read(length)
 
+
 def sep(text):
     return text.replace(b'\\', b'/')
 
-def runcommand(server, args, output=stdout, error=stderr, input=None,
-               outfilter=lambda x: x):
+
+def runcommand(
+    server, args, output=stdout, error=stderr, input=None, outfilter=lambda x: x
+):
     bprint(b'*** runcommand', b' '.join(args))
     stdout.flush()
     server.stdin.write(b'runcommand\n')
@@ -123,7 +136,7 b' def runcommand(server, args, output=stdo'
         elif ch == b'm':
             bprint(b"message: %r" % data)
         elif ch == b'r':
-            ret, = struct.unpack('>i', data)
+            (ret,) = struct.unpack('>i', data)
             if ret != 0:
                 bprint(b' [%d]' % ret)
             return ret
@@ -132,6 +145,7 b' def runcommand(server, args, output=stdo'
             if ch.isupper():
                 return
 
+
 def check(func, connect=connectpipe):
     stdout.flush()
     server = connect()
@@ -141,7 +155,9 b' def check(func, connect=connectpipe):'
         server.stdin.close()
         server.wait()
 
+
 def checkwith(connect=connectpipe, **kwargs):
     def wrap(func):
         return check(func, lambda: connect(**kwargs))
+
     return wrap

contrib/memory.py

@@ -13,6 +13,7 b' prints it to ``stderr`` on exit.'
 
 from __future__ import absolute_import
 
+
 def memusage(ui):
     """Report memory usage of the current process."""
     result = {'peak': 0, 'rss': 0}
@@ -24,8 +25,13 b' def memusage(ui):'
             key = parts[0][2:-1].lower()
             if key in result:
                 result[key] = int(parts[1])
-    ui.write_err(", ".join(["%s: %.1f MiB" % (k, v / 1024.0)
-                            for k, v in result.iteritems()]) + "\n")
+    ui.write_err(
+        ", ".join(
+            ["%s: %.1f MiB" % (k, v / 1024.0) for k, v in result.iteritems()]
+        )
+        + "\n"
+    )
+
 
 def extsetup(ui):
     ui.atexit(memusage, ui)

contrib/packaging/hgpackaging/downloads.py

@@ -98,7 +98,10 b' def secure_download_stream(url, size, sh'
     length = 0
 
     with urllib.request.urlopen(url) as fh:
-        if not url.endswith('.gz') and fh.info().get('Content-Encoding') == 'gzip':
+        if (
+            not url.endswith('.gz')
+            and fh.info().get('Content-Encoding') == 'gzip'
+        ):
             fh = gzip.GzipFile(fileobj=fh)
 
         while True:
@@ -114,12 +117,14 b' def secure_download_stream(url, size, sh'
     digest = h.hexdigest()
 
     if length != size:
-        raise IntegrityError('size mismatch on %s: wanted %d; got %d' % (
-            url, size, length))
+        raise IntegrityError(
+            'size mismatch on %s: wanted %d; got %d' % (url, size, length)
+        )
 
     if digest != sha256:
-        raise IntegrityError('sha256 mismatch on %s: wanted %s; got %s' % (
-            url, sha256, digest))
+        raise IntegrityError(
+            'sha256 mismatch on %s: wanted %s; got %s' % (url, sha256, digest)
+        )
 
 
 def download_to_path(url: str, path: pathlib.Path, size: int, sha256: str):
@@ -162,7 +167,9 b' def download_to_path(url: str, path: pat'
     print('successfully downloaded %s' % url)
 
 
-def download_entry(name: dict, dest_path: pathlib.Path, local_name=None) -> pathlib.Path:
+def download_entry(
+    name: dict, dest_path: pathlib.Path, local_name=None
+) -> pathlib.Path:
     entry = DOWNLOADS[name]
 
     url = entry['url']

contrib/packaging/hgpackaging/inno.py

@@ -12,12 +12,8 b' import pathlib'
 import shutil
 import subprocess
 
-from .py2exe import (
-    build_py2exe,
-)
-from .util import (
-    find_vc_runtime_files,
-)
+from .py2exe import build_py2exe
+from .util import find_vc_runtime_files
 
 
 EXTRA_PACKAGES = {
@@ -28,9 +24,13 b' EXTRA_PACKAGES = {'
 }
 
 
-def build(source_dir: pathlib.Path, build_dir: pathlib.Path,
-          python_exe: pathlib.Path, iscc_exe: pathlib.Path,
-          version=None):
+def build(
+    source_dir: pathlib.Path,
+    build_dir: pathlib.Path,
+    python_exe: pathlib.Path,
+    iscc_exe: pathlib.Path,
+    version=None,
+):
     """Build the Inno installer.
 
     Build files will be placed in ``build_dir``.
@@ -44,11 +44,18 b' def build(source_dir: pathlib.Path, buil'
 
     vc_x64 = r'\x64' in os.environ.get('LIB', '')
 
-    requirements_txt = (source_dir / 'contrib' / 'packaging' /
-                        'inno' / 'requirements.txt')
+    requirements_txt = (
+        source_dir / 'contrib' / 'packaging' / 'inno' / 'requirements.txt'
+    )
 
-    build_py2exe(source_dir, build_dir, python_exe, 'inno',
-                 requirements_txt, extra_packages=EXTRA_PACKAGES)
+    build_py2exe(
+        source_dir,
+        build_dir,
+        python_exe,
+        'inno',
+        requirements_txt,
+        extra_packages=EXTRA_PACKAGES,
+    )
 
     # hg.exe depends on VC9 runtime DLLs. Copy those into place.
     for f in find_vc_runtime_files(vc_x64):

contrib/packaging/hgpackaging/py2exe.py

@@ -11,9 +11,7 b' import os'
 import pathlib
 import subprocess
 
-from .downloads import (
-    download_entry,
-)
+from .downloads import download_entry
 from .util import (
     extract_tar_to_directory,
     extract_zip_to_directory,
@@ -21,12 +19,17 b' from .util import ('
 )
 
 
-def build_py2exe(source_dir: pathlib.Path, build_dir: pathlib.Path,
-                 python_exe: pathlib.Path, build_name: str,
+def build_py2exe(
+    source_dir: pathlib.Path,
+    build_dir: pathlib.Path,
+    python_exe: pathlib.Path,
+    build_name: str,
                  venv_requirements_txt: pathlib.Path,
-                 extra_packages=None, extra_excludes=None,
+    extra_packages=None,
+    extra_excludes=None,
                  extra_dll_excludes=None,
-                 extra_packages_script=None):
+    extra_packages_script=None,
+):
     """Build Mercurial with py2exe.
 
     Build files will be placed in ``build_dir``.
@@ -36,9 +39,11 b' def build_py2exe(source_dir: pathlib.Pat'
     to already be configured with an active toolchain.
     """
     if 'VCINSTALLDIR' not in os.environ:
-        raise Exception('not running from a Visual C++ build environment; '
+        raise Exception(
+            'not running from a Visual C++ build environment; '
                         'execute the "Visual C++ <version> Command Prompt" '
-                        'application shortcut or a vcsvarsall.bat file')
+            'application shortcut or a vcsvarsall.bat file'
+        )
 
     # Identity x86/x64 and validate the environment matches the Python
     # architecture.
@@ -48,12 +53,16 b' def build_py2exe(source_dir: pathlib.Pat'
 
     if vc_x64:
         if py_info['arch'] != '64bit':
-            raise Exception('architecture mismatch: Visual C++ environment '
-                            'is configured for 64-bit but Python is 32-bit')
+            raise Exception(
+                'architecture mismatch: Visual C++ environment '
+                'is configured for 64-bit but Python is 32-bit'
+            )
     else:
         if py_info['arch'] != '32bit':
-            raise Exception('architecture mismatch: Visual C++ environment '
-                            'is configured for 32-bit but Python is 64-bit')
+            raise Exception(
+                'architecture mismatch: Visual C++ environment '
+                'is configured for 32-bit but Python is 64-bit'
+            )
 
     if py_info['py3']:
         raise Exception('Only Python 2 is currently supported')
@@ -65,11 +74,11 b' def build_py2exe(source_dir: pathlib.Pat'
     virtualenv_pkg, virtualenv_entry = download_entry('virtualenv', build_dir)
     py2exe_pkg, py2exe_entry = download_entry('py2exe', build_dir)
 
-    venv_path = build_dir / ('venv-%s-%s' % (build_name,
-                                             'x64' if vc_x64 else 'x86'))
+    venv_path = build_dir / (
+        'venv-%s-%s' % (build_name, 'x64' if vc_x64 else 'x86')
+    )
 
-    gettext_root = build_dir / (
-        'gettext-win-%s' % gettext_entry['version'])
+    gettext_root = build_dir / ('gettext-win-%s' % gettext_entry['version'])
 
     if not gettext_root.exists():
         extract_zip_to_directory(gettext_pkg, gettext_root)
@@ -77,7 +86,8 b' def build_py2exe(source_dir: pathlib.Pat'
 
     # This assumes Python 2. We don't need virtualenv on Python 3.
     virtualenv_src_path = build_dir / (
-        'virtualenv-%s' % virtualenv_entry['version'])
+        'virtualenv-%s' % virtualenv_entry['version']
+    )
     virtualenv_py = virtualenv_src_path / 'virtualenv.py'
 
     if not virtualenv_src_path.exists():
@@ -91,14 +101,15 b' def build_py2exe(source_dir: pathlib.Pat'
     if not venv_path.exists():
         print('creating virtualenv with dependencies')
         subprocess.run(
-            [str(python_exe), str(virtualenv_py), str(venv_path)],
-            check=True)
+            [str(python_exe), str(virtualenv_py), str(venv_path)], check=True
+        )
 
     venv_python = venv_path / 'Scripts' / 'python.exe'
     venv_pip = venv_path / 'Scripts' / 'pip.exe'
 
-    subprocess.run([str(venv_pip), 'install', '-r', str(venv_requirements_txt)],
-                   check=True)
+    subprocess.run(
+        [str(venv_pip), 'install', '-r', str(venv_requirements_txt)], check=True
+    )
 
     # Force distutils to use VC++ settings from environment, which was
     # validated above.
@@ -107,9 +118,13 b' def build_py2exe(source_dir: pathlib.Pat'
     env['MSSdk'] = '1'
 
     if extra_packages_script:
-        more_packages = set(subprocess.check_output(
-            extra_packages_script,
-            cwd=build_dir).split(b'\0')[-1].strip().decode('utf-8').splitlines())
+        more_packages = set(
+            subprocess.check_output(extra_packages_script, cwd=build_dir)
+            .split(b'\0')[-1]
+            .strip()
+            .decode('utf-8')
+            .splitlines()
+        )
         if more_packages:
             if not extra_packages:
                 extra_packages = more_packages
@@ -119,32 +134,38 b' def build_py2exe(source_dir: pathlib.Pat'
     if extra_packages:
         env['HG_PY2EXE_EXTRA_PACKAGES'] = ' '.join(sorted(extra_packages))
         hgext3rd_extras = sorted(
-            e for e in extra_packages if e.startswith('hgext3rd.'))
+            e for e in extra_packages if e.startswith('hgext3rd.')
+        )
         if hgext3rd_extras:
             env['HG_PY2EXE_EXTRA_INSTALL_PACKAGES'] = ' '.join(hgext3rd_extras)
     if extra_excludes:
         env['HG_PY2EXE_EXTRA_EXCLUDES'] = ' '.join(sorted(extra_excludes))
     if extra_dll_excludes:
         env['HG_PY2EXE_EXTRA_DLL_EXCLUDES'] = ' '.join(
-            sorted(extra_dll_excludes))
+            sorted(extra_dll_excludes)
+        )
 
     py2exe_py_path = venv_path / 'Lib' / 'site-packages' / 'py2exe'
     if not py2exe_py_path.exists():
         print('building py2exe')
-        subprocess.run([str(venv_python), 'setup.py', 'install'],
+        subprocess.run(
+            [str(venv_python), 'setup.py', 'install'],
                        cwd=py2exe_source_path,
                        env=env,
-                       check=True)
+            check=True,
+        )
 
     # Register location of msgfmt and other binaries.
     env['PATH'] = '%s%s%s' % (
-        env['PATH'], os.pathsep, str(gettext_root / 'bin'))
+        env['PATH'],
+        os.pathsep,
+        str(gettext_root / 'bin'),
+    )
 
     print('building Mercurial')
     subprocess.run(
-        [str(venv_python), 'setup.py',
-         'py2exe',
-         'build_doc', '--html'],
+        [str(venv_python), 'setup.py', 'py2exe', 'build_doc', '--html'],
         cwd=str(source_dir),
         env=env,
-        check=True)
+        check=True,
+    )

contrib/packaging/hgpackaging/util.py

@@ -32,8 +32,11 b' def find_vc_runtime_files(x64=False):'
 
     prefix = 'amd64' if x64 else 'x86'
 
-    candidates = sorted(p for p in os.listdir(winsxs)
-                  if p.lower().startswith('%s_microsoft.vc90.crt_' % prefix))
+    candidates = sorted(
+        p
+        for p in os.listdir(winsxs)
+        if p.lower().startswith('%s_microsoft.vc90.crt_' % prefix)
+    )
 
     for p in candidates:
         print('found candidate VC runtime: %s' % p)
@@ -72,7 +75,7 b' def windows_10_sdk_info():'
         'version': version,
         'bin_root': bin_version,
         'bin_x86': bin_version / 'x86',
-        'bin_x64': bin_version / 'x64'
+        'bin_x64': bin_version / 'x64',
     }
 
 
@@ -89,9 +92,14 b' def find_signtool():'
     raise Exception('could not find signtool.exe in Windows 10 SDK')
 
 
-def sign_with_signtool(file_path, description, subject_name=None,
-                       cert_path=None, cert_password=None,
-                       timestamp_url=None):
+def sign_with_signtool(
+    file_path,
+    description,
+    subject_name=None,
+    cert_path=None,
+    cert_password=None,
+    timestamp_url=None,
+):
     """Digitally sign a file with signtool.exe.
 
     ``file_path`` is file to sign.
@@ -114,10 +122,13 b' def sign_with_signtool(file_path, descri'
         cert_password = getpass.getpass('password for %s: ' % cert_path)
 
     args = [
-        str(find_signtool()), 'sign',
+        str(find_signtool()),
+        'sign',
         '/v',
-        '/fd', 'sha256',
-        '/d', description,
+        '/fd',
+        'sha256',
+        '/d',
+        description,
     ]
 
     if cert_path:

contrib/packaging/hgpackaging/wix.py

@@ -15,12 +15,8 b' import tempfile'
 import typing
 import xml.dom.minidom
 
-from .downloads import (
-    download_entry,
-)
-from .py2exe import (
-    build_py2exe,
-)
+from .downloads import download_entry
+from .py2exe import build_py2exe
 from .util import (
     extract_zip_to_directory,
     sign_with_signtool,
@@ -84,17 +80,29 b' def normalize_version(version):'
 
 def ensure_vc90_merge_modules(build_dir):
     x86 = (
-        download_entry('vc9-crt-x86-msm', build_dir,
-                       local_name='microsoft.vcxx.crt.x86_msm.msm')[0],
-        download_entry('vc9-crt-x86-msm-policy', build_dir,
-                       local_name='policy.x.xx.microsoft.vcxx.crt.x86_msm.msm')[0]
+        download_entry(
+            'vc9-crt-x86-msm',
+            build_dir,
+            local_name='microsoft.vcxx.crt.x86_msm.msm',
+        )[0],
+        download_entry(
+            'vc9-crt-x86-msm-policy',
+            build_dir,
+            local_name='policy.x.xx.microsoft.vcxx.crt.x86_msm.msm',
+        )[0],
     )
 
     x64 = (
-        download_entry('vc9-crt-x64-msm', build_dir,
-                       local_name='microsoft.vcxx.crt.x64_msm.msm')[0],
-        download_entry('vc9-crt-x64-msm-policy', build_dir,
-                       local_name='policy.x.xx.microsoft.vcxx.crt.x64_msm.msm')[0]
+        download_entry(
+            'vc9-crt-x64-msm',
+            build_dir,
+            local_name='microsoft.vcxx.crt.x64_msm.msm',
+        )[0],
+        download_entry(
+            'vc9-crt-x64-msm-policy',
+            build_dir,
+            local_name='policy.x.xx.microsoft.vcxx.crt.x64_msm.msm',
+        )[0],
     )
     return {
         'x86': x86,
@@ -116,17 +124,26 b' def run_candle(wix, cwd, wxs, source_dir'
     subprocess.run(args, cwd=str(cwd), check=True)
 
 
-def make_post_build_signing_fn(name, subject_name=None, cert_path=None,
-                               cert_password=None, timestamp_url=None):
+def make_post_build_signing_fn(
+    name,
+    subject_name=None,
+    cert_path=None,
+    cert_password=None,
+    timestamp_url=None,
+):
     """Create a callable that will use signtool to sign hg.exe."""
 
     def post_build_sign(source_dir, build_dir, dist_dir, version):
         description = '%s %s' % (name, version)
 
-        sign_with_signtool(dist_dir / 'hg.exe', description,
-                           subject_name=subject_name, cert_path=cert_path,
+        sign_with_signtool(
+            dist_dir / 'hg.exe',
+            description,
+            subject_name=subject_name,
+            cert_path=cert_path,
                            cert_password=cert_password,
-                           timestamp_url=timestamp_url)
+            timestamp_url=timestamp_url,
+        )
 
     return post_build_sign
 
@@ -155,7 +172,8 b' def make_libraries_xml(wix_dir: pathlib.'
     # We can't use ElementTree because it doesn't handle the
     # <?include ?> directives.
     doc = xml.dom.minidom.parseString(
-        LIBRARIES_XML.format(wix_dir=str(wix_dir)))
+        LIBRARIES_XML.format(wix_dir=str(wix_dir))
+    )
 
     component = doc.getElementsByTagName('Component')[0]
 
@@ -177,11 +195,16 b' def make_libraries_xml(wix_dir: pathlib.'
     return doc.toprettyxml()
 
 
-def build_installer(source_dir: pathlib.Path, python_exe: pathlib.Path,
-                    msi_name='mercurial', version=None, post_build_fn=None,
+def build_installer(
+    source_dir: pathlib.Path,
+    python_exe: pathlib.Path,
+    msi_name='mercurial',
+    version=None,
+    post_build_fn=None,
                     extra_packages_script=None,
                     extra_wxs:typing.Optional[typing.Dict[str,str]]=None,
-                    extra_features:typing.Optional[typing.List[str]]=None):
+    extra_features: typing.Optional[typing.List[str]] = None,
+):
     """Build a WiX MSI installer.
 
     ``source_dir`` is the path to the Mercurial source tree to use.
@@ -209,10 +232,15 b' def build_installer(source_dir: pathlib.'
 
     requirements_txt = wix_dir / 'requirements.txt'
 
-    build_py2exe(source_dir, hg_build_dir,
-                 python_exe, 'wix', requirements_txt,
+    build_py2exe(
+        source_dir,
+        hg_build_dir,
+        python_exe,
+        'wix',
+        requirements_txt,
                  extra_packages=EXTRA_PACKAGES,
-                 extra_packages_script=extra_packages_script)
+        extra_packages_script=extra_packages_script,
+    )
 
     version = version or normalize_version(find_version(source_dir))
     print('using version string: %s' % version)
@@ -265,16 +293,19 b' def build_installer(source_dir: pathlib.'
 
     run_candle(wix_path, build_dir, source, source_build_rel, defines=defines)
 
-    msi_path = source_dir / 'dist' / (
-        '%s-%s-%s.msi' % (msi_name, version, arch))
+    msi_path = (
+        source_dir / 'dist' / ('%s-%s-%s.msi' % (msi_name, version, arch))
+    )
 
     args = [
         str(wix_path / 'light.exe'),
         '-nologo',
-        '-ext', 'WixUIExtension',
+        '-ext',
+        'WixUIExtension',
         '-sw1076',
         '-spdb',
-        '-o', str(msi_path),
+        '-o',
+        str(msi_path),
     ]
 
     for source, rel_path in SUPPORT_WXS:
@@ -286,10 +317,12 b' def build_installer(source_dir: pathlib.'
         source = os.path.basename(source)
         args.append(str(build_dir / ('%s.wixobj' % source[:-4])))
 
-    args.extend([
+    args.extend(
+        [
         str(build_dir / 'library.wixobj'),
         str(build_dir / 'mercurial.wixobj'),
-    ])
+        ]
+    )
 
     subprocess.run(args, cwd=str(source_dir), check=True)
 
@@ -300,11 +333,19 b' def build_installer(source_dir: pathlib.'
     }
 
 
-def build_signed_installer(source_dir: pathlib.Path, python_exe: pathlib.Path,
-                           name: str, version=None, subject_name=None,
-                           cert_path=None, cert_password=None,
-                           timestamp_url=None, extra_packages_script=None,
-                           extra_wxs=None, extra_features=None):
+def build_signed_installer(
+    source_dir: pathlib.Path,
+    python_exe: pathlib.Path,
+    name: str,
+    version=None,
+    subject_name=None,
+    cert_path=None,
+    cert_password=None,
+    timestamp_url=None,
+    extra_packages_script=None,
+    extra_wxs=None,
+    extra_features=None,
+):
     """Build an installer with signed executables."""
 
     post_build_fn = make_post_build_signing_fn(
@@ -312,16 +353,27 b' def build_signed_installer(source_dir: p'
         subject_name=subject_name,
         cert_path=cert_path,
         cert_password=cert_password,
-        timestamp_url=timestamp_url)
+        timestamp_url=timestamp_url,
+    )
 
-    info = build_installer(source_dir, python_exe=python_exe,
-                           msi_name=name.lower(), version=version,
+    info = build_installer(
+        source_dir,
+        python_exe=python_exe,
+        msi_name=name.lower(),
+        version=version,
                            post_build_fn=post_build_fn,
                            extra_packages_script=extra_packages_script,
-                           extra_wxs=extra_wxs, extra_features=extra_features)
+        extra_wxs=extra_wxs,
+        extra_features=extra_features,
+    )
 
     description = '%s %s' % (name, version)
 
-    sign_with_signtool(info['msi_path'], description,
-                       subject_name=subject_name, cert_path=cert_path,
-                       cert_password=cert_password, timestamp_url=timestamp_url)
+    sign_with_signtool(
+        info['msi_path'],
+        description,
+        subject_name=subject_name,
+        cert_path=cert_path,
+        cert_password=cert_password,
+        timestamp_url=timestamp_url,
+    )

contrib/packaging/inno/build.py

@@ -19,14 +19,15 b' import sys'
 if __name__ == '__main__':
     parser = argparse.ArgumentParser()
 
-    parser.add_argument('--python',
-                        required=True,
-                        help='path to python.exe to use')
-    parser.add_argument('--iscc',
-                        help='path to iscc.exe to use')
-    parser.add_argument('--version',
+    parser.add_argument(
+        '--python', required=True, help='path to python.exe to use'
+    )
+    parser.add_argument('--iscc', help='path to iscc.exe to use')
+    parser.add_argument(
+        '--version',
                         help='Mercurial version string to use '
-                             '(detected from __version__.py if not defined')
+        '(detected from __version__.py if not defined',
+    )
 
     args = parser.parse_args()
 
@@ -36,8 +37,11 b" if __name__ == '__main__':"
     if args.iscc:
         iscc = pathlib.Path(args.iscc)
     else:
-        iscc = (pathlib.Path(os.environ['ProgramFiles(x86)']) / 'Inno Setup 5' /
-            'ISCC.exe')
+        iscc = (
+            pathlib.Path(os.environ['ProgramFiles(x86)'])
+            / 'Inno Setup 5'
+            / 'ISCC.exe'
+        )
 
     here = pathlib.Path(os.path.abspath(os.path.dirname(__file__)))
     source_dir = here.parent.parent.parent
@@ -47,5 +51,10 b" if __name__ == '__main__':"
 
     from hgpackaging.inno import build
 
-    build(source_dir, build_dir, pathlib.Path(args.python), iscc,
-          version=args.version)
+    build(
+        source_dir,
+        build_dir,
+        pathlib.Path(args.python),
+        iscc,
+        version=args.version,
+    )

contrib/packaging/wix/build.py

@@ -17,31 +17,42 b' import sys'
 if __name__ == '__main__':
     parser = argparse.ArgumentParser()
 
-    parser.add_argument('--name',
-                        help='Application name',
-                        default='Mercurial')
-    parser.add_argument('--python',
-                        help='Path to Python executable to use',
-                        required=True)
-    parser.add_argument('--sign-sn',
+    parser.add_argument('--name', help='Application name', default='Mercurial')
+    parser.add_argument(
+        '--python', help='Path to Python executable to use', required=True
+    )
+    parser.add_argument(
+        '--sign-sn',
                         help='Subject name (or fragment thereof) of certificate '
-                             'to use for signing')
-    parser.add_argument('--sign-cert',
-                        help='Path to certificate to use for signing')
-    parser.add_argument('--sign-password',
-                        help='Password for signing certificate')
-    parser.add_argument('--sign-timestamp-url',
-                        help='URL of timestamp server to use for signing')
-    parser.add_argument('--version',
-                        help='Version string to use')
-    parser.add_argument('--extra-packages-script',
-                        help=('Script to execute to include extra packages in '
-                              'py2exe binary.'))
-    parser.add_argument('--extra-wxs',
-                        help='CSV of path_to_wxs_file=working_dir_for_wxs_file')
-    parser.add_argument('--extra-features',
-                        help=('CSV of extra feature names to include '
-                              'in the installer from the extra wxs files'))
+        'to use for signing',
+    )
+    parser.add_argument(
+        '--sign-cert', help='Path to certificate to use for signing'
+    )
+    parser.add_argument(
+        '--sign-password', help='Password for signing certificate'
+    )
+    parser.add_argument(
+        '--sign-timestamp-url',
+        help='URL of timestamp server to use for signing',
+    )
+    parser.add_argument('--version', help='Version string to use')
+    parser.add_argument(
+        '--extra-packages-script',
+        help=(
+            'Script to execute to include extra packages in ' 'py2exe binary.'
+        ),
+    )
+    parser.add_argument(
+        '--extra-wxs', help='CSV of path_to_wxs_file=working_dir_for_wxs_file'
+    )
+    parser.add_argument(
+        '--extra-features',
+        help=(
+            'CSV of extra feature names to include '
+            'in the installer from the extra wxs files'
+        ),
+    )
 
     args = parser.parse_args()
 
@@ -69,7 +80,8 b" if __name__ == '__main__':"
         kwargs['extra_packages_script'] = args.extra_packages_script
     if args.extra_wxs:
         kwargs['extra_wxs'] = dict(
-            thing.split("=") for thing in args.extra_wxs.split(','))
+            thing.split("=") for thing in args.extra_wxs.split(',')
+        )
     if args.extra_features:
         kwargs['extra_features'] = args.extra_features.split(',')
 

contrib/perf-utils/perf-revlog-write-plot.py

@@ -44,18 +44,12 b' def plot(data, title=None):'
     comb_plt = fig.add_subplot(211)
     other_plt = fig.add_subplot(212)
 
-    comb_plt.plot(ary[0],
-                  np.cumsum(ary[1]),
-                  color='red',
-                  linewidth=1,
-                  label='comb')
+    comb_plt.plot(
+        ary[0], np.cumsum(ary[1]), color='red', linewidth=1, label='comb'
+    )
 
     plots = []
-    p = other_plt.plot(ary[0],
-                       ary[1],
-                       color='red',
-                       linewidth=1,
-                       label='wall')
+    p = other_plt.plot(ary[0], ary[1], color='red', linewidth=1, label='wall')
     plots.append(p)
 
     colors = {
@@ -64,20 +58,24 b' def plot(data, title=None):'
         1000: ('purple', 'xkcd:dark pink'),
     }
     for n, color in colors.items():
-        avg_n = np.convolve(ary[1], np.full(n, 1. / n), 'valid')
-        p = other_plt.plot(ary[0][n - 1:],
+        avg_n = np.convolve(ary[1], np.full(n, 1.0 / n), 'valid')
+        p = other_plt.plot(
+            ary[0][n - 1 :],
                            avg_n,
                            color=color[0],
                            linewidth=1,
-                           label='avg time last %d' % n)
+            label='avg time last %d' % n,
+        )
         plots.append(p)
 
         med_n = scipy.signal.medfilt(ary[1], n + 1)
-        p = other_plt.plot(ary[0],
+        p = other_plt.plot(
+            ary[0],
                            med_n,
                            color=color[1],
                            linewidth=1,
-                           label='median time last %d' % n)
+            label='median time last %d' % n,
+        )
         plots.append(p)
 
     formatter = mticker.ScalarFormatter()
@@ -108,6 +106,7 b' def plot(data, title=None):'
         else:
             legline.set_alpha(0.2)
         fig.canvas.draw()
+
     if title is not None:
         fig.canvas.set_window_title(title)
     fig.canvas.mpl_connect('pick_event', onpick)

contrib/perf.py

@@ -93,6 +93,7 b' except ImportError:'
     pass
 try:
     from mercurial import registrar # since 3.7 (or 37d50250b696)
+
     dir(registrar) # forcibly load it
 except ImportError:
     registrar = None
@@ -118,11 +119,14 b' try:'
 except ImportError:
     profiling = None
 
+
 def identity(a):
     return a
 
+
 try:
     from mercurial import pycompat
+
     getargspec = pycompat.getargspec  # added to module after 4.5
     _byteskwargs = pycompat.byteskwargs  # since 4.1 (or fbc3f73dc802)
     _sysstr = pycompat.sysstr         # since 4.0 (or 2219f4f82ede)
@@ -135,6 +139,7 b' try:'
         _maxint = sys.maxint
 except (NameError, ImportError, AttributeError):
     import inspect
+
     getargspec = inspect.getargspec
     _byteskwargs = identity
     _bytestr = str
@@ -155,6 +160,7 b' except (NameError, AttributeError, Impor'
 
 try:
     from mercurial import logcmdutil
+
     makelogtemplater = logcmdutil.maketemplater
 except (AttributeError, ImportError):
     try:
@@ -166,8 +172,12 b' except (AttributeError, ImportError):'
 # define util.safehasattr forcibly, because util.safehasattr has been
 # available since 1.9.3 (or 94b200a11cf7)
 _undefined = object()
+
+
 def safehasattr(thing, attr):
     return getattr(thing, _sysstr(attr), _undefined) is not _undefined
+
+
 setattr(util, 'safehasattr', safehasattr)
 
 # for "historical portability":
@@ -185,20 +195,28 b' else:'
 # available, because commands.formatteropts has been available since
 # 3.2 (or 7a7eed5176a4), even though formatting itself has been
 # available since 2.2 (or ae5f92e154d3)
-formatteropts = getattr(cmdutil, "formatteropts",
-                        getattr(commands, "formatteropts", []))
+formatteropts = getattr(
+    cmdutil, "formatteropts", getattr(commands, "formatteropts", [])
+)
 
 # for "historical portability":
 # use locally defined option list, if debugrevlogopts isn't available,
 # because commands.debugrevlogopts has been available since 3.7 (or
 # 5606f7d0d063), even though cmdutil.openrevlog() has been available
 # since 1.9 (or a79fea6b3e77).
-revlogopts = getattr(cmdutil, "debugrevlogopts",
-                     getattr(commands, "debugrevlogopts", [
-        (b'c', b'changelog', False, (b'open changelog')),
-        (b'm', b'manifest', False, (b'open manifest')),
-        (b'', b'dir', False, (b'open directory manifest')),
-        ]))
+revlogopts = getattr(
+    cmdutil,
+    "debugrevlogopts",
+    getattr(
+        commands,
+        "debugrevlogopts",
+        [
+            (b'c', b'changelog', False, b'open changelog'),
+            (b'm', b'manifest', False, b'open manifest'),
+            (b'', b'dir', False, b'open directory manifest'),
+        ],
+    ),
+)
 
 cmdtable = {}
 
@@ -208,6 +226,7 b' cmdtable = {}'
 def parsealiases(cmd):
     return cmd.split(b"|")
 
+
 if safehasattr(registrar, 'command'):
     command = registrar.command(cmdtable)
 elif safehasattr(cmdutil, 'command'):
@@ -217,10 +236,13 b" elif safehasattr(cmdutil, 'command'):"
         # wrap original cmdutil.command, because "norepo" option has
         # been available since 3.1 (or 75a96326cecb)
         _command = command
+
         def command(name, options=(), synopsis=None, norepo=False):
             if norepo:
                 commands.norepo += b' %s' % b' '.join(parsealiases(name))
             return _command(name, list(options), synopsis)
+
+
 else:
     # for "historical portability":
     # define "@command" annotation locally, because cmdutil.command
@@ -234,36 +256,51 b' else:'
             if norepo:
                 commands.norepo += b' %s' % b' '.join(parsealiases(name))
             return func
+
         return decorator
 
+
 try:
     import mercurial.registrar
     import mercurial.configitems
+
     configtable = {}
     configitem = mercurial.registrar.configitem(configtable)
-    configitem(b'perf', b'presleep',
+    configitem(
+        b'perf',
+        b'presleep',
         default=mercurial.configitems.dynamicdefault,
         experimental=True,
     )
-    configitem(b'perf', b'stub',
+    configitem(
+        b'perf',
+        b'stub',
         default=mercurial.configitems.dynamicdefault,
         experimental=True,
     )
-    configitem(b'perf', b'parentscount',
+    configitem(
+        b'perf',
+        b'parentscount',
         default=mercurial.configitems.dynamicdefault,
         experimental=True,
     )
-    configitem(b'perf', b'all-timing',
+    configitem(
+        b'perf',
+        b'all-timing',
         default=mercurial.configitems.dynamicdefault,
         experimental=True,
     )
-    configitem(b'perf', b'pre-run',
+    configitem(
+        b'perf', b'pre-run', default=mercurial.configitems.dynamicdefault,
+    )
+    configitem(
+        b'perf',
+        b'profile-benchmark',
         default=mercurial.configitems.dynamicdefault,
     )
-    configitem(b'perf', b'profile-benchmark',
-        default=mercurial.configitems.dynamicdefault,
-    )
-    configitem(b'perf', b'run-limits',
+    configitem(
+        b'perf',
+        b'run-limits',
         default=mercurial.configitems.dynamicdefault,
         experimental=True,
     )
@@ -272,42 +309,50 b' except (ImportError, AttributeError):'
 except TypeError:
     # compatibility fix for a11fd395e83f
     # hg version: 5.2
-    configitem(b'perf', b'presleep',
-        default=mercurial.configitems.dynamicdefault,
+    configitem(
+        b'perf', b'presleep', default=mercurial.configitems.dynamicdefault,
+    )
+    configitem(
+        b'perf', b'stub', default=mercurial.configitems.dynamicdefault,
+    )
+    configitem(
+        b'perf', b'parentscount', default=mercurial.configitems.dynamicdefault,
     )
-    configitem(b'perf', b'stub',
-        default=mercurial.configitems.dynamicdefault,
+    configitem(
+        b'perf', b'all-timing', default=mercurial.configitems.dynamicdefault,
     )
-    configitem(b'perf', b'parentscount',
+    configitem(
+        b'perf', b'pre-run', default=mercurial.configitems.dynamicdefault,
+    )
+    configitem(
+        b'perf',
+        b'profile-benchmark',
         default=mercurial.configitems.dynamicdefault,
     )
-    configitem(b'perf', b'all-timing',
-        default=mercurial.configitems.dynamicdefault,
-    )
-    configitem(b'perf', b'pre-run',
-        default=mercurial.configitems.dynamicdefault,
+    configitem(
+        b'perf', b'run-limits', default=mercurial.configitems.dynamicdefault,
     )
-    configitem(b'perf', b'profile-benchmark',
-        default=mercurial.configitems.dynamicdefault,
-    )
-    configitem(b'perf', b'run-limits',
-        default=mercurial.configitems.dynamicdefault,
-    )
+
 
 def getlen(ui):
     if ui.configbool(b"perf", b"stub", False):
         return lambda x: 1
     return len
 
+
 class noop(object):
     """dummy context manager"""
+
     def __enter__(self):
         pass
+
     def __exit__(self, *args):
         pass
 
+
 NOOPCTX = noop()
 
+
 def gettimer(ui, opts=None):
     """return a timer function and formatter: (timer, formatter)
 
@@ -338,31 +383,42 b' def gettimer(ui, opts=None):'
         # define formatter locally, because ui.formatter has been
         # available since 2.2 (or ae5f92e154d3)
         from mercurial import node
+
         class defaultformatter(object):
             """Minimized composition of baseformatter and plainformatter
             """
+
             def __init__(self, ui, topic, opts):
                 self._ui = ui
                 if ui.debugflag:
                     self.hexfunc = node.hex
                 else:
                     self.hexfunc = node.short
+
             def __nonzero__(self):
                 return False
+
             __bool__ = __nonzero__
+
             def startitem(self):
                 pass
+
             def data(self, **data):
                 pass
+
             def write(self, fields, deftext, *fielddata, **opts):
                 self._ui.write(deftext % fielddata, **opts)
+
             def condwrite(self, cond, fields, deftext, *fielddata, **opts):
                 if cond:
                     self._ui.write(deftext % fielddata, **opts)
+
             def plain(self, text, **opts):
                 self._ui.write(text, **opts)
+
             def end(self):
                 pass
+
         fm = defaultformatter(ui, b'perf', opts)
 
     # stub function, runs code only once instead of in a loop
@@ -379,20 +435,27 b' def gettimer(ui, opts=None):'
     for item in limitspec:
         parts = item.split(b'-', 1)
         if len(parts) < 2:
-            ui.warn((b'malformatted run limit entry, missing "-": %s\n'
-                     % item))
+            ui.warn((b'malformatted run limit entry, missing "-": %s\n' % item))
             continue
         try:
             time_limit = float(_sysstr(parts[0]))
         except ValueError as e:
-            ui.warn((b'malformatted run limit entry, %s: %s\n'
-                     % (_bytestr(e), item)))
+            ui.warn(
+                (
+                    b'malformatted run limit entry, %s: %s\n'
+                    % (_bytestr(e), item)
+                )
+            )
             continue
         try:
             run_limit = int(_sysstr(parts[1]))
         except ValueError as e:
-            ui.warn((b'malformatted run limit entry, %s: %s\n'
-                     % (_bytestr(e), item)))
+            ui.warn(
+                (
+                    b'malformatted run limit entry, %s: %s\n'
+                    % (_bytestr(e), item)
+                )
+            )
             continue
         limits.append((time_limit, run_limit))
     if not limits:
@@ -404,15 +467,23 b' def gettimer(ui, opts=None):'
             profiler = profiling.profile(ui)
 
     prerun = getint(ui, b"perf", b"pre-run", 0)
-    t = functools.partial(_timer, fm, displayall=displayall, limits=limits,
-                          prerun=prerun, profiler=profiler)
+    t = functools.partial(
+        _timer,
+        fm,
+        displayall=displayall,
+        limits=limits,
+        prerun=prerun,
+        profiler=profiler,
+    )
     return t, fm
 
+
 def stub_timer(fm, func, setup=None, title=None):
     if setup is not None:
         setup()
     func()
 
+
 @contextlib.contextmanager
 def timeone():
     r = []
@@ -431,8 +502,17 b' DEFAULTLIMITS = ('
     (10.0, 3),
 )
 
-def _timer(fm, func, setup=None, title=None, displayall=False,
-           limits=DEFAULTLIMITS, prerun=0, profiler=None):
+
+def _timer(
+    fm,
+    func,
+    setup=None,
+    title=None,
+    displayall=False,
+    limits=DEFAULTLIMITS,
+    prerun=0,
+    profiler=None,
+):
     gc.collect()
     results = []
     begin = util.timer()
@@ -461,8 +541,8 b' def _timer(fm, func, setup=None, title=N'
                 keepgoing = False
                 break
 
-    formatone(fm, results, title=title, result=r,
-              displayall=displayall)
+    formatone(fm, results, title=title, result=r, displayall=displayall)
+
 
 def formatone(fm, timings, title=None, result=None, displayall=False):
 
@@ -474,6 +554,7 b' def formatone(fm, timings, title=None, r'
         fm.write(b'title', b'! %s\n', title)
     if result:
         fm.write(b'result', b'! result: %s\n', result)
+
     def display(role, entry):
         prefix = b''
         if role != b'best':
@@ -485,6 +566,7 b' def formatone(fm, timings, title=None, r'
         fm.write(prefix + b'sys',  b' sys %f', entry[2])
         fm.write(prefix + b'count',  b' (%s of %%d)' % role, count)
         fm.plain(b'\n')
+
     timings.sort()
     min_val = timings[0]
     display(b'best', min_val)
@@ -496,8 +578,10 b' def formatone(fm, timings, title=None, r'
         median = timings[len(timings) // 2]
         display(b'median', median)
 
+
 # utilities for historical portability
 
+
 def getint(ui, section, name, default):
     # for "historical portability":
     # ui.configint has been available since 1.9 (or fa2b596db182)
@@ -507,8 +591,10 b' def getint(ui, section, name, default):'
     try:
         return int(v)
     except ValueError:
-        raise error.ConfigError((b"%s.%s is not an integer ('%s')")
-                                % (section, name, v))
+        raise error.ConfigError(
+            b"%s.%s is not an integer ('%s')" % (section, name, v)
+        )
+
 
 def safeattrsetter(obj, name, ignoremissing=False):
     """Ensure that 'obj' has 'name' attribute before subsequent setattr
@@ -528,20 +614,29 b' def safeattrsetter(obj, name, ignoremiss'
     if not util.safehasattr(obj, name):
         if ignoremissing:
             return None
-        raise error.Abort((b"missing attribute %s of %s might break assumption"
-                           b" of performance measurement") % (name, obj))
+        raise error.Abort(
+            (
+                b"missing attribute %s of %s might break assumption"
+                b" of performance measurement"
+            )
+            % (name, obj)
+        )
 
     origvalue = getattr(obj, _sysstr(name))
+
     class attrutil(object):
         def set(self, newvalue):
             setattr(obj, _sysstr(name), newvalue)
+
         def restore(self):
             setattr(obj, _sysstr(name), origvalue)
 
     return attrutil()
 
+
 # utilities to examine each internal API changes
 
+
 def getbranchmapsubsettable():
     # for "historical portability":
     # subsettable is defined in:
@@ -556,8 +651,11 b' def getbranchmapsubsettable():'
     # bisecting in bcee63733aad::59a9f18d4587 can reach here (both
     # branchmap and repoview modules exist, but subsettable attribute
     # doesn't)
-    raise error.Abort((b"perfbranchmap not available with this Mercurial"),
-                      hint=b"use 2.5 or later")
+    raise error.Abort(
+        b"perfbranchmap not available with this Mercurial",
+        hint=b"use 2.5 or later",
+    )
+
 
 def getsvfs(repo):
     """Return appropriate object to access files under .hg/store
@@ -570,6 +668,7 b' def getsvfs(repo):'
     else:
         return getattr(repo, 'sopener')
 
+
 def getvfs(repo):
     """Return appropriate object to access files under .hg
     """
@@ -581,6 +680,7 b' def getvfs(repo):'
     else:
         return getattr(repo, 'opener')
 
+
 def repocleartagscachefunc(repo):
     """Return the function to clear tags cache according to repo internal API
     """
@@ -593,6 +693,7 b' def repocleartagscachefunc(repo):'
             # 98c867ac1330), and delattr() can't work in such case
             if b'_tagscache' in vars(repo):
                 del repo.__dict__[b'_tagscache']
+
         return clearcache
 
     repotags = safeattrsetter(repo, b'_tags', ignoremissing=True)
@@ -608,10 +709,12 b' def repocleartagscachefunc(repo):'
     # - repo.tags of such Mercurial isn't "callable", and repo.tags()
     #   in perftags() causes failure soon
     # - perf.py itself has been available since 1.1 (or eb240755386d)
-    raise error.Abort((b"tags API of this hg command is unknown"))
+    raise error.Abort(b"tags API of this hg command is unknown")
+
 
 # utilities to clear cache
 
+
 def clearfilecache(obj, attrname):
     unfiltered = getattr(obj, 'unfiltered', None)
     if unfiltered is not None:
@@ -620,23 +723,32 b' def clearfilecache(obj, attrname):'
         delattr(obj, attrname)
     obj._filecache.pop(attrname, None)
 
+
 def clearchangelog(repo):
     if repo is not repo.unfiltered():
         object.__setattr__(repo, r'_clcachekey', None)
         object.__setattr__(repo, r'_clcache', None)
     clearfilecache(repo.unfiltered(), 'changelog')
 
+
 # perf commands
 
+
 @command(b'perfwalk', formatteropts)
 def perfwalk(ui, repo, *pats, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     m = scmutil.match(repo[None], pats, {})
-    timer(lambda: len(list(repo.dirstate.walk(m, subrepos=[], unknown=True,
-                                              ignored=False))))
+    timer(
+        lambda: len(
+            list(
+                repo.dirstate.walk(m, subrepos=[], unknown=True, ignored=False)
+            )
+        )
+    )
     fm.end()
 
+
 @command(b'perfannotate', formatteropts)
 def perfannotate(ui, repo, f, **opts):
     opts = _byteskwargs(opts)
@@ -645,9 +757,12 b' def perfannotate(ui, repo, f, **opts):'
     timer(lambda: len(fc.annotate(True)))
     fm.end()
 
-@command(b'perfstatus',
-         [(b'u', b'unknown', False,
-           b'ask status to look for unknown files')] + formatteropts)
+
+@command(
+    b'perfstatus',
+    [(b'u', b'unknown', False, b'ask status to look for unknown files')]
+    + formatteropts,
+)
 def perfstatus(ui, repo, **opts):
     opts = _byteskwargs(opts)
     #m = match.always(repo.root, repo.getcwd())
@@ -657,6 +772,7 b' def perfstatus(ui, repo, **opts):'
     timer(lambda: sum(map(len, repo.status(unknown=opts[b'unknown']))))
     fm.end()
 
+
 @command(b'perfaddremove', formatteropts)
 def perfaddremove(ui, repo, **opts):
     opts = _byteskwargs(opts)
@@ -675,71 +791,89 b' def perfaddremove(ui, repo, **opts):'
         repo.ui.quiet = oldquiet
         fm.end()
 
+
 def clearcaches(cl):
     # behave somewhat consistently across internal API changes
     if util.safehasattr(cl, b'clearcaches'):
         cl.clearcaches()
     elif util.safehasattr(cl, b'_nodecache'):
         from mercurial.node import nullid, nullrev
+
         cl._nodecache = {nullid: nullrev}
         cl._nodepos = None
 
+
 @command(b'perfheads', formatteropts)
 def perfheads(ui, repo, **opts):
     """benchmark the computation of a changelog heads"""
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     cl = repo.changelog
+
     def s():
         clearcaches(cl)
+
     def d():
         len(cl.headrevs())
+
     timer(d, setup=s)
     fm.end()
 
-@command(b'perftags', formatteropts+
-        [
-            (b'', b'clear-revlogs', False, b'refresh changelog and manifest'),
-        ])
+
+@command(
+    b'perftags',
+    formatteropts
+    + [(b'', b'clear-revlogs', False, b'refresh changelog and manifest'),],
+)
 def perftags(ui, repo, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     repocleartagscache = repocleartagscachefunc(repo)
     clearrevlogs = opts[b'clear_revlogs']
+
     def s():
         if clearrevlogs:
             clearchangelog(repo)
             clearfilecache(repo.unfiltered(), 'manifest')
         repocleartagscache()
+
     def t():
         return len(repo.tags())
+
     timer(t, setup=s)
     fm.end()
 
+
 @command(b'perfancestors', formatteropts)
 def perfancestors(ui, repo, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     heads = repo.changelog.headrevs()
+
     def d():
         for a in repo.changelog.ancestors(heads):
             pass
+
     timer(d)
     fm.end()
 
+
 @command(b'perfancestorset', formatteropts)
 def perfancestorset(ui, repo, revset, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     revs = repo.revs(revset)
     heads = repo.changelog.headrevs()
+
     def d():
         s = repo.changelog.ancestors(heads)
         for rev in revs:
             rev in s
+
     timer(d)
     fm.end()
 
+
 @command(b'perfdiscovery', formatteropts, b'PATH')
 def perfdiscovery(ui, repo, path, **opts):
     """benchmark discovery between local repo and the peer at given path
@@ -750,30 +884,38 b' def perfdiscovery(ui, repo, path, **opts'
 
     def s():
         repos[1] = hg.peer(ui, opts, path)
+
     def d():
         setdiscovery.findcommonheads(ui, *repos)
+
     timer(d, setup=s)
     fm.end()
 
-@command(b'perfbookmarks', formatteropts +
-        [
-            (b'', b'clear-revlogs', False, b'refresh changelog and manifest'),
-        ])
+
+@command(
+    b'perfbookmarks',
+    formatteropts
+    + [(b'', b'clear-revlogs', False, b'refresh changelog and manifest'),],
+)
 def perfbookmarks(ui, repo, **opts):
     """benchmark parsing bookmarks from disk to memory"""
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
 
     clearrevlogs = opts[b'clear_revlogs']
+
     def s():
         if clearrevlogs:
             clearchangelog(repo)
         clearfilecache(repo, b'_bookmarks')
+
     def d():
         repo._bookmarks
+
     timer(d, setup=s)
     fm.end()
 
+
 @command(b'perfbundleread', formatteropts, b'BUNDLE')
 def perfbundleread(ui, repo, bundlepath, **opts):
     """Benchmark reading of bundle files.
@@ -863,25 +1005,32 b' def perfbundleread(ui, repo, bundlepath,'
         bundle = exchange.readbundle(ui, fh, bundlepath)
 
         if isinstance(bundle, changegroup.cg1unpacker):
-            benches.extend([
+            benches.extend(
+                [
                 (makebench(deltaiter), b'cg1 deltaiter()'),
                 (makebench(iterchunks), b'cg1 getchunks()'),
                 (makereadnbytes(8192), b'cg1 read(8k)'),
                 (makereadnbytes(16384), b'cg1 read(16k)'),
                 (makereadnbytes(32768), b'cg1 read(32k)'),
                 (makereadnbytes(131072), b'cg1 read(128k)'),
-            ])
+                ]
+            )
         elif isinstance(bundle, bundle2.unbundle20):
-            benches.extend([
+            benches.extend(
+                [
                 (makebench(forwardchunks), b'bundle2 forwardchunks()'),
                 (makebench(iterparts), b'bundle2 iterparts()'),
-                (makebench(iterpartsseekable), b'bundle2 iterparts() seekable'),
+                    (
+                        makebench(iterpartsseekable),
+                        b'bundle2 iterparts() seekable',
+                    ),
                 (makebench(seek), b'bundle2 part seek()'),
                 (makepartreadnbytes(8192), b'bundle2 part read(8k)'),
                 (makepartreadnbytes(16384), b'bundle2 part read(16k)'),
                 (makepartreadnbytes(32768), b'bundle2 part read(32k)'),
                 (makepartreadnbytes(131072), b'bundle2 part read(128k)'),
-            ])
+                ]
+            )
         elif isinstance(bundle, streamclone.streamcloneapplier):
             raise error.Abort(b'stream clone bundles not supported')
         else:
@@ -892,9 +1041,15 b' def perfbundleread(ui, repo, bundlepath,'
         timer(fn, title=title)
         fm.end()
 
-@command(b'perfchangegroupchangelog', formatteropts +
-         [(b'', b'cgversion', b'02', b'changegroup version'),
-          (b'r', b'rev', b'', b'revisions to add to changegroup')])
+
+@command(
+    b'perfchangegroupchangelog',
+    formatteropts
+    + [
+        (b'', b'cgversion', b'02', b'changegroup version'),
+        (b'r', b'rev', b'', b'revisions to add to changegroup'),
+    ],
+)
 def perfchangegroupchangelog(ui, repo, cgversion=b'02', rev=None, **opts):
     """Benchmark producing a changelog group for a changegroup.
 
@@ -923,77 +1078,96 b' def perfchangegroupchangelog(ui, repo, c'
 
     fm.end()
 
+
 @command(b'perfdirs', formatteropts)
 def perfdirs(ui, repo, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     dirstate = repo.dirstate
     b'a' in dirstate
+
     def d():
         dirstate.hasdir(b'a')
         del dirstate._map._dirs
+
     timer(d)
     fm.end()
 
+
 @command(b'perfdirstate', formatteropts)
 def perfdirstate(ui, repo, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     b"a" in repo.dirstate
+
     def d():
         repo.dirstate.invalidate()
         b"a" in repo.dirstate
+
     timer(d)
     fm.end()
 
+
 @command(b'perfdirstatedirs', formatteropts)
 def perfdirstatedirs(ui, repo, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     b"a" in repo.dirstate
+
     def d():
         repo.dirstate.hasdir(b"a")
         del repo.dirstate._map._dirs
+
     timer(d)
     fm.end()
 
+
 @command(b'perfdirstatefoldmap', formatteropts)
 def perfdirstatefoldmap(ui, repo, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     dirstate = repo.dirstate
     b'a' in dirstate
+
     def d():
         dirstate._map.filefoldmap.get(b'a')
         del dirstate._map.filefoldmap
+
     timer(d)
     fm.end()
 
+
 @command(b'perfdirfoldmap', formatteropts)
 def perfdirfoldmap(ui, repo, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     dirstate = repo.dirstate
     b'a' in dirstate
+
     def d():
         dirstate._map.dirfoldmap.get(b'a')
         del dirstate._map.dirfoldmap
         del dirstate._map._dirs
+
     timer(d)
     fm.end()
 
+
 @command(b'perfdirstatewrite', formatteropts)
 def perfdirstatewrite(ui, repo, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     ds = repo.dirstate
     b"a" in ds
+
     def d():
         ds._dirty = True
         ds.write(repo.currenttransaction())
+
     timer(d)
     fm.end()
 
+
 def _getmergerevs(repo, opts):
     """parse command argument to return rev involved in merge
 
@@ -1016,44 +1190,64 b' def _getmergerevs(repo, opts):'
         ancestor = wctx.ancestor(rctx)
     return (wctx, rctx, ancestor)
 
-@command(b'perfmergecalculate',
+
+@command(
+    b'perfmergecalculate',
          [
              (b'r', b'rev', b'.', b'rev to merge against'),
              (b'', b'from', b'', b'rev to merge from'),
              (b'', b'base', b'', b'the revision to use as base'),
-         ] + formatteropts)
+    ]
+    + formatteropts,
+)
 def perfmergecalculate(ui, repo, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
 
     wctx, rctx, ancestor = _getmergerevs(repo, opts)
+
     def d():
         # acceptremote is True because we don't want prompts in the middle of
         # our benchmark
-        merge.calculateupdates(repo, wctx, rctx, [ancestor], branchmerge=False,
-                               force=False, acceptremote=True,
-                               followcopies=True)
+        merge.calculateupdates(
+            repo,
+            wctx,
+            rctx,
+            [ancestor],
+            branchmerge=False,
+            force=False,
+            acceptremote=True,
+            followcopies=True,
+        )
+
     timer(d)
     fm.end()
 
-@command(b'perfmergecopies',
+
+@command(
+    b'perfmergecopies',
          [
              (b'r', b'rev', b'.', b'rev to merge against'),
              (b'', b'from', b'', b'rev to merge from'),
              (b'', b'base', b'', b'the revision to use as base'),
-         ] + formatteropts)
+    ]
+    + formatteropts,
+)
 def perfmergecopies(ui, repo, **opts):
     """measure runtime of `copies.mergecopies`"""
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     wctx, rctx, ancestor = _getmergerevs(repo, opts)
+
     def d():
         # acceptremote is True because we don't want prompts in the middle of
         # our benchmark
         copies.mergecopies(repo, wctx, rctx, ancestor)
+
     timer(d)
     fm.end()
 
+
 @command(b'perfpathcopies', [], b"REV REV")
 def perfpathcopies(ui, repo, rev1, rev2, **opts):
     """benchmark the copy tracing logic"""
@@ -1061,20 +1255,26 b' def perfpathcopies(ui, repo, rev1, rev2,'
     timer, fm = gettimer(ui, opts)
     ctx1 = scmutil.revsingle(repo, rev1, rev1)
     ctx2 = scmutil.revsingle(repo, rev2, rev2)
+
     def d():
         copies.pathcopies(ctx1, ctx2)
+
     timer(d)
     fm.end()
 
-@command(b'perfphases',
-         [(b'', b'full', False, b'include file reading time too'),
-          ], b"")
+
+@command(
+    b'perfphases',
+    [(b'', b'full', False, b'include file reading time too'),],
+    b"",
+)
 def perfphases(ui, repo, **opts):
     """benchmark phasesets computation"""
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     _phases = repo._phasecache
     full = opts.get(b'full')
+
     def d():
         phases = _phases
         if full:
@@ -1082,30 +1282,32 b' def perfphases(ui, repo, **opts):'
             phases = repo._phasecache
         phases.invalidate()
         phases.loadphaserevs(repo)
+
     timer(d)
     fm.end()
 
-@command(b'perfphasesremote',
-         [], b"[DEST]")
+
+@command(b'perfphasesremote', [], b"[DEST]")
 def perfphasesremote(ui, repo, dest=None, **opts):
     """benchmark time needed to analyse phases of the remote server"""
-    from mercurial.node import (
-        bin,
-    )
+    from mercurial.node import bin
     from mercurial import (
         exchange,
         hg,
         phases,
     )
+
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
 
     path = ui.paths.getpath(dest, default=(b'default-push', b'default'))
     if not path:
-        raise error.Abort((b'default repository not configured!'),
-                          hint=(b"see 'hg help config.paths'"))
+        raise error.Abort(
+            b'default repository not configured!',
+            hint=b"see 'hg help config.paths'",
+        )
     dest = path.pushloc or path.loc
-    ui.status((b'analysing phase of %s\n') % util.hidepassword(dest))
+    ui.status(b'analysing phase of %s\n' % util.hidepassword(dest))
     other = hg.peer(repo, opts, dest)
 
     # easier to perform discovery through the operation
@@ -1115,14 +1317,15 b' def perfphasesremote(ui, repo, dest=None'
     remotesubset = op.fallbackheads
 
     with other.commandexecutor() as e:
-        remotephases = e.callcommand(b'listkeys',
-                       {b'namespace': b'phases'}).result()
+        remotephases = e.callcommand(
+            b'listkeys', {b'namespace': b'phases'}
+        ).result()
     del other
     publishing = remotephases.get(b'publishing', False)
     if publishing:
-        ui.status((b'publishing: yes\n'))
+        ui.status(b'publishing: yes\n')
     else:
-        ui.status((b'publishing: no\n'))
+        ui.status(b'publishing: no\n')
 
     nodemap = repo.changelog.nodemap
     nonpublishroots = 0
@@ -1132,19 +1335,25 b' def perfphasesremote(ui, repo, dest=None'
         node = bin(nhex)
         if node in nodemap and int(phase):
             nonpublishroots += 1
-    ui.status((b'number of roots: %d\n') % len(remotephases))
-    ui.status((b'number of known non public roots: %d\n') % nonpublishroots)
+    ui.status(b'number of roots: %d\n' % len(remotephases))
+    ui.status(b'number of known non public roots: %d\n' % nonpublishroots)
+
     def d():
-        phases.remotephasessummary(repo,
-                                   remotesubset,
-                                   remotephases)
+        phases.remotephasessummary(repo, remotesubset, remotephases)
+
     timer(d)
     fm.end()
 
-@command(b'perfmanifest',[
+
+@command(
+    b'perfmanifest',
+    [
             (b'm', b'manifest-rev', False, b'Look up a manifest node revision'),
             (b'', b'clear-disk', False, b'clear on-disk caches too'),
-         ] + formatteropts, b'REV|NODE')
+    ]
+    + formatteropts,
+    b'REV|NODE',
+)
 def perfmanifest(ui, repo, rev, manifest_rev=False, clear_disk=False, **opts):
     """benchmark the time to read a manifest from disk and return a usable
     dict-like object
@@ -1169,25 +1378,32 b' def perfmanifest(ui, repo, rev, manifest'
                 else:
                     t = repo.manifestlog._revlog.lookup(rev)
             except ValueError:
-                raise error.Abort(b'manifest revision must be integer or full '
-                                  b'node')
+                raise error.Abort(
+                    b'manifest revision must be integer or full ' b'node'
+                )
+
     def d():
         repo.manifestlog.clearcaches(clear_persisted_data=clear_disk)
         repo.manifestlog[t].read()
+
     timer(d)
     fm.end()
 
+
 @command(b'perfchangeset', formatteropts)
 def perfchangeset(ui, repo, rev, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     n = scmutil.revsingle(repo, rev).node()
+
     def d():
         repo.changelog.read(n)
         #repo.changelog._cache = None
+
     timer(d)
     fm.end()
 
+
 @command(b'perfignore', formatteropts)
 def perfignore(ui, repo, **opts):
     """benchmark operation related to computing ignore"""
@@ -1205,10 +1421,15 b' def perfignore(ui, repo, **opts):'
     timer(runone, setup=setupone, title=b"load")
     fm.end()
 
-@command(b'perfindex', [
+
+@command(
+    b'perfindex',
+    [
             (b'', b'rev', [], b'revision to be looked up (default tip)'),
             (b'', b'no-lookup', None, b'do not revision lookup post creation'),
-         ] + formatteropts)
+    ]
+    + formatteropts,
+)
 def perfindex(ui, repo, **opts):
     """benchmark index creation time followed by a lookup
 
@@ -1231,6 +1452,7 b' def perfindex(ui, repo, **opts):'
     It is not currently possible to check for lookup of a missing node. For
     deeper lookup benchmarking, checkout the `perfnodemap` command."""
     import mercurial.revlog
+
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     mercurial.revlog._prereadsize = 2**24 # disable lazy parser in old hg
@@ -1249,20 +1471,28 b' def perfindex(ui, repo, **opts):'
     # find the filecache func directly
     # This avoid polluting the benchmark with the filecache logic
     makecl = unfi.__class__.changelog.func
+
     def setup():
         # probably not necessary, but for good measure
         clearchangelog(unfi)
+
     def d():
         cl = makecl(unfi)
         for n in nodes:
             cl.rev(n)
+
     timer(d, setup=setup)
     fm.end()
 
-@command(b'perfnodemap', [
+
+@command(
+    b'perfnodemap',
+    [
           (b'', b'rev', [], b'revision to be looked up (default tip)'),
           (b'', b'clear-caches', True, b'clear revlog cache between calls'),
-    ] + formatteropts)
+    ]
+    + formatteropts,
+)
 def perfnodemap(ui, repo, **opts):
     """benchmark the time necessary to look up revision from a cold nodemap
 
@@ -1281,6 +1511,7 b' def perfnodemap(ui, repo, **opts):'
     hexlookup, prefix lookup and missing lookup would also be valuable.
     """
     import mercurial.revlog
+
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     mercurial.revlog._prereadsize = 2**24 # disable lazy parser in old hg
@@ -1298,6 +1529,7 b' def perfnodemap(ui, repo, **opts):'
 
     # use a list to pass reference to a nodemap from one closure to the next
     nodeget = [None]
+
     def setnodeget():
         # probably not necessary, but for good measure
         clearchangelog(unfi)
@@ -1310,28 +1542,35 b' def perfnodemap(ui, repo, **opts):'
 
     setup = None
     if clearcaches:
+
         def setup():
             setnodeget()
+
     else:
         setnodeget()
         d() # prewarm the data structure
     timer(d, setup=setup)
     fm.end()
 
+
 @command(b'perfstartup', formatteropts)
 def perfstartup(ui, repo, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
+
     def d():
         if os.name != r'nt':
-            os.system(b"HGRCPATH= %s version -q > /dev/null" %
-                      fsencode(sys.argv[0]))
+            os.system(
+                b"HGRCPATH= %s version -q > /dev/null" % fsencode(sys.argv[0])
+            )
         else:
             os.environ[r'HGRCPATH'] = r' '
             os.system(r"%s version -q > NUL" % sys.argv[0])
+
     timer(d)
     fm.end()
 
+
 @command(b'perfparents', formatteropts)
 def perfparents(ui, repo, **opts):
     """benchmark the time necessary to fetch one changeset's parents.
@@ -1350,33 +1589,42 b' def perfparents(ui, repo, **opts):'
         raise error.Abort(b"repo needs %d commits for this test" % count)
     repo = repo.unfiltered()
     nl = [repo.changelog.node(i) for i in _xrange(count)]
+
     def d():
         for n in nl:
             repo.changelog.parents(n)
+
     timer(d)
     fm.end()
 
+
 @command(b'perfctxfiles', formatteropts)
 def perfctxfiles(ui, repo, x, **opts):
     opts = _byteskwargs(opts)
     x = int(x)
     timer, fm = gettimer(ui, opts)
+
     def d():
         len(repo[x].files())
+
     timer(d)
     fm.end()
 
+
 @command(b'perfrawfiles', formatteropts)
 def perfrawfiles(ui, repo, x, **opts):
     opts = _byteskwargs(opts)
     x = int(x)
     timer, fm = gettimer(ui, opts)
     cl = repo.changelog
+
     def d():
         len(cl.read(x)[3])
+
     timer(d)
     fm.end()
 
+
 @command(b'perflookup', formatteropts)
 def perflookup(ui, repo, rev, **opts):
     opts = _byteskwargs(opts)
@@ -1384,10 +1632,15 b' def perflookup(ui, repo, rev, **opts):'
     timer(lambda: len(repo.lookup(rev)))
     fm.end()
 
-@command(b'perflinelogedits',
-         [(b'n', b'edits', 10000, b'number of edits'),
+
+@command(
+    b'perflinelogedits',
+    [
+        (b'n', b'edits', 10000, b'number of edits'),
           (b'', b'max-hunk-lines', 10, b'max lines in a hunk'),
-          ], norepo=True)
+    ],
+    norepo=True,
+)
 def perflinelogedits(ui, **opts):
     from mercurial import linelog
 
@@ -1418,6 +1671,7 b' def perflinelogedits(ui, **opts):'
     timer(d)
     fm.end()
 
+
 @command(b'perfrevrange', formatteropts)
 def perfrevrange(ui, repo, *specs, **opts):
     opts = _byteskwargs(opts)
@@ -1426,34 +1680,44 b' def perfrevrange(ui, repo, *specs, **opt'
     timer(lambda: len(revrange(repo, specs)))
     fm.end()
 
+
 @command(b'perfnodelookup', formatteropts)
 def perfnodelookup(ui, repo, rev, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     import mercurial.revlog
+
     mercurial.revlog._prereadsize = 2**24 # disable lazy parser in old hg
     n = scmutil.revsingle(repo, rev).node()
     cl = mercurial.revlog.revlog(getsvfs(repo), b"00changelog.i")
+
     def d():
         cl.rev(n)
         clearcaches(cl)
+
     timer(d)
     fm.end()
 
-@command(b'perflog',
-         [(b'', b'rename', False, b'ask log to follow renames')
-         ] + formatteropts)
+
+@command(
+    b'perflog',
+    [(b'', b'rename', False, b'ask log to follow renames')] + formatteropts,
+)
 def perflog(ui, repo, rev=None, **opts):
     opts = _byteskwargs(opts)
     if rev is None:
         rev=[]
     timer, fm = gettimer(ui, opts)
     ui.pushbuffer()
-    timer(lambda: commands.log(ui, repo, rev=rev, date=b'', user=b'',
-                               copies=opts.get(b'rename')))
+    timer(
+        lambda: commands.log(
+            ui, repo, rev=rev, date=b'', user=b'', copies=opts.get(b'rename')
+        )
+    )
     ui.popbuffer()
     fm.end()
 
+
 @command(b'perfmoonwalk', formatteropts)
 def perfmoonwalk(ui, repo, **opts):
     """benchmark walking the changelog backwards
@@ -1462,21 +1726,27 b' def perfmoonwalk(ui, repo, **opts):'
     """
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
+
     def moonwalk():
         for i in repo.changelog.revs(start=(len(repo) - 1), stop=-1):
             ctx = repo[i]
             ctx.branch() # read changelog data (in addition to the index)
+
     timer(moonwalk)
     fm.end()
 
-@command(b'perftemplating',
-         [(b'r', b'rev', [], b'revisions to run the template on'),
-          ] + formatteropts)
+
+@command(
+    b'perftemplating',
+    [(b'r', b'rev', [], b'revisions to run the template on'),] + formatteropts,
+)
 def perftemplating(ui, repo, testedtemplate=None, **opts):
     """test the rendering time of a given template"""
     if makelogtemplater is None:
-        raise error.Abort((b"perftemplating not available with this Mercurial"),
-                          hint=b"use 4.3 or later")
+        raise error.Abort(
+            b"perftemplating not available with this Mercurial",
+            hint=b"use 4.3 or later",
+        )
 
     opts = _byteskwargs(opts)
 
@@ -1488,11 +1758,14 b' def perftemplating(ui, repo, testedtempl'
         revs = [b'all()']
     revs = list(scmutil.revrange(repo, revs))
 
-    defaulttemplate = (b'{date|shortdate} [{rev}:{node|short}]'
-                       b' {author|person}: {desc|firstline}\n')
+    defaulttemplate = (
+        b'{date|shortdate} [{rev}:{node|short}]'
+        b' {author|person}: {desc|firstline}\n'
+    )
     if testedtemplate is None:
         testedtemplate = defaulttemplate
     displayer = makelogtemplater(nullui, repo, testedtemplate)
+
     def format():
         for r in revs:
             ctx = repo[r]
@@ -1503,6 +1776,7 b' def perftemplating(ui, repo, testedtempl'
     timer(format)
     fm.end()
 
+
 def _displaystats(ui, opts, entries, data):
     pass
     # use a second formatter because the data are quite different, not sure
@@ -1549,12 +1823,16 b' def _displaystats(ui, opts, entries, dat'
             fm.plain('%s: %s\n' % (l, stats[l]))
     fm.end()
 
-@command(b'perfhelper-mergecopies', formatteropts +
-         [
+
+@command(
+    b'perfhelper-mergecopies',
+    formatteropts
+    + [
           (b'r', b'revs', [], b'restrict search to these revisions'),
           (b'', b'timing', False, b'provides extra data (costly)'),
           (b'', b'stats', False, b'provides statistic about the measured data'),
-         ])
+    ],
+)
 def perfhelpermergecopies(ui, repo, revs=[], **opts):
     """find statistics about potential parameters for `perfmergecopies`
 
@@ -1591,8 +1869,11 b' def perfhelpermergecopies(ui, repo, revs'
         ("total.time", "%(time)12.3f"),
         ]
     if not dotiming:
-        output_template = [i for i in output_template
-                           if not ('time' in i[0] or 'renames' in i[0])]
+        output_template = [
+            i
+            for i in output_template
+            if not ('time' in i[0] or 'renames' in i[0])
+        ]
     header_names = [h for (h, v) in output_template]
     output = ' '.join([v for (h, v) in output_template]) + '\n'
     header = ' '.join(['%12s'] * len(header_names)) + '\n'
@@ -1634,27 +1915,19 b' def perfhelpermergecopies(ui, repo, revs'
             }
             if dostats:
                 if p1missing:
-                    alldata['nbrevs'].append((
-                        data['p1.nbrevs'],
-                        b.hex(),
-                        p1.hex()
-                    ))
-                    alldata['nbmissingfiles'].append((
-                        data['p1.nbmissingfiles'],
-                        b.hex(),
-                        p1.hex()
-                    ))
+                    alldata['nbrevs'].append(
+                        (data['p1.nbrevs'], b.hex(), p1.hex())
+                    )
+                    alldata['nbmissingfiles'].append(
+                        (data['p1.nbmissingfiles'], b.hex(), p1.hex())
+                    )
                 if p2missing:
-                    alldata['nbrevs'].append((
-                        data['p2.nbrevs'],
-                        b.hex(),
-                        p2.hex()
-                    ))
-                    alldata['nbmissingfiles'].append((
-                        data['p2.nbmissingfiles'],
-                        b.hex(),
-                        p2.hex()
-                    ))
+                    alldata['nbrevs'].append(
+                        (data['p2.nbrevs'], b.hex(), p2.hex())
+                    )
+                    alldata['nbmissingfiles'].append(
+                        (data['p2.nbmissingfiles'], b.hex(), p2.hex())
+                    )
             if dotiming:
                 begin = util.timer()
                 mergedata = copies.mergecopies(repo, p1, p2, b)
@@ -1682,40 +1955,31 b' def perfhelpermergecopies(ui, repo, revs'
 
                 if dostats:
                     if p1missing:
-                        alldata['parentnbrenames'].append((
-                            data['p1.renamedfiles'],
-                            b.hex(),
-                            p1.hex()
-                        ))
-                        alldata['parenttime'].append((
-                            data['p1.time'],
-                            b.hex(),
-                            p1.hex()
-                        ))
+                        alldata['parentnbrenames'].append(
+                            (data['p1.renamedfiles'], b.hex(), p1.hex())
+                        )
+                        alldata['parenttime'].append(
+                            (data['p1.time'], b.hex(), p1.hex())
+                        )
                     if p2missing:
-                        alldata['parentnbrenames'].append((
-                            data['p2.renamedfiles'],
-                            b.hex(),
-                            p2.hex()
-                        ))
-                        alldata['parenttime'].append((
-                            data['p2.time'],
-                            b.hex(),
-                            p2.hex()
-                        ))
+                        alldata['parentnbrenames'].append(
+                            (data['p2.renamedfiles'], b.hex(), p2.hex())
+                        )
+                        alldata['parenttime'].append(
+                            (data['p2.time'], b.hex(), p2.hex())
+                        )
                     if p1missing or p2missing:
-                        alldata['totalnbrenames'].append((
+                        alldata['totalnbrenames'].append(
+                            (
                             data['nbrenamedfiles'],
                             b.hex(),
                             p1.hex(),
-                            p2.hex()
-                        ))
-                        alldata['totaltime'].append((
-                            data['time'],
-                            b.hex(),
-                            p1.hex(),
-                            p2.hex()
-                        ))
+                                p2.hex(),
+                            )
+                        )
+                        alldata['totaltime'].append(
+                            (data['time'], b.hex(), p1.hex(), p2.hex())
+                        )
             fm.startitem()
             fm.data(**data)
             # make node pretty for the human output
@@ -1734,20 +1998,24 b' def perfhelpermergecopies(ui, repo, revs'
             ('nbmissingfiles', 'number of missing files at head'),
         ]
         if dotiming:
-            entries.append(('parentnbrenames',
-                            'rename from one parent to base'))
+            entries.append(
+                ('parentnbrenames', 'rename from one parent to base')
+            )
             entries.append(('totalnbrenames', 'total number of renames'))
             entries.append(('parenttime', 'time for one parent'))
             entries.append(('totaltime', 'time for both parents'))
         _displaystats(ui, opts, entries, alldata)
 
 
-@command(b'perfhelper-pathcopies', formatteropts +
-         [
+@command(
+    b'perfhelper-pathcopies',
+    formatteropts
+    + [
           (b'r', b'revs', [], b'restrict search to these revisions'),
           (b'', b'timing', False, b'provides extra data (costly)'),
           (b'', b'stats', False, b'provides statistic about the measured data'),
-         ])
+    ],
+)
 def perfhelperpathcopies(ui, repo, revs=[], **opts):
     """find statistic about potential parameters for the `perftracecopies`
 
@@ -1769,23 +2037,32 b' def perfhelperpathcopies(ui, repo, revs='
 
     if dotiming:
         header = '%12s %12s %12s %12s %12s %12s\n'
-        output = ("%(source)12s %(destination)12s "
+        output = (
+            "%(source)12s %(destination)12s "
                   "%(nbrevs)12d %(nbmissingfiles)12d "
-                  "%(nbrenamedfiles)12d %(time)18.5f\n")
-        header_names = ("source", "destination", "nb-revs", "nb-files",
-                        "nb-renames", "time")
+            "%(nbrenamedfiles)12d %(time)18.5f\n"
+        )
+        header_names = (
+            "source",
+            "destination",
+            "nb-revs",
+            "nb-files",
+            "nb-renames",
+            "time",
+        )
         fm.plain(header % header_names)
     else:
         header = '%12s %12s %12s %12s\n'
-        output = ("%(source)12s %(destination)12s "
-                  "%(nbrevs)12d %(nbmissingfiles)12d\n")
+        output = (
+            "%(source)12s %(destination)12s "
+            "%(nbrevs)12d %(nbmissingfiles)12d\n"
+        )
         fm.plain(header % ("source", "destination", "nb-revs", "nb-files"))
 
     if not revs:
         revs = ['all()']
     revs = scmutil.revrange(repo, revs)
 
-
     if dostats:
         alldata = {
             'nbrevs': [],
@@ -1815,16 +2092,12 b' def perfhelperpathcopies(ui, repo, revs='
                     b'nbmissingfiles': len(missing),
                 }
                 if dostats:
-                    alldata['nbrevs'].append((
-                        data['nbrevs'],
-                        base.hex(),
-                        parent.hex(),
-                    ))
-                    alldata['nbmissingfiles'].append((
-                        data['nbmissingfiles'],
-                        base.hex(),
-                        parent.hex(),
-                    ))
+                    alldata['nbrevs'].append(
+                        (data['nbrevs'], base.hex(), parent.hex(),)
+                    )
+                    alldata['nbmissingfiles'].append(
+                        (data['nbmissingfiles'], base.hex(), parent.hex(),)
+                    )
                 if dotiming:
                     begin = util.timer()
                     renames = copies.pathcopies(base, parent)
@@ -1833,16 +2106,12 b' def perfhelperpathcopies(ui, repo, revs='
                     data['time'] = end - begin
                     data['nbrenamedfiles'] = len(renames)
                     if dostats:
-                        alldata['time'].append((
-                            data['time'],
-                            base.hex(),
-                            parent.hex(),
-                        ))
-                        alldata['nbrenames'].append((
-                            data['nbrenamedfiles'],
-                            base.hex(),
-                            parent.hex(),
-                        ))
+                        alldata['time'].append(
+                            (data['time'], base.hex(), parent.hex(),)
+                        )
+                        alldata['nbrenames'].append(
+                            (data['nbrenamedfiles'], base.hex(), parent.hex(),)
+                        )
                 fm.startitem()
                 fm.data(**data)
                 out = data.copy()
@@ -1860,11 +2129,11 b' def perfhelperpathcopies(ui, repo, revs='
             ('nbmissingfiles', 'number of missing files at head'),
         ]
         if dotiming:
-            entries.append(('nbrenames',
-                            'renamed files'))
+            entries.append(('nbrenames', 'renamed files'))
             entries.append(('time', 'time'))
         _displaystats(ui, opts, entries, alldata)
 
+
 @command(b'perfcca', formatteropts)
 def perfcca(ui, repo, **opts):
     opts = _byteskwargs(opts)
@@ -1872,16 +2141,20 b' def perfcca(ui, repo, **opts):'
     timer(lambda: scmutil.casecollisionauditor(ui, False, repo.dirstate))
     fm.end()
 
+
 @command(b'perffncacheload', formatteropts)
 def perffncacheload(ui, repo, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     s = repo.store
+
     def d():
         s.fncache._load()
+
     timer(d)
     fm.end()
 
+
 @command(b'perffncachewrite', formatteropts)
 def perffncachewrite(ui, repo, **opts):
     opts = _byteskwargs(opts)
@@ -1891,26 +2164,32 b' def perffncachewrite(ui, repo, **opts):'
     s.fncache._load()
     tr = repo.transaction(b'perffncachewrite')
     tr.addbackup(b'fncache')
+
     def d():
         s.fncache._dirty = True
         s.fncache.write(tr)
+
     timer(d)
     tr.close()
     lock.release()
     fm.end()
 
+
 @command(b'perffncacheencode', formatteropts)
 def perffncacheencode(ui, repo, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     s = repo.store
     s.fncache._load()
+
     def d():
         for p in s.fncache.entries:
             s.encode(p)
+
     timer(d)
     fm.end()
 
+
 def _bdiffworker(q, blocks, xdiff, ready, done):
     while not done.is_set():
         pair = q.get()
@@ -1927,6 +2206,7 b' def _bdiffworker(q, blocks, xdiff, ready'
         with ready:
             ready.wait()
 
+
 def _manifestrevision(repo, mnode):
     ml = repo.manifestlog
 
@@ -1937,15 +2217,25 b' def _manifestrevision(repo, mnode):'
 
     return store.revision(mnode)
 
-@command(b'perfbdiff', revlogopts + formatteropts + [
-    (b'', b'count', 1, b'number of revisions to test (when using --startrev)'),
+
+@command(
+    b'perfbdiff',
+    revlogopts
+    + formatteropts
+    + [
+        (
+            b'',
+            b'count',
+            1,
+            b'number of revisions to test (when using --startrev)',
+        ),
     (b'', b'alldata', False, b'test bdiffs for all associated revisions'),
     (b'', b'threads', 0, b'number of thread to use (disable with 0)'),
     (b'', b'blocks', False, b'test computing diffs into blocks'),
     (b'', b'xdiff', False, b'use xdiff algorithm'),
     ],
-
-    b'-c|-m|FILE REV')
+    b'-c|-m|FILE REV',
+)
 def perfbdiff(ui, repo, file_, rev=None, count=None, threads=0, **opts):
     """benchmark a bdiff between revisions
 
@@ -2001,6 +2291,7 b' def perfbdiff(ui, repo, file_, rev=None,'
 
     withthreads = threads > 0
     if not withthreads:
+
         def d():
             for pair in textpairs:
                 if xdiff:
@@ -2009,6 +2300,7 b' def perfbdiff(ui, repo, file_, rev=None,'
                     mdiff.bdiff.blocks(*pair)
                 else:
                     mdiff.textdiff(*pair)
+
     else:
         q = queue()
         for i in _xrange(threads):
@@ -2016,9 +2308,11 b' def perfbdiff(ui, repo, file_, rev=None,'
         ready = threading.Condition()
         done = threading.Event()
         for i in _xrange(threads):
-            threading.Thread(target=_bdiffworker,
-                             args=(q, blocks, xdiff, ready, done)).start()
+            threading.Thread(
+                target=_bdiffworker, args=(q, blocks, xdiff, ready, done)
+            ).start()
         q.join()
+
         def d():
             for pair in textpairs:
                 q.put(pair)
@@ -2027,6 +2321,7 b' def perfbdiff(ui, repo, file_, rev=None,'
             with ready:
                 ready.notify_all()
             q.join()
+
     timer, fm = gettimer(ui, opts)
     timer(d)
     fm.end()
@@ -2038,10 +2333,22 b' def perfbdiff(ui, repo, file_, rev=None,'
         with ready:
             ready.notify_all()
 
-@command(b'perfunidiff', revlogopts + formatteropts + [
-    (b'', b'count', 1, b'number of revisions to test (when using --startrev)'),
+
+@command(
+    b'perfunidiff',
+    revlogopts
+    + formatteropts
+    + [
+        (
+            b'',
+            b'count',
+            1,
+            b'number of revisions to test (when using --startrev)',
+        ),
     (b'', b'alldata', False, b'test unidiffs for all associated revisions'),
-    ], b'-c|-m|FILE REV')
+    ],
+    b'-c|-m|FILE REV',
+)
 def perfunidiff(ui, repo, file_, rev=None, count=None, **opts):
     """benchmark a unified diff between revisions
 
@@ -2096,14 +2403,17 b' def perfunidiff(ui, repo, file_, rev=Non'
         for left, right in textpairs:
             # The date strings don't matter, so we pass empty strings.
             headerlines, hunks = mdiff.unidiff(
-                left, b'', right, b'', b'left', b'right', binary=False)
+                left, b'', right, b'', b'left', b'right', binary=False
+            )
             # consume iterators in roughly the way patch.py does
             b'\n'.join(headerlines)
             b''.join(sum((list(hlines) for hrange, hlines in hunks), []))
+
     timer, fm = gettimer(ui, opts)
     timer(d)
     fm.end()
 
+
 @command(b'perfdiffwd', formatteropts)
 def perfdiffwd(ui, repo, **opts):
     """Profile diff of working directory changes"""
@@ -2117,17 +2427,19 b' def perfdiffwd(ui, repo, **opts):'
 
     for diffopt in ('', 'w', 'b', 'B', 'wB'):
         opts = dict((options[c], b'1') for c in diffopt)
+
         def d():
             ui.pushbuffer()
             commands.diff(ui, repo, **opts)
             ui.popbuffer()
+
         diffopt = diffopt.encode('ascii')
         title = b'diffopts: %s' % (diffopt and (b'-' + diffopt) or b'none')
         timer(d, title=title)
     fm.end()
 
-@command(b'perfrevlogindex', revlogopts + formatteropts,
-         b'-c|-m|FILE')
+
+@command(b'perfrevlogindex', revlogopts + formatteropts, b'-c|-m|FILE')
 def perfrevlogindex(ui, repo, file_=None, **opts):
     """Benchmark operations against a revlog index.
 
@@ -2150,7 +2462,7 b' def perfrevlogindex(ui, repo, file_=None'
         revlogio = revlog.revlogio()
         inline = header & (1 << 16)
     else:
-        raise error.Abort((b'unsupported revlog version: %d') % version)
+        raise error.Abort(b'unsupported revlog version: %d' % version)
 
     rllen = len(rl)
 
@@ -2221,22 +2533,26 b' def perfrevlogindex(ui, repo, file_=None'
         (lambda: resolvenode(node75), b'look up node at 3/4 len'),
         (lambda: resolvenode(node100), b'look up node at tip'),
         # 2x variation is to measure caching impact.
-        (lambda: resolvenodes(allnodes),
-         b'look up all nodes (forward)'),
-        (lambda: resolvenodes(allnodes, 2),
-         b'look up all nodes 2x (forward)'),
-        (lambda: resolvenodes(allnodesrev),
-         b'look up all nodes (reverse)'),
-        (lambda: resolvenodes(allnodesrev, 2),
-         b'look up all nodes 2x (reverse)'),
-        (lambda: getentries(allrevs),
-         b'retrieve all index entries (forward)'),
-        (lambda: getentries(allrevs, 2),
-         b'retrieve all index entries 2x (forward)'),
-        (lambda: getentries(allrevsrev),
-         b'retrieve all index entries (reverse)'),
-        (lambda: getentries(allrevsrev, 2),
-         b'retrieve all index entries 2x (reverse)'),
+        (lambda: resolvenodes(allnodes), b'look up all nodes (forward)'),
+        (lambda: resolvenodes(allnodes, 2), b'look up all nodes 2x (forward)'),
+        (lambda: resolvenodes(allnodesrev), b'look up all nodes (reverse)'),
+        (
+            lambda: resolvenodes(allnodesrev, 2),
+            b'look up all nodes 2x (reverse)',
+        ),
+        (lambda: getentries(allrevs), b'retrieve all index entries (forward)'),
+        (
+            lambda: getentries(allrevs, 2),
+            b'retrieve all index entries 2x (forward)',
+        ),
+        (
+            lambda: getentries(allrevsrev),
+            b'retrieve all index entries (reverse)',
+        ),
+        (
+            lambda: getentries(allrevsrev, 2),
+            b'retrieve all index entries 2x (reverse)',
+        ),
     ]
 
     for fn, title in benches:
@@ -2244,13 +2560,21 b' def perfrevlogindex(ui, repo, file_=None'
         timer(fn, title=title)
         fm.end()
 
-@command(b'perfrevlogrevisions', revlogopts + formatteropts +
-         [(b'd', b'dist', 100, b'distance between the revisions'),
+
+@command(
+    b'perfrevlogrevisions',
+    revlogopts
+    + formatteropts
+    + [
+        (b'd', b'dist', 100, b'distance between the revisions'),
           (b's', b'startrev', 0, b'revision to start reading at'),
-          (b'', b'reverse', False, b'read in reverse')],
-         b'-c|-m|FILE')
-def perfrevlogrevisions(ui, repo, file_=None, startrev=0, reverse=False,
-                        **opts):
+        (b'', b'reverse', False, b'read in reverse'),
+    ],
+    b'-c|-m|FILE',
+)
+def perfrevlogrevisions(
+    ui, repo, file_=None, startrev=0, reverse=False, **opts
+):
     """Benchmark reading a series of revisions from a revlog.
 
     By default, we read every ``-d/--dist`` revision from 0 to tip of
@@ -2286,8 +2610,13 b' def perfrevlogrevisions(ui, repo, file_='
     timer(d)
     fm.end()
 
-@command(b'perfrevlogwrite', revlogopts + formatteropts +
-         [(b's', b'startrev', 1000, b'revision to start writing at'),
+
+@command(
+    b'perfrevlogwrite',
+    revlogopts
+    + formatteropts
+    + [
+        (b's', b'startrev', 1000, b'revision to start writing at'),
           (b'', b'stoprev', -1, b'last revision to write'),
           (b'', b'count', 3, b'number of passes to perform'),
           (b'', b'details', False, b'print timing for every revisions tested'),
@@ -2295,7 +2624,8 b' def perfrevlogrevisions(ui, repo, file_='
           (b'', b'lazydeltabase', True, b'try the provided delta first'),
           (b'', b'clear-caches', True, b'clear revlog cache between calls'),
          ],
-         b'-c|-m|FILE')
+    b'-c|-m|FILE',
+)
 def perfrevlogwrite(ui, repo, file_=None, startrev=1000, stoprev=-1, **opts):
     """Benchmark writing a series of revisions to a revlog.
 
@@ -2329,8 +2659,13 b' def perfrevlogwrite(ui, repo, file_=None'
     lazydeltabase = opts['lazydeltabase']
     source = opts['source']
     clearcaches = opts['clear_caches']
-    validsource = (b'full', b'parent-1', b'parent-2', b'parent-smallest',
-                   b'storage')
+    validsource = (
+        b'full',
+        b'parent-1',
+        b'parent-2',
+        b'parent-smallest',
+        b'storage',
+    )
     if source not in validsource:
         raise error.Abort('invalid source type: %s' % source)
 
@@ -2340,9 +2675,16 b' def perfrevlogwrite(ui, repo, file_=None'
         raise error.Abort('invalide run count: %d' % count)
     allresults = []
     for c in range(count):
-        timing = _timeonewrite(ui, rl, source, startrev, stoprev, c + 1,
+        timing = _timeonewrite(
+            ui,
+            rl,
+            source,
+            startrev,
+            stoprev,
+            c + 1,
                                lazydeltabase=lazydeltabase,
-                               clearcaches=clearcaches)
+            clearcaches=clearcaches,
+        )
         allresults.append(timing)
 
     ### consolidate the results in a single list
@@ -2396,20 +2738,37 b' def perfrevlogwrite(ui, repo, file_=None'
     # for now
     totaltime = []
     for item in allresults:
-        totaltime.append((sum(x[1][0] for x in item),
+        totaltime.append(
+            (
+                sum(x[1][0] for x in item),
                           sum(x[1][1] for x in item),
-                          sum(x[1][2] for x in item),)
+                sum(x[1][2] for x in item),
+            )
         )
-    formatone(fm, totaltime, title="total time (%d revs)" % resultcount,
-              displayall=displayall)
+    formatone(
+        fm,
+        totaltime,
+        title="total time (%d revs)" % resultcount,
+        displayall=displayall,
+    )
     fm.end()
 
+
 class _faketr(object):
     def add(s, x, y, z=None):
         return None
 
-def _timeonewrite(ui, orig, source, startrev, stoprev, runidx=None,
-                  lazydeltabase=True, clearcaches=True):
+
+def _timeonewrite(
+    ui,
+    orig,
+    source,
+    startrev,
+    stoprev,
+    runidx=None,
+    lazydeltabase=True,
+    clearcaches=True,
+):
     timings = []
     tr = _faketr()
     with _temprevlog(ui, orig, startrev) as dest:
@@ -2422,13 +2781,18 b' def _timeonewrite(ui, orig, source, star'
          # Support both old and new progress API
         if util.safehasattr(ui, 'makeprogress'):
             progress = ui.makeprogress(topic, unit='revs', total=total)
+
             def updateprogress(pos):
                 progress.update(pos)
+
             def completeprogress():
                 progress.complete()
+
         else:
+
             def updateprogress(pos):
                 ui.progress(topic, pos, unit='revs', total=total)
+
             def completeprogress():
                 ui.progress(topic, None, unit='revs', total=total)
 
@@ -2445,6 +2809,7 b' def _timeonewrite(ui, orig, source, star'
         completeprogress()
     return timings
 
+
 def _getrevisionseed(orig, rev, tr, source):
     from mercurial.node import nullid
 
@@ -2481,8 +2846,11 b' def _getrevisionseed(orig, rev, tr, sour'
         baserev = orig.deltaparent(rev)
         cachedelta = (baserev, orig.revdiff(orig.node(baserev), rev))
 
-    return ((text, tr, linkrev, p1, p2),
-            {'node': node, 'flags': flags, 'cachedelta': cachedelta})
+    return (
+        (text, tr, linkrev, p1, p2),
+        {'node': node, 'flags': flags, 'cachedelta': cachedelta},
+    )
+
 
 @contextlib.contextmanager
 def _temprevlog(ui, orig, truncaterev):
@@ -2523,9 +2891,9 b' def _temprevlog(ui, orig, truncaterev):'
         vfs = vfsmod.vfs(tmpdir)
         vfs.options = getattr(orig.opener, 'options', None)
 
-        dest = revlog.revlog(vfs,
-                             indexfile=indexname,
-                             datafile=dataname, **revlogkwargs)
+        dest = revlog.revlog(
+            vfs, indexfile=indexname, datafile=dataname, **revlogkwargs
+        )
         if dest._inline:
             raise error.Abort('not supporting inline revlog (yet)')
         # make sure internals are initialized
@@ -2535,10 +2903,17 b' def _temprevlog(ui, orig, truncaterev):'
     finally:
         shutil.rmtree(tmpdir, True)
 
-@command(b'perfrevlogchunks', revlogopts + formatteropts +
-         [(b'e', b'engines', b'', b'compression engines to use'),
-          (b's', b'startrev', 0, b'revision to start at')],
-         b'-c|-m|FILE')
+
+@command(
+    b'perfrevlogchunks',
+    revlogopts
+    + formatteropts
+    + [
+        (b'e', b'engines', b'', b'compression engines to use'),
+        (b's', b'startrev', 0, b'revision to start at'),
+    ],
+    b'-c|-m|FILE',
+)
 def perfrevlogchunks(ui, repo, file_=None, engines=None, startrev=0, **opts):
     """Benchmark operations on revlog chunks.
 
@@ -2645,17 +3020,26 b' def perfrevlogchunks(ui, repo, file_=Non'
 
     for engine in sorted(engines):
         compressor = util.compengines[engine].revlogcompressor()
-        benches.append((functools.partial(docompress, compressor),
-                        b'compress w/ %s' % engine))
+        benches.append(
+            (
+                functools.partial(docompress, compressor),
+                b'compress w/ %s' % engine,
+            )
+        )
 
     for fn, title in benches:
         timer, fm = gettimer(ui, opts)
         timer(fn, title=title)
         fm.end()
 
-@command(b'perfrevlogrevision', revlogopts + formatteropts +
-         [(b'', b'cache', False, b'use caches instead of clearing')],
-         b'-c|-m|FILE REV')
+
+@command(
+    b'perfrevlogrevision',
+    revlogopts
+    + formatteropts
+    + [(b'', b'cache', False, b'use caches instead of clearing')],
+    b'-c|-m|FILE REV',
+)
 def perfrevlogrevision(ui, repo, file_, rev=None, cache=None, **opts):
     """Benchmark obtaining a revlog revision.
 
@@ -2777,22 +3161,30 b' def perfrevlogrevision(ui, repo, file_, '
         slicing = (lambda: doslice(r, chain, size), b'slice-sparse-chain')
         benches.append(slicing)
 
-    benches.extend([
+    benches.extend(
+        [
         (lambda: dorawchunks(data, slicedchain), b'rawchunks'),
         (lambda: dodecompress(rawchunks), b'decompress'),
         (lambda: dopatch(text, bins), b'patch'),
         (lambda: dohash(text), b'hash'),
-    ])
+        ]
+    )
 
     timer, fm = gettimer(ui, opts)
     for fn, title in benches:
         timer(fn, title=title)
     fm.end()
 
-@command(b'perfrevset',
-         [(b'C', b'clear', False, b'clear volatile cache between each call.'),
-          (b'', b'contexts', False, b'obtain changectx for each revision')]
-         + formatteropts, b"REVSET")
+
+@command(
+    b'perfrevset',
+    [
+        (b'C', b'clear', False, b'clear volatile cache between each call.'),
+        (b'', b'contexts', False, b'obtain changectx for each revision'),
+    ]
+    + formatteropts,
+    b"REVSET",
+)
 def perfrevset(ui, repo, expr, clear=False, contexts=False, **opts):
     """benchmark the execution time of a revset
 
@@ -2802,19 +3194,26 b' def perfrevset(ui, repo, expr, clear=Fal'
     opts = _byteskwargs(opts)
 
     timer, fm = gettimer(ui, opts)
+
     def d():
         if clear:
             repo.invalidatevolatilesets()
         if contexts:
-            for ctx in repo.set(expr): pass
+            for ctx in repo.set(expr):
+                pass
         else:
-            for r in repo.revs(expr): pass
+            for r in repo.revs(expr):
+                pass
+
     timer(d)
     fm.end()
 
-@command(b'perfvolatilesets',
-         [(b'', b'clear-obsstore', False, b'drop obsstore between each call.'),
-          ] + formatteropts)
+
+@command(
+    b'perfvolatilesets',
+    [(b'', b'clear-obsstore', False, b'drop obsstore between each call.'),]
+    + formatteropts,
+)
 def perfvolatilesets(ui, repo, *names, **opts):
     """benchmark the computation of various volatile set
 
@@ -2829,6 +3228,7 b' def perfvolatilesets(ui, repo, *names, *'
             if opts[b'clear_obsstore']:
                 clearfilecache(repo, b'obsstore')
             obsolete.getrevs(repo, name)
+
         return d
 
     allobs = sorted(obsolete.cachefuncs)
@@ -2844,6 +3244,7 b' def perfvolatilesets(ui, repo, *names, *'
             if opts[b'clear_obsstore']:
                 clearfilecache(repo, b'obsstore')
             repoview.filterrevs(repo, name)
+
         return d
 
     allfilter = sorted(repoview.filtertable)
@@ -2854,12 +3255,20 b' def perfvolatilesets(ui, repo, *names, *'
         timer(getfiltered(name), title=name)
     fm.end()
 
-@command(b'perfbranchmap',
-         [(b'f', b'full', False,
-           b'Includes build time of subset'),
-          (b'', b'clear-revbranch', False,
-           b'purge the revbranch cache between computation'),
-          ] + formatteropts)
+
+@command(
+    b'perfbranchmap',
+    [
+        (b'f', b'full', False, b'Includes build time of subset'),
+        (
+            b'',
+            b'clear-revbranch',
+            False,
+            b'purge the revbranch cache between computation',
+        ),
+    ]
+    + formatteropts,
+)
 def perfbranchmap(ui, repo, *filternames, **opts):
     """benchmark the update of a branchmap
 
@@ -2869,6 +3278,7 b' def perfbranchmap(ui, repo, *filternames'
     full = opts.get(b"full", False)
     clear_revbranch = opts.get(b"clear_revbranch", False)
     timer, fm = gettimer(ui, opts)
+
     def getbranchmap(filtername):
         """generate a benchmark function for the filtername"""
         if filtername is None:
@@ -2880,6 +3290,7 b' def perfbranchmap(ui, repo, *filternames'
         else:
             # older versions
             filtered = view._branchcaches
+
         def d():
             if clear_revbranch:
                 repo.revbranchcache()._clear()
@@ -2888,7 +3299,9 b' def perfbranchmap(ui, repo, *filternames'
             else:
                 filtered.pop(filtername, None)
             view.branchmap()
+
         return d
+
     # add filter in smaller subset to bigger subset
     possiblefilters = set(repoview.filtertable)
     if filternames:
@@ -2933,11 +3346,16 b' def perfbranchmap(ui, repo, *filternames'
         branchcachewrite.restore()
     fm.end()
 
-@command(b'perfbranchmapupdate', [
+
+@command(
+    b'perfbranchmapupdate',
+    [
      (b'', b'base', [], b'subset of revision to start from'),
      (b'', b'target', [], b'subset of revision to end with'),
-     (b'', b'clear-caches', False, b'clear cache between each runs')
-    ] + formatteropts)
+        (b'', b'clear-caches', False, b'clear cache between each runs'),
+    ]
+    + formatteropts,
+)
 def perfbranchmapupdate(ui, repo, base=(), target=(), **opts):
     """benchmark branchmap update from for <base> revs to <target> revs
 
@@ -2956,6 +3374,7 b' def perfbranchmapupdate(ui, repo, base=('
     """
     from mercurial import branchmap
     from mercurial import repoview
+
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     clearcaches = opts[b'clear_caches']
@@ -3037,12 +3456,16 b' def perfbranchmapupdate(ui, repo, base=('
         repoview.filtertable.pop(b'__perf_branchmap_update_base', None)
         repoview.filtertable.pop(b'__perf_branchmap_update_target', None)
 
-@command(b'perfbranchmapload', [
+
+@command(
+    b'perfbranchmapload',
+    [
      (b'f', b'filter', b'', b'Specify repoview filter'),
      (b'', b'list', False, b'List brachmap filter caches'),
      (b'', b'clear-revlogs', False, b'refresh changelog and manifest'),
-
-    ] + formatteropts)
+    ]
+    + formatteropts,
+)
 def perfbranchmapload(ui, repo, filter=b'', list=False, **opts):
     """benchmark reading the branchmap"""
     opts = _byteskwargs(opts)
@@ -3052,8 +3475,9 b' def perfbranchmapload(ui, repo, filter=b'
         for name, kind, st in repo.cachevfs.readdir(stat=True):
             if name.startswith(b'branch2'):
                 filtername = name.partition(b'-')[2] or b'unfiltered'
-                ui.status(b'%s - %s\n'
-                          % (filtername, util.bytecount(st.st_size)))
+                ui.status(
+                    b'%s - %s\n' % (filtername, util.bytecount(st.st_size))
+                )
         return
     if not filter:
         filter = None
@@ -3076,18 +3500,23 b' def perfbranchmapload(ui, repo, filter=b'
     while fromfile(repo) is None:
         currentfilter = subsettable.get(currentfilter)
         if currentfilter is None:
-            raise error.Abort(b'No branchmap cached for %s repo'
-                              % (filter or b'unfiltered'))
+            raise error.Abort(
+                b'No branchmap cached for %s repo' % (filter or b'unfiltered')
+            )
         repo = repo.filtered(currentfilter)
     timer, fm = gettimer(ui, opts)
+
     def setup():
         if clearrevlogs:
             clearchangelog(repo)
+
     def bench():
         fromfile(repo)
+
     timer(bench, setup=setup)
     fm.end()
 
+
 @command(b'perfloadmarkers')
 def perfloadmarkers(ui, repo):
     """benchmark the time to parse the on-disk markers for a repo
@@ -3098,18 +3527,39 b' def perfloadmarkers(ui, repo):'
     timer(lambda: len(obsolete.obsstore(svfs)))
     fm.end()
 
-@command(b'perflrucachedict', formatteropts +
-    [(b'', b'costlimit', 0, b'maximum total cost of items in cache'),
+
+@command(
+    b'perflrucachedict',
+    formatteropts
+    + [
+        (b'', b'costlimit', 0, b'maximum total cost of items in cache'),
      (b'', b'mincost', 0, b'smallest cost of items in cache'),
      (b'', b'maxcost', 100, b'maximum cost of items in cache'),
      (b'', b'size', 4, b'size of cache'),
      (b'', b'gets', 10000, b'number of key lookups'),
      (b'', b'sets', 10000, b'number of key sets'),
      (b'', b'mixed', 10000, b'number of mixed mode operations'),
-     (b'', b'mixedgetfreq', 50, b'frequency of get vs set ops in mixed mode')],
-    norepo=True)
-def perflrucache(ui, mincost=0, maxcost=100, costlimit=0, size=4,
-                 gets=10000, sets=10000, mixed=10000, mixedgetfreq=50, **opts):
+        (
+            b'',
+            b'mixedgetfreq',
+            50,
+            b'frequency of get vs set ops in mixed mode',
+        ),
+    ],
+    norepo=True,
+)
+def perflrucache(
+    ui,
+    mincost=0,
+    maxcost=100,
+    costlimit=0,
+    size=4,
+    gets=10000,
+    sets=10000,
+    mixed=10000,
+    mixedgetfreq=50,
+    **opts
+):
     opts = _byteskwargs(opts)
 
     def doinit():
@@ -3178,9 +3628,9 b' def perflrucache(ui, mincost=0, maxcost='
         else:
             op = 1
 
-        mixedops.append((op,
-                         random.randint(0, size * 2),
-                         random.choice(costrange)))
+        mixedops.append(
+            (op, random.randint(0, size * 2), random.choice(costrange))
+        )
 
     def domixed():
         d = util.lrucachedict(size)
@@ -3211,24 +3661,29 b' def perflrucache(ui, mincost=0, maxcost='
     ]
 
     if costlimit:
-        benches.extend([
+        benches.extend(
+            [
             (dogetscost, b'gets w/ cost limit'),
             (doinsertscost, b'inserts w/ cost limit'),
             (domixedcost, b'mixed w/ cost limit'),
-        ])
+            ]
+        )
     else:
-        benches.extend([
+        benches.extend(
+            [
             (dogets, b'gets'),
             (doinserts, b'inserts'),
             (dosets, b'sets'),
-            (domixed, b'mixed')
-        ])
+                (domixed, b'mixed'),
+            ]
+        )
 
     for fn, title in benches:
         timer, fm = gettimer(ui, opts)
         timer(fn, title=title)
         fm.end()
 
+
 @command(b'perfwrite', formatteropts)
 def perfwrite(ui, repo, **opts):
     """microbenchmark ui.write
@@ -3236,15 +3691,19 b' def perfwrite(ui, repo, **opts):'
     opts = _byteskwargs(opts)
 
     timer, fm = gettimer(ui, opts)
+
     def write():
         for i in range(100000):
-            ui.write((b'Testing write performance\n'))
+            ui.write(b'Testing write performance\n')
+
     timer(write)
     fm.end()
 
+
 def uisetup(ui):
-    if (util.safehasattr(cmdutil, b'openrevlog') and
-        not util.safehasattr(commands, b'debugrevlogopts')):
+    if util.safehasattr(cmdutil, b'openrevlog') and not util.safehasattr(
+        commands, b'debugrevlogopts'
+    ):
         # for "historical portability":
         # In this case, Mercurial should be 1.9 (or a79fea6b3e77) -
         # 3.7 (or 5606f7d0d063). Therefore, '--dir' option for
@@ -3252,15 +3711,24 b' def uisetup(ui):'
         # available since 3.5 (or 49c583ca48c4).
         def openrevlog(orig, repo, cmd, file_, opts):
             if opts.get(b'dir') and not util.safehasattr(repo, b'dirlog'):
-                raise error.Abort(b"This version doesn't support --dir option",
-                                  hint=b"use 3.5 or later")
+                raise error.Abort(
+                    b"This version doesn't support --dir option",
+                    hint=b"use 3.5 or later",
+                )
             return orig(repo, cmd, file_, opts)
+
         extensions.wrapfunction(cmdutil, b'openrevlog', openrevlog)
 
-@command(b'perfprogress', formatteropts + [
+
+@command(
+    b'perfprogress',
+    formatteropts
+    + [
     (b'', b'topic', b'topic', b'topic for progress messages'),
     (b'c', b'total', 1000000, b'total value we are progressing to'),
-], norepo=True)
+    ],
+    norepo=True,
+)
 def perfprogress(ui, topic=None, total=None, **opts):
     """printing of progress bars"""
     opts = _byteskwargs(opts)

contrib/python-hook-examples.py

@@ -7,6 +7,7 b' from mercurial import ('
     util,
 )
 
+
 def diffstat(ui, repo, **kwargs):
     '''Example usage:
 

contrib/python3-ratchet.py

@@ -25,65 +25,103 b' import subprocess'
 import sys
 
 _hgenv = dict(os.environ)
-_hgenv.update({
-    'HGPLAIN': '1',
-    })
+_hgenv.update(
+    {'HGPLAIN': '1',}
+)
 
 _HG_FIRST_CHANGE = '9117c6561b0bd7792fa13b50d28239d51b78e51f'
 
+
 def _runhg(*args):
     return subprocess.check_output(args, env=_hgenv)
 
+
 def _is_hg_repo(path):
-    return _runhg('hg', 'log', '-R', path,
-                  '-r0', '--template={node}').strip() == _HG_FIRST_CHANGE
+    return (
+        _runhg('hg', 'log', '-R', path, '-r0', '--template={node}').strip()
+        == _HG_FIRST_CHANGE
+    )
+
 
 def _py3default():
     if sys.version_info[0] >= 3:
         return sys.executable
     return 'python3'
 
+
 def main(argv=()):
     p = argparse.ArgumentParser()
-    p.add_argument('--working-tests',
-                   help='List of tests that already work in Python 3.')
-    p.add_argument('--commit-to-repo',
-                   help='If set, commit newly fixed tests to the given repo')
-    p.add_argument('-j', default=os.sysconf(r'SC_NPROCESSORS_ONLN'), type=int,
-                   help='Number of parallel tests to run.')
-    p.add_argument('--python3', default=_py3default(),
-                   help='python3 interpreter to use for test run')
-    p.add_argument('--commit-user',
+    p.add_argument(
+        '--working-tests', help='List of tests that already work in Python 3.'
+    )
+    p.add_argument(
+        '--commit-to-repo',
+        help='If set, commit newly fixed tests to the given repo',
+    )
+    p.add_argument(
+        '-j',
+        default=os.sysconf(r'SC_NPROCESSORS_ONLN'),
+        type=int,
+        help='Number of parallel tests to run.',
+    )
+    p.add_argument(
+        '--python3',
+        default=_py3default(),
+        help='python3 interpreter to use for test run',
+    )
+    p.add_argument(
+        '--commit-user',
                    default='[e-mail]',
-                   help='Username to specify when committing to a repo.')
+        help='Username to specify when committing to a repo.',
+    )
     opts = p.parse_args(argv)
     if opts.commit_to_repo:
         if not _is_hg_repo(opts.commit_to_repo):
             print('abort: specified repository is not the hg repository')
             sys.exit(1)
     if not opts.working_tests or not os.path.isfile(opts.working_tests):
-        print('abort: --working-tests must exist and be a file (got %r)' %
-              opts.working_tests)
+        print(
+            'abort: --working-tests must exist and be a file (got %r)'
+            % opts.working_tests
+        )
         sys.exit(1)
     elif opts.commit_to_repo:
         root = _runhg('hg', 'root').strip()
         if not opts.working_tests.startswith(root):
-            print('abort: if --commit-to-repo is given, '
-                  '--working-tests must be from that repo')
+            print(
+                'abort: if --commit-to-repo is given, '
+                '--working-tests must be from that repo'
+            )
             sys.exit(1)
     try:
-        subprocess.check_call([opts.python3, '-c',
+        subprocess.check_call(
+            [
+                opts.python3,
+                '-c',
                                'import sys ; '
                                'assert ((3, 5) <= sys.version_info < (3, 6) '
-                               'or sys.version_info >= (3, 6, 2))'])
+                'or sys.version_info >= (3, 6, 2))',
+            ]
+        )
     except subprocess.CalledProcessError:
-        print('warning: Python 3.6.0 and 3.6.1 have '
-              'a bug which breaks Mercurial')
+        print(
+            'warning: Python 3.6.0 and 3.6.1 have '
+            'a bug which breaks Mercurial'
+        )
         print('(see https://bugs.python.org/issue29714 for details)')
         sys.exit(1)
 
-    rt = subprocess.Popen([opts.python3, 'run-tests.py', '-j', str(opts.j),
-                           '--blacklist', opts.working_tests, '--json'])
+    rt = subprocess.Popen(
+        [
+            opts.python3,
+            'run-tests.py',
+            '-j',
+            str(opts.j),
+            '--blacklist',
+            opts.working_tests,
+            '--json',
+        ]
+    )
     rt.wait()
     with open('report.json') as f:
         data = f.read()
@@ -104,12 +142,20 b' def main(argv=()):'
             with open(opts.working_tests, 'w') as f:
                 for p in sorted(oldpass | newpass):
                     f.write('%s\n' % p)
-            _runhg('hg', 'commit', '-R', opts.commit_to_repo,
-                   '--user', opts.commit_user,
-                   '--message', 'python3: expand list of passing tests')
+            _runhg(
+                'hg',
+                'commit',
+                '-R',
+                opts.commit_to_repo,
+                '--user',
+                opts.commit_user,
+                '--message',
+                'python3: expand list of passing tests',
+            )
         else:
             print('Newly passing tests:', '\n'.join(sorted(newpass)))
             sys.exit(2)
 
+
 if __name__ == '__main__':
     main(sys.argv[1:])

contrib/revsetbenchmarks.py

@@ -16,9 +16,20 b' import re'
 import subprocess
 import sys
 
-DEFAULTVARIANTS = ['plain', 'min', 'max', 'first', 'last',
-                   'reverse', 'reverse+first', 'reverse+last',
-                   'sort', 'sort+first', 'sort+last']
+DEFAULTVARIANTS = [
+    'plain',
+    'min',
+    'max',
+    'first',
+    'last',
+    'reverse',
+    'reverse+first',
+    'reverse+last',
+    'sort',
+    'sort+first',
+    'sort+last',
+]
+
 
 def check_output(*args, **kwargs):
     kwargs.setdefault('stderr', subprocess.PIPE)
@@ -29,12 +40,14 b' def check_output(*args, **kwargs):'
         raise subprocess.CalledProcessError(proc.returncode, ' '.join(args[0]))
     return output
 
+
 def update(rev):
     """update the repo to a revision"""
     try:
         subprocess.check_call(['hg', 'update', '--quiet', '--check', str(rev)])
-        check_output(['make', 'local'],
-                     stderr=None)  # suppress output except for error/warning
+        check_output(
+            ['make', 'local'], stderr=None
+        )  # suppress output except for error/warning
     except subprocess.CalledProcessError as exc:
         print('update to revision %s failed, aborting'%rev, file=sys.stderr)
         sys.exit(exc.returncode)
@@ -48,11 +61,14 b' def hg(cmd, repo=None):'
     fullcmd = ['./hg']
     if repo is not None:
         fullcmd += ['-R', repo]
-    fullcmd += ['--config',
-                'extensions.perf=' + os.path.join(contribdir, 'perf.py')]
+    fullcmd += [
+        '--config',
+        'extensions.perf=' + os.path.join(contribdir, 'perf.py'),
+    ]
     fullcmd += cmd
     return check_output(fullcmd, stderr=subprocess.STDOUT)
 
+
 def perf(revset, target=None, contexts=False):
     """run benchmark for this very revset"""
     try:
@@ -64,15 +80,21 b' def perf(revset, target=None, contexts=F'
         output = hg(args, repo=target)
         return parseoutput(output)
     except subprocess.CalledProcessError as exc:
-        print('abort: cannot run revset benchmark: %s'%exc.cmd, file=sys.stderr)
+        print(
+            'abort: cannot run revset benchmark: %s' % exc.cmd, file=sys.stderr
+        )
         if getattr(exc, 'output', None) is None: # no output before 2.7
             print('(no output)', file=sys.stderr)
         else:
             print(exc.output, file=sys.stderr)
         return None
 
-outputre = re.compile(br'! wall (\d+.\d+) comb (\d+.\d+) user (\d+.\d+) '
-                      br'sys (\d+.\d+) \(best of (\d+)\)')
+
+outputre = re.compile(
+    br'! wall (\d+.\d+) comb (\d+.\d+) user (\d+.\d+) '
+    br'sys (\d+.\d+) \(best of (\d+)\)'
+)
+
 
 def parseoutput(output):
     """parse a textual output into a dict
@@ -85,20 +107,30 b' def parseoutput(output):'
         print('abort: invalid output:', file=sys.stderr)
         print(output, file=sys.stderr)
         sys.exit(1)
-    return {'comb': float(match.group(2)),
+    return {
+        'comb': float(match.group(2)),
             'count': int(match.group(5)),
             'sys': float(match.group(3)),
             'user': float(match.group(4)),
             'wall': float(match.group(1)),
             }
 
+
 def printrevision(rev):
     """print data about a revision"""
     sys.stdout.write("Revision ")
     sys.stdout.flush()
-    subprocess.check_call(['hg', 'log', '--rev', str(rev), '--template',
-                           '{if(tags, " ({tags})")} '
-                           '{rev}:{node|short}: {desc|firstline}\n'])
+    subprocess.check_call(
+        [
+            'hg',
+            'log',
+            '--rev',
+            str(rev),
+            '--template',
+            '{if(tags, " ({tags})")} ' '{rev}:{node|short}: {desc|firstline}\n',
+        ]
+    )
+
 
 def idxwidth(nbidx):
     """return the max width of number used for index
@@ -116,6 +148,7 b' def idxwidth(nbidx):'
         idxwidth = 1
     return idxwidth
 
+
 def getfactor(main, other, field, sensitivity=0.05):
     """return the relative factor between values for 'field' in main and other
 
@@ -125,10 +158,11 b' def getfactor(main, other, field, sensit'
     if main is not None:
         factor = other[field] / main[field]
     low, high = 1 - sensitivity, 1 + sensitivity
-    if (low < factor < high):
+    if low < factor < high:
         return None
     return factor
 
+
 def formatfactor(factor):
     """format a factor into a 4 char string
 
@@ -155,6 +189,7 b' def formatfactor(factor):'
             factor //= 0
         return 'x%ix%i' % (factor, order)
 
+
 def formattiming(value):
     """format a value to strictly 8 char, dropping some precision if needed"""
     if value < 10**7:
@@ -163,7 +198,10 b' def formattiming(value):'
         # value is HUGE very unlikely to happen (4+ month run)
         return '%i' % value
 
+
 _marker = object()
+
+
 def printresult(variants, idx, data, maxidx, verbose=False, reference=_marker):
     """print a line of result to stdout"""
     mask = '%%0%ii) %%s' % idxwidth(maxidx)
@@ -187,6 +225,7 b' def printresult(variants, idx, data, max'
             out.append('%6d'    % data[var]['count'])
     print(mask % (idx, ' '.join(out)))
 
+
 def printheader(variants, maxidx, verbose=False, relative=False):
     header = [' ' * (idxwidth(maxidx) + 1)]
     for var in variants:
@@ -204,6 +243,7 b' def printheader(variants, maxidx, verbos'
             header.append('%6s' % 'count')
     print(' '.join(header))
 
+
 def getrevs(spec):
     """get the list of rev matched by a revset"""
     try:
@@ -221,31 +261,44 b' def applyvariants(revset, variant):'
         revset = '%s(%s)' % (var, revset)
     return revset
 
+
 helptext="""This script will run multiple variants of provided revsets using
 different revisions in your mercurial repository. After the benchmark are run
 summary output is provided. Use it to demonstrate speed improvements or pin
 point regressions. Revsets to run are specified in a file (or from stdin), one
 revsets per line. Line starting with '#' will be ignored, allowing insertion of
 comments."""
-parser = optparse.OptionParser(usage="usage: %prog [options] <revs>",
-                               description=helptext)
-parser.add_option("-f", "--file",
+parser = optparse.OptionParser(
+    usage="usage: %prog [options] <revs>", description=helptext
+)
+parser.add_option(
+    "-f",
+    "--file",
                   help="read revset from FILE (stdin if omitted)",
-                  metavar="FILE")
-parser.add_option("-R", "--repo",
-                  help="run benchmark on REPO", metavar="REPO")
+    metavar="FILE",
+)
+parser.add_option("-R", "--repo", help="run benchmark on REPO", metavar="REPO")
 
-parser.add_option("-v", "--verbose",
+parser.add_option(
+    "-v",
+    "--verbose",
                   action='store_true',
-                  help="display all timing data (not just best total time)")
+    help="display all timing data (not just best total time)",
+)
 
-parser.add_option("", "--variants",
+parser.add_option(
+    "",
+    "--variants",
                   default=','.join(DEFAULTVARIANTS),
                   help="comma separated list of variant to test "
-                       "(eg: plain,min,sorted) (plain = no modification)")
-parser.add_option('', '--contexts',
+    "(eg: plain,min,sorted) (plain = no modification)",
+)
+parser.add_option(
+    '',
+    '--contexts',
                   action='store_true',
-                  help='obtain changectx from results instead of integer revs')
+    help='obtain changectx from results instead of integer revs',
+)
 
 (options, args) = parser.parse_args()
 
@@ -294,17 +347,20 b' for r in revs:'
             data = perf(varrset, target=options.repo, contexts=options.contexts)
             varres[var] = data
         res.append(varres)
-        printresult(variants, idx, varres, len(revsets),
-                    verbose=options.verbose)
+        printresult(
+            variants, idx, varres, len(revsets), verbose=options.verbose
+        )
         sys.stdout.flush()
     print("----------------------------")
 
 
-print("""
+print(
+    """
 
 Result by revset
 ================
-""")
+"""
+)
 
 print('Revision:')
 for idx, rev in enumerate(revs):
@@ -321,7 +377,13 b' for ridx, rset in enumerate(revsets):'
     printheader(variants, len(results), verbose=options.verbose, relative=True)
     ref = None
     for idx, data in enumerate(results):
-        printresult(variants, idx, data[ridx], len(results),
-                    verbose=options.verbose, reference=ref)
+        printresult(
+            variants,
+            idx,
+            data[ridx],
+            len(results),
+            verbose=options.verbose,
+            reference=ref,
+        )
         ref = data[ridx]
     print()

contrib/showstack.py

@@ -9,16 +9,19 b' import signal'
 import sys
 import traceback
 
+
 def sigshow(*args):
     sys.stderr.write("\n")
     traceback.print_stack(args[1], limit=10, file=sys.stderr)
     sys.stderr.write("----\n")
 
+
 def sigexit(*args):
     sigshow(*args)
     print('alarm!')
     sys.exit(1)
 
+
 def extsetup(ui):
     signal.signal(signal.SIGQUIT, sigshow)
     signal.signal(signal.SIGALRM, sigexit)

contrib/synthrepo.py

@@ -62,9 +62,7 b' from mercurial import ('
     registrar,
     scmutil,
 )
-from mercurial.utils import (
-    dateutil,
-)
+from mercurial.utils import dateutil
 
 # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
@@ -77,14 +75,17 b' command = registrar.command(cmdtable)'
 
 newfile = {'new fi', 'rename', 'copy f', 'copy t'}
 
+
 def zerodict():
     return collections.defaultdict(lambda: 0)
 
+
 def roundto(x, k):
     if x > k * 2:
         return int(round(x / float(k)) * k)
     return int(round(x))
 
+
 def parsegitdiff(lines):
     filename, mar, lineadd, lineremove = None, None, zerodict(), 0
     binary = False
@@ -110,10 +111,16 b' def parsegitdiff(lines):'
     if filename:
         yield filename, mar, lineadd, lineremove, binary
 
-@command('analyze',
-         [('o', 'output', '', _('write output to given file'), _('FILE')),
-          ('r', 'rev', [], _('analyze specified revisions'), _('REV'))],
-         _('hg analyze'), optionalrepo=True)
+
+@command(
+    'analyze',
+    [
+        ('o', 'output', '', _('write output to given file'), _('FILE')),
+        ('r', 'rev', [], _('analyze specified revisions'), _('REV')),
+    ],
+    _('hg analyze'),
+    optionalrepo=True,
+)
 def analyze(ui, repo, *revs, **opts):
     '''create a simple model of a repository to use for later synthesis
 
@@ -176,8 +183,9 b' def analyze(ui, repo, *revs, **opts):'
         revs = scmutil.revrange(repo, revs)
         revs.sort()
 
-        progress = ui.makeprogress(_('analyzing'), unit=_('changesets'),
-                                   total=len(revs))
+        progress = ui.makeprogress(
+            _('analyzing'), unit=_('changesets'), total=len(revs)
+        )
         for i, rev in enumerate(revs):
             progress.update(i)
             ctx = repo[rev]
@@ -198,8 +206,9 b' def analyze(ui, repo, *revs, **opts):'
                 timedelta = ctx.date()[0] - lastctx.date()[0]
                 interarrival[roundto(timedelta, 300)] += 1
             diffopts = diffutil.diffallopts(ui, {'git': True})
-            diff = sum((d.splitlines()
-                       for d in ctx.diff(pctx, opts=diffopts)), [])
+            diff = sum(
+                (d.splitlines() for d in ctx.diff(pctx, opts=diffopts)), []
+            )
             fileadds, diradds, fileremoves, filechanges = 0, 0, 0, 0
             for filename, mar, lineadd, lineremove, isbin in parsegitdiff(diff):
                 if isbin:
@@ -207,8 +216,9 b' def analyze(ui, repo, *revs, **opts):'
                 added = sum(lineadd.itervalues(), 0)
                 if mar == 'm':
                     if added and lineremove:
-                        lineschanged[roundto(added, 5),
-                                     roundto(lineremove, 5)] += 1
+                        lineschanged[
+                            roundto(added, 5), roundto(lineremove, 5)
+                        ] += 1
                         filechanges += 1
                 elif mar == 'a':
                     fileadds += 1
@@ -238,7 +248,9 b' def analyze(ui, repo, *revs, **opts):'
     def pronk(d):
         return sorted(d.iteritems(), key=lambda x: x[1], reverse=True)
 
-    json.dump({'revs': len(revs),
+    json.dump(
+        {
+            'revs': len(revs),
                'initdirs': pronk(dirs),
                'lineschanged': pronk(lineschanged),
                'children': pronk(invchildren),
@@ -254,14 +266,20 b' def analyze(ui, repo, *revs, **opts):'
                'interarrival': pronk(interarrival),
                'tzoffset': pronk(tzoffset),
                },
-              fp)
+        fp,
+    )
     fp.close()
 
-@command('synthesize',
-         [('c', 'count', 0, _('create given number of commits'), _('COUNT')),
+
+@command(
+    'synthesize',
+    [
+        ('c', 'count', 0, _('create given number of commits'), _('COUNT')),
           ('', 'dict', '', _('path to a dictionary of words'), _('FILE')),
-          ('', 'initfiles', 0, _('initial file count to create'), _('COUNT'))],
-         _('hg synthesize [OPTION].. DESCFILE'))
+        ('', 'initfiles', 0, _('initial file count to create'), _('COUNT')),
+    ],
+    _('hg synthesize [OPTION].. DESCFILE'),
+)
 def synthesize(ui, repo, descpath, **opts):
     '''synthesize commits based on a model of an existing repository
 
@@ -384,16 +402,23 b' def synthesize(ui, repo, descpath, **opt'
 
         progress.complete()
         message = 'synthesized wide repo with %d files' % (len(files),)
-        mc = context.memctx(repo, [pctx.node(), nullid], message,
-                            files, filectxfn, ui.username(),
-                            '%d %d' % dateutil.makedate())
+        mc = context.memctx(
+            repo,
+            [pctx.node(), nullid],
+            message,
+            files,
+            filectxfn,
+            ui.username(),
+            '%d %d' % dateutil.makedate(),
+        )
         initnode = mc.commit()
         if ui.debugflag:
             hexfn = hex
         else:
             hexfn = short
-        ui.status(_('added commit %s with %d files\n')
-                  % (hexfn(initnode), len(files)))
+        ui.status(
+            _('added commit %s with %d files\n') % (hexfn(initnode), len(files))
+        )
 
     # Synthesize incremental revisions to the repository, adding repo depth.
     count = int(opts['count'])
@@ -437,8 +462,11 b' def synthesize(ui, repo, descpath, **opt'
                 for __ in pycompat.xrange(10):
                     fctx = pctx.filectx(random.choice(mfk))
                     path = fctx.path()
-                    if not (path in nevertouch or fctx.isbinary() or
-                            'l' in fctx.flags()):
+                    if not (
+                        path in nevertouch
+                        or fctx.isbinary()
+                        or 'l' in fctx.flags()
+                    ):
                         break
                 lines = fctx.data().splitlines()
                 add, remove = pick(lineschanged)
@@ -466,14 +494,20 b' def synthesize(ui, repo, descpath, **opt'
                     path.append(random.choice(words))
                 path.append(random.choice(words))
                 pathstr = '/'.join(filter(None, path))
-            data = '\n'.join(
+            data = (
+                '\n'.join(
                 makeline()
-                for __ in pycompat.xrange(pick(linesinfilesadded))) + '\n'
+                    for __ in pycompat.xrange(pick(linesinfilesadded))
+                )
+                + '\n'
+            )
             changes[pathstr] = data
+
         def filectxfn(repo, memctx, path):
             if path not in changes:
                 return None
             return context.memfilectx(repo, memctx, path, changes[path])
+
         if not changes:
             continue
         if revs:
@@ -481,11 +515,17 b' def synthesize(ui, repo, descpath, **opt'
         else:
             date = time.time() - (86400 * count)
         # dates in mercurial must be positive, fit in 32-bit signed integers.
-        date = min(0x7fffffff, max(0, date))
+        date = min(0x7FFFFFFF, max(0, date))
         user = random.choice(words) + '@' + random.choice(words)
-        mc = context.memctx(repo, pl, makeline(minimum=2),
+        mc = context.memctx(
+            repo,
+            pl,
+            makeline(minimum=2),
                             sorted(changes),
-                            filectxfn, user, '%d %d' % (date, pick(tzoffset)))
+            filectxfn,
+            user,
+            '%d %d' % (date, pick(tzoffset)),
+        )
         newnode = mc.commit()
         heads.add(repo.changelog.rev(newnode))
         heads.discard(r1)
@@ -495,10 +535,12 b' def synthesize(ui, repo, descpath, **opt'
     lock.release()
     wlock.release()
 
+
 def renamedirs(dirs, words):
     '''Randomly rename the directory names in the per-dir file count dict.'''
     wordgen = itertools.cycle(words)
     replacements = {'': ''}
+
     def rename(dirpath):
         '''Recursively rename the directory and all path prefixes.
 
@@ -516,6 +558,7 b' def renamedirs(dirs, words):'
         renamed = os.path.join(head, next(wordgen))
         replacements[dirpath] = renamed
         return renamed
+
     result = []
     for dirpath, count in dirs.iteritems():
         result.append([rename(dirpath.lstrip(os.sep)), count])

contrib/testparseutil.py

@@ -14,11 +14,13 b' import sys'
 ####################
 # for Python3 compatibility (almost comes from mercurial/pycompat.py)
 
-ispy3 = (sys.version_info[0] >= 3)
+ispy3 = sys.version_info[0] >= 3
+
 
 def identity(a):
     return a
 
+
 def _rapply(f, xs):
     if xs is None:
         # assume None means non-value of optional data
@@ -29,12 +31,14 b' def _rapply(f, xs):'
         return type(xs)((_rapply(f, k), _rapply(f, v)) for k, v in xs.items())
     return f(xs)
 
+
 def rapply(f, xs):
     if f is identity:
         # fast path mainly for py2
         return xs
     return _rapply(f, xs)
 
+
 if ispy3:
     import builtins
 
@@ -49,29 +53,37 b' if ispy3:'
 
     def opentext(f):
         return open(f, 'r')
+
+
 else:
     bytestr = str
     sysstr = identity
 
     opentext = open
 
+
 def b2s(x):
     # convert BYTES elements in "x" to SYSSTR recursively
     return rapply(sysstr, x)
 
+
 def writeout(data):
     # write "data" in BYTES into stdout
     sys.stdout.write(data)
 
+
 def writeerr(data):
     # write "data" in BYTES into stderr
     sys.stderr.write(data)
 
+
 ####################
 
+
 class embeddedmatcher(object):
     """Base class to detect embedded code fragments in *.t test script
     """
+
     __metaclass__ = abc.ABCMeta
 
     def __init__(self, desc):
@@ -126,6 +138,7 b' class embeddedmatcher(object):'
     def codeinside(self, ctx, line):
         """Return actual code at line inside embedded code"""
 
+
 def embedded(basefile, lines, errors, matchers):
     """pick embedded code fragments up from given lines
 
@@ -185,8 +198,10 b' def embedded(basefile, lines, errors, ma'
             elif not matcher.isinside(ctx, line):
                 # this is an error of basefile
                 # (if matchers are implemented correctly)
-                errors.append('%s:%d: unexpected line for "%s"'
-                              % (basefile, lineno, matcher.desc))
+                errors.append(
+                    '%s:%d: unexpected line for "%s"'
+                    % (basefile, lineno, matcher.desc)
+                )
                 # stop extracting embedded code by current 'matcher',
                 # because appearance of unexpected line might mean
                 # that expected end-of-embedded-code line might never
@@ -208,10 +223,14 b' def embedded(basefile, lines, errors, ma'
         if matched:
             if len(matched) > 1:
                 # this is an error of matchers, maybe
-                errors.append('%s:%d: ambiguous line for %s' %
-                              (basefile, lineno,
-                               ', '.join(['"%s"' % m.desc
-                                           for m, c in matched])))
+                errors.append(
+                    '%s:%d: ambiguous line for %s'
+                    % (
+                        basefile,
+                        lineno,
+                        ', '.join(['"%s"' % m.desc for m, c in matched]),
+                    )
+                )
                 # omit extracting embedded code, because choosing
                 # arbitrary matcher from matched ones might fail to
                 # detect the end of embedded code as expected.
@@ -238,8 +257,11 b' def embedded(basefile, lines, errors, ma'
         else:
             # this is an error of basefile
             # (if matchers are implemented correctly)
-            errors.append('%s:%d: unexpected end of file for "%s"'
-                          % (basefile, lineno, matcher.desc))
+            errors.append(
+                '%s:%d: unexpected end of file for "%s"'
+                % (basefile, lineno, matcher.desc)
+            )
+
 
 # heredoc limit mark to ignore embedded code at check-code.py or so
 heredocignorelimit = 'NO_CHECK_EOF'
@@ -252,6 +274,7 b" heredocignorelimit = 'NO_CHECK_EOF'"
 # - << 'LIMITMARK'
 heredoclimitpat = r'\s*<<\s*(?P<lquote>["\']?)(?P<limit>\w+)(?P=lquote)'
 
+
 class fileheredocmatcher(embeddedmatcher):
     """Detect "cat > FILE << LIMIT" style embedded code
 
@@ -290,6 +313,7 b' class fileheredocmatcher(embeddedmatcher'
     >>> matcher.ignores(ctx)
     True
     """
+
     _prefix = '  > '
 
     def __init__(self, desc, namepat):
@@ -302,8 +326,9 b' class fileheredocmatcher(embeddedmatcher'
         # - > NAMEPAT
         # - > "NAMEPAT"
         # - > 'NAMEPAT'
-        namepat = (r'\s*>>?\s*(?P<nquote>["\']?)(?P<name>%s)(?P=nquote)'
-                   % namepat)
+        namepat = (
+            r'\s*>>?\s*(?P<nquote>["\']?)(?P<name>%s)(?P=nquote)' % namepat
+        )
         self._fileres = [
             # "cat > NAME << LIMIT" case
             re.compile(r'  \$ \s*cat' + namepat + heredoclimitpat),
@@ -316,8 +341,10 b' class fileheredocmatcher(embeddedmatcher'
         for filere in self._fileres:
             matched = filere.match(line)
             if matched:
-                return (matched.group('name'),
-                        '  > %s\n' % matched.group('limit'))
+                return (
+                    matched.group('name'),
+                    '  > %s\n' % matched.group('limit'),
+                )
 
     def endsat(self, ctx, line):
         return ctx[1] == line
@@ -340,9 +367,11 b' class fileheredocmatcher(embeddedmatcher'
     def codeinside(self, ctx, line):
         return line[len(self._prefix):] # strip prefix
 
+
 ####
 # for embedded python script
 
+
 class pydoctestmatcher(embeddedmatcher):
     """Detect ">>> code" style embedded python code
 
@@ -395,6 +424,7 b' class pydoctestmatcher(embeddedmatcher):'
     True
     >>> matcher.codeatend(ctx, end)
     """
+
     _prefix = '  >>> '
     _prefixre = re.compile(r'  (>>>|\.\.\.) ')
 
@@ -438,6 +468,7 b' class pydoctestmatcher(embeddedmatcher):'
             return line[len(self._prefix):] # strip prefix '  >>> '/'  ... '
         return '\n' # an expected output line is treated as an empty line
 
+
 class pyheredocmatcher(embeddedmatcher):
     """Detect "python << LIMIT" style embedded python code
 
@@ -474,10 +505,12 b' class pyheredocmatcher(embeddedmatcher):'
     >>> matcher.ignores(ctx)
     True
     """
+
     _prefix = '  > '
 
-    _startre = re.compile(r'  \$ (\$PYTHON|"\$PYTHON"|python).*' +
-                          heredoclimitpat)
+    _startre = re.compile(
+        r'  \$ (\$PYTHON|"\$PYTHON"|python).*' + heredoclimitpat
+    )
 
     def __init__(self):
         super(pyheredocmatcher, self).__init__("heredoc python invocation")
@@ -509,6 +542,7 b' class pyheredocmatcher(embeddedmatcher):'
     def codeinside(self, ctx, line):
         return line[len(self._prefix):] # strip prefix
 
+
 _pymatchers = [
     pydoctestmatcher(),
     pyheredocmatcher(),
@@ -517,9 +551,11 b' class pyheredocmatcher(embeddedmatcher):'
     fileheredocmatcher('heredoc .py file', r'[^<]+\.py'),
 ]
 
+
 def pyembedded(basefile, lines, errors):
     return embedded(basefile, lines, errors, _pymatchers)
 
+
 ####
 # for embedded shell script
 
@@ -529,22 +565,27 b' def pyembedded(basefile, lines, errors):'
     fileheredocmatcher('heredoc .sh file', r'[^<]+\.sh'),
 ]
 
+
 def shembedded(basefile, lines, errors):
     return embedded(basefile, lines, errors, _shmatchers)
 
+
 ####
 # for embedded hgrc configuration
 
 _hgrcmatchers = [
     # use '[^<]+' instead of '\S+', in order to match against
     # paths including whitespaces
-    fileheredocmatcher('heredoc hgrc file',
-                       r'(([^/<]+/)+hgrc|\$HGRCPATH|\${HGRCPATH})'),
+    fileheredocmatcher(
+        'heredoc hgrc file', r'(([^/<]+/)+hgrc|\$HGRCPATH|\${HGRCPATH})'
+    ),
 ]
 
+
 def hgrcembedded(basefile, lines, errors):
     return embedded(basefile, lines, errors, _hgrcmatchers)
 
+
 ####
 
 if __name__ == "__main__":
@@ -558,8 +599,7 b' if __name__ == "__main__":'
                 name = '<anonymous>'
             writeout("%s:%d: %s starts\n" % (basefile, starts, name))
             if opts.verbose and code:
-                writeout("  |%s\n" %
-                         "\n  |".join(l for l in code.splitlines()))
+                writeout("  |%s\n" % "\n  |".join(l for l in code.splitlines()))
             writeout("%s:%d: %s ends\n" % (basefile, ends, name))
         for e in errors:
             writeerr("%s\n" % e)
@@ -579,9 +619,11 b' if __name__ == "__main__":'
         return ret
 
     commands = {}
+
     def command(name, desc):
         def wrap(func):
             commands[name] = (desc, func)
+
         return wrap
 
     @command("pyembedded", "detect embedded python script")
@@ -596,21 +638,29 b' if __name__ == "__main__":'
     def hgrcembeddedcmd(args, opts):
         return applyembedded(args, hgrcembedded, opts)
 
-    availablecommands = "\n".join(["  - %s: %s" % (key, value[0])
-                                   for key, value in commands.items()])
+    availablecommands = "\n".join(
+        ["  - %s: %s" % (key, value[0]) for key, value in commands.items()]
+    )
 
-    parser = optparse.OptionParser("""%prog COMMAND [file ...]
+    parser = optparse.OptionParser(
+        """%prog COMMAND [file ...]
 
 Pick up embedded code fragments from given file(s) or stdin, and list
 up start/end lines of them in standard compiler format
 ("FILENAME:LINENO:").
 
 Available commands are:
-""" + availablecommands + """
-""")
-    parser.add_option("-v", "--verbose",
+"""
+        + availablecommands
+        + """
+"""
+    )
+    parser.add_option(
+        "-v",
+        "--verbose",
                       help="enable additional output (e.g. actual code)",
-                      action="store_true")
+        action="store_true",
+    )
     (opts, args) = parser.parse_args()
 
     if not args or args[0] not in commands:

contrib/win32/hgwebdir_wsgi.py

@@ -96,6 +96,7 b' import sys'
 # Enable tracing. Run 'python -m win32traceutil' to debug
 if getattr(sys, 'isapidllhandle', None) is not None:
     import win32traceutil
+
     win32traceutil.SetupForPrint # silence unused import warning
 
 import isapi_wsgi
@@ -106,11 +107,13 b' from mercurial.hgweb.hgwebdir_mod import'
 class WsgiHandler(isapi_wsgi.IsapiWsgiHandler):
     error_status = '500 Internal Server Error' # less silly error message
 
+
 isapi_wsgi.IsapiWsgiHandler = WsgiHandler
 
 # Only create the hgwebdir instance once
 application = hgwebdir(hgweb_config)
 
+
 def handler(environ, start_response):
 
     # Translate IIS's weird URLs
@@ -125,10 +128,13 b' def handler(environ, start_response):'
 
     return application(environ, start_response)
 
+
 def __ExtensionFactory__():
     return isapi_wsgi.ISAPISimpleHandler(handler)
 
+
 if __name__=='__main__':
     from isapi.install import ISAPIParameters, HandleCommandLine
+
     params = ISAPIParameters()
     HandleCommandLine(params)

doc/check-seclevel.py

@@ -11,7 +11,9 b' import sys'
 # import from the live mercurial repo
 os.environ['HGMODULEPOLICY'] = 'py'
 sys.path.insert(0, "..")
-from mercurial import demandimport; demandimport.enable()
+from mercurial import demandimport
+
+demandimport.enable()
 from mercurial import (
     commands,
     extensions,
@@ -36,13 +38,16 b' initlevel_cmd = 1'
 initlevel_ext = 1
 initlevel_ext_cmd = 3
 
+
 def showavailables(ui, initlevel):
-    avail = ('    available marks and order of them in this help: %s\n') % (
-        ', '.join(['%r' % (m * 4) for m in level2mark[initlevel + 1:]]))
+    avail = '    available marks and order of them in this help: %s\n' % (
+        ', '.join(['%r' % (m * 4) for m in level2mark[initlevel + 1 :]])
+    )
     ui.warn(avail.encode('utf-8'))
 
+
 def checkseclevel(ui, doc, name, initlevel):
-    ui.note(('checking "%s"\n') % name)
+    ui.note('checking "%s"\n' % name)
     if not isinstance(doc, bytes):
         doc = doc.encode('utf-8')
     blocks, pruned = minirst.parse(doc, 0, ['verbose'])
@@ -54,66 +59,77 b' def checkseclevel(ui, doc, name, initlev'
         mark = block[b'underline']
         title = block[b'lines'][0]
         if (mark not in mark2level) or (mark2level[mark] <= initlevel):
-            ui.warn((('invalid section mark %r for "%s" of %s\n') %
-                     (mark * 4, title, name)).encode('utf-8'))
+            ui.warn(
+                (
+                    'invalid section mark %r for "%s" of %s\n'
+                    % (mark * 4, title, name)
+                ).encode('utf-8')
+            )
             showavailables(ui, initlevel)
             errorcnt += 1
             continue
         nextlevel = mark2level[mark]
         if curlevel < nextlevel and curlevel + 1 != nextlevel:
-            ui.warn(('gap of section level at "%s" of %s\n') %
-                    (title, name))
+            ui.warn('gap of section level at "%s" of %s\n' % (title, name))
             showavailables(ui, initlevel)
             errorcnt += 1
             continue
-        ui.note(('appropriate section level for "%s %s"\n') %
-                (mark * (nextlevel * 2), title))
+        ui.note(
+            'appropriate section level for "%s %s"\n'
+            % (mark * (nextlevel * 2), title)
+        )
         curlevel = nextlevel
 
     return errorcnt
 
+
 def checkcmdtable(ui, cmdtable, namefmt, initlevel):
     errorcnt = 0
     for k, entry in cmdtable.items():
         name = k.split(b"|")[0].lstrip(b"^")
         if not entry[0].__doc__:
-            ui.note(('skip checking %s: no help document\n') %
-                    (namefmt % name))
+            ui.note('skip checking %s: no help document\n' % (namefmt % name))
             continue
-        errorcnt += checkseclevel(ui, entry[0].__doc__,
-                                  namefmt % name,
-                                  initlevel)
+        errorcnt += checkseclevel(
+            ui, entry[0].__doc__, namefmt % name, initlevel
+        )
     return errorcnt
 
+
 def checkhghelps(ui):
     errorcnt = 0
     for h in helptable:
         names, sec, doc = h[0:3]
         if callable(doc):
             doc = doc(ui)
-        errorcnt += checkseclevel(ui, doc,
-                                  '%s help topic' % names[0],
-                                  initlevel_topic)
+        errorcnt += checkseclevel(
+            ui, doc, '%s help topic' % names[0], initlevel_topic
+        )
 
     errorcnt += checkcmdtable(ui, table, '%s command', initlevel_cmd)
 
-    for name in sorted(list(extensions.enabled()) +
-                       list(extensions.disabled())):
+    for name in sorted(
+        list(extensions.enabled()) + list(extensions.disabled())
+    ):
         mod = extensions.load(ui, name, None)
         if not mod.__doc__:
-            ui.note(('skip checking %s extension: no help document\n') % name)
+            ui.note('skip checking %s extension: no help document\n' % name)
             continue
-        errorcnt += checkseclevel(ui, mod.__doc__,
-                                  '%s extension' % name,
-                                  initlevel_ext)
+        errorcnt += checkseclevel(
+            ui, mod.__doc__, '%s extension' % name, initlevel_ext
+        )
 
         cmdtable = getattr(mod, 'cmdtable', None)
         if cmdtable:
-            errorcnt += checkcmdtable(ui, cmdtable,
+            errorcnt += checkcmdtable(
+                ui,
+                cmdtable,
                                       '%%s command of %s extension' % name,
-                                      initlevel_ext_cmd)
+                initlevel_ext_cmd,
+            )
     return errorcnt
 
+
 def checkfile(ui, filename, initlevel):
     if filename == '-':
         filename = 'stdin'
@@ -122,43 +138,76 b' def checkfile(ui, filename, initlevel):'
         with open(filename) as fp:
             doc = fp.read()
 
-    ui.note(('checking input from %s with initlevel %d\n') %
-            (filename, initlevel))
+    ui.note(
+        'checking input from %s with initlevel %d\n' % (filename, initlevel)
+    )
     return checkseclevel(ui, doc, 'input from %s' % filename, initlevel)
 
+
 def main():
-    optparser = optparse.OptionParser("""%prog [options]
+    optparser = optparse.OptionParser(
+        """%prog [options]
 
 This checks all help documents of Mercurial (topics, commands,
 extensions and commands of them), if no file is specified by --file
 option.
-""")
-    optparser.add_option("-v", "--verbose",
-                         help="enable additional output",
-                         action="store_true")
-    optparser.add_option("-d", "--debug",
-                         help="debug mode",
-                         action="store_true")
-    optparser.add_option("-f", "--file",
+"""
+    )
+    optparser.add_option(
+        "-v", "--verbose", help="enable additional output", action="store_true"
+    )
+    optparser.add_option(
+        "-d", "--debug", help="debug mode", action="store_true"
+    )
+    optparser.add_option(
+        "-f",
+        "--file",
                          help="filename to read in (or '-' for stdin)",
-                         action="store", default="")
+        action="store",
+        default="",
+    )
 
-    optparser.add_option("-t", "--topic",
+    optparser.add_option(
+        "-t",
+        "--topic",
                          help="parse file as help topic",
-                         action="store_const", dest="initlevel", const=0)
-    optparser.add_option("-c", "--command",
+        action="store_const",
+        dest="initlevel",
+        const=0,
+    )
+    optparser.add_option(
+        "-c",
+        "--command",
                          help="parse file as help of core command",
-                         action="store_const", dest="initlevel", const=1)
-    optparser.add_option("-e", "--extension",
+        action="store_const",
+        dest="initlevel",
+        const=1,
+    )
+    optparser.add_option(
+        "-e",
+        "--extension",
                          help="parse file as help of extension",
-                         action="store_const", dest="initlevel", const=1)
-    optparser.add_option("-C", "--extension-command",
+        action="store_const",
+        dest="initlevel",
+        const=1,
+    )
+    optparser.add_option(
+        "-C",
+        "--extension-command",
                          help="parse file as help of extension command",
-                         action="store_const", dest="initlevel", const=3)
+        action="store_const",
+        dest="initlevel",
+        const=3,
+    )
 
-    optparser.add_option("-l", "--initlevel",
+    optparser.add_option(
+        "-l",
+        "--initlevel",
                          help="set initial section level manually",
-                         action="store", type="int", default=0)
+        action="store",
+        type="int",
+        default=0,
+    )
 
     (options, args) = optparser.parse_args()
 
@@ -173,5 +222,6 b' option.'
         if checkhghelps(ui):
             sys.exit(1)
 
+
 if __name__ == "__main__":
     main()

doc/gendoc.py

@@ -12,6 +12,7 b' import textwrap'
 
 try:
     import msvcrt
+
     msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
     msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY)
 except ImportError:
@@ -22,10 +23,13 b' except ImportError:'
 os.environ[r'HGMODULEPOLICY'] = r'allow'
 # import from the live mercurial repo
 sys.path.insert(0, r"..")
-from mercurial import demandimport; demandimport.enable()
+from mercurial import demandimport
+
+demandimport.enable()
 # Load util so that the locale path is set by i18n.setdatapath() before
 # calling _().
 from mercurial import util
+
 util.datapath
 from mercurial import (
     commands,
@@ -46,6 +50,7 b' globalopts = commands.globalopts'
 helptable = help.helptable
 loaddoc = help.loaddoc
 
+
 def get_desc(docstr):
     if not docstr:
         return b"", b""
@@ -64,6 +69,7 b' def get_desc(docstr):'
 
     return (shortdesc, desc)
 
+
 def get_opts(opts):
     for opt in opts:
         if len(opt) == 5:
@@ -86,6 +92,7 b' def get_opts(opts):'
         desc += default and _(b" (default: %s)") % bytes(default) or b""
         yield (b", ".join(allopts), desc)
 
+
 def get_cmd(cmd, cmdtable):
     d = {}
     attr = cmdtable[cmd]
@@ -106,6 +113,7 b' def get_cmd(cmd, cmdtable):'
 
     return d
 
+
 def showdoc(ui):
     # print options
     ui.write(minirst.section(_(b"Options")))
@@ -127,14 +135,22 b' def showdoc(ui):'
     helpprinter(ui, helptable, minirst.section, exclude=[b'config'])
 
     ui.write(minirst.section(_(b"Extensions")))
-    ui.write(_(b"This section contains help for extensions that are "
+    ui.write(
+        _(
+            b"This section contains help for extensions that are "
                b"distributed together with Mercurial. Help for other "
-               b"extensions is available in the help system."))
-    ui.write((b"\n\n"
+            b"extensions is available in the help system."
+        )
+    )
+    ui.write(
+        (
+            b"\n\n"
               b".. contents::\n"
               b"   :class: htmlonly\n"
               b"   :local:\n"
-              b"   :depth: 1\n\n"))
+            b"   :depth: 1\n\n"
+        )
+    )
 
     for extensionname in sorted(allextensionnames()):
         mod = extensions.load(ui, extensionname, None)
@@ -143,24 +159,42 b' def showdoc(ui):'
         cmdtable = getattr(mod, 'cmdtable', None)
         if cmdtable:
             ui.write(minirst.subsubsection(_(b'Commands')))
-            commandprinter(ui, cmdtable, minirst.subsubsubsection,
-                    minirst.subsubsubsubsection)
+            commandprinter(
+                ui,
+                cmdtable,
+                minirst.subsubsubsection,
+                minirst.subsubsubsubsection,
+            )
+
 
 def showtopic(ui, topic):
     extrahelptable = [
         ([b"common"], b'', loaddoc(b'common'), help.TOPIC_CATEGORY_MISC),
         ([b"hg.1"], b'', loaddoc(b'hg.1'), help.TOPIC_CATEGORY_CONFIG),
         ([b"hg-ssh.8"], b'', loaddoc(b'hg-ssh.8'), help.TOPIC_CATEGORY_CONFIG),
-        ([b"hgignore.5"], b'', loaddoc(b'hgignore.5'),
-         help.TOPIC_CATEGORY_CONFIG),
+        (
+            [b"hgignore.5"],
+            b'',
+            loaddoc(b'hgignore.5'),
+            help.TOPIC_CATEGORY_CONFIG,
+        ),
         ([b"hgrc.5"], b'', loaddoc(b'hgrc.5'), help.TOPIC_CATEGORY_CONFIG),
-        ([b"hgignore.5.gendoc"], b'', loaddoc(b'hgignore'),
-         help.TOPIC_CATEGORY_CONFIG),
-        ([b"hgrc.5.gendoc"], b'', loaddoc(b'config'),
-         help.TOPIC_CATEGORY_CONFIG),
+        (
+            [b"hgignore.5.gendoc"],
+            b'',
+            loaddoc(b'hgignore'),
+            help.TOPIC_CATEGORY_CONFIG,
+        ),
+        (
+            [b"hgrc.5.gendoc"],
+            b'',
+            loaddoc(b'config'),
+            help.TOPIC_CATEGORY_CONFIG,
+        ),
     ]
     helpprinter(ui, helptable + extrahelptable, None, include=[topic])
 
+
 def helpprinter(ui, helptable, sectionfunc, include=[], exclude=[]):
     for h in helptable:
         names, sec, doc = h[0:3]
@@ -178,6 +212,7 b' def helpprinter(ui, helptable, sectionfu'
         ui.write(doc)
         ui.write(b"\n")
 
+
 def commandprinter(ui, cmdtable, sectionfunc, subsectionfunc):
     """Render restructuredtext describing a list of commands and their
     documentations, grouped by command category.
@@ -222,7 +257,8 b' def commandprinter(ui, cmdtable, section'
         if helpcategory(cmd) not in cmdsbycategory:
             raise AssertionError(
                 "The following command did not register its (category) in "
-                "help.CATEGORY_ORDER: %s (%s)" % (cmd, helpcategory(cmd)))
+                "help.CATEGORY_ORDER: %s (%s)" % (cmd, helpcategory(cmd))
+            )
         cmdsbycategory[helpcategory(cmd)].append(cmd)
 
     # Print the help for each command. We present the commands grouped by
@@ -270,16 +306,22 b' def commandprinter(ui, cmdtable, section'
                     if optstr.endswith(b"[+]>"):
                         multioccur = True
                 if multioccur:
-                    ui.write(_(b"\n[+] marked option can be specified"
-                               b" multiple times\n"))
+                    ui.write(
+                        _(
+                            b"\n[+] marked option can be specified"
+                            b" multiple times\n"
+                        )
+                    )
                 ui.write(b"\n")
             # aliases
             if d[b'aliases']:
                 ui.write(_(b"    aliases: %s\n\n") % b" ".join(d[b'aliases']))
 
+
 def allextensionnames():
     return set(extensions.enabled().keys()) | set(extensions.disabled().keys())
 
+
 if __name__ == "__main__":
     doc = b'hg.1.gendoc'
     if len(sys.argv) > 1:

doc/hgmanpage.py

@@ -53,6 +53,7 b' from docutils import ('
     nodes,
     writers,
 )
+
 try:
     import roman
 except ImportError:
@@ -65,7 +66,7 b' BLOCKQOUTE_INDENT = 3.5'
 
 # Define two macros so man/roff can calculate the
 # indent/unindent margins by itself
-MACRO_DEF = (r""".
+MACRO_DEF = r""".
 .nr rst2man-indent-level 0
 .
 .de1 rstReportMargin
@@ -92,11 +93,12 b' level margin: \\\\n[rst2man-indent\\\\n[rst2'
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-""")
+"""
+
 
 class Writer(writers.Writer):
 
-    supported = ('manpage')
+    supported = 'manpage'
     """Formats this writer supports."""
 
     output = None
@@ -118,11 +120,14 b' class Table(object):'
         self._options = ['center']
         self._tab_char = '\t'
         self._coldefs = []
+
     def new_row(self):
         self._rows.append([])
+
     def append_separator(self, separator):
         """Append the separator for table head."""
         self._rows.append([separator])
+
     def append_cell(self, cell_lines):
         """cell_lines is an array of lines"""
         start = 0
@@ -131,12 +136,14 b' class Table(object):'
         self._rows[-1].append(cell_lines[start:])
         if len(self._coldefs) < len(self._rows[-1]):
             self._coldefs.append('l')
+
     def _minimize_cell(self, cell_lines):
         """Remove leading and trailing blank and ``.sp`` lines"""
-        while (cell_lines and cell_lines[0] in ('\n', '.sp\n')):
+        while cell_lines and cell_lines[0] in ('\n', '.sp\n'):
             del cell_lines[0]
-        while (cell_lines and cell_lines[-1] in ('\n', '.sp\n')):
+        while cell_lines and cell_lines[-1] in ('\n', '.sp\n'):
             del cell_lines[-1]
+
     def as_list(self):
         text = ['.TS\n']
         text.append(' '.join(self._options) + ';\n')
@@ -159,6 +166,7 b' class Table(object):'
         text.append('.TE\n')
         return text
 
+
 class Translator(nodes.NodeVisitor):
     """"""
 
@@ -171,8 +179,9 b' class Translator(nodes.NodeVisitor):'
         lcode = settings.language_code
         arglen = len(inspect.getargspec(languages.get_language)[0])
         if arglen == 2:
-            self.language = languages.get_language(lcode,
-                                                   self.document.reporter)
+            self.language = languages.get_language(
+                lcode, self.document.reporter
+            )
         else:
             self.language = languages.get_language(lcode)
         self.head = []
@@ -189,9 +198,11 b' class Translator(nodes.NodeVisitor):'
         # writing the header .TH and .SH NAME is postboned after
         # docinfo.
         self._docinfo = {
-                "title" : "", "title_upper": "",
+            "title": "",
+            "title_upper": "",
                 "subtitle" : "",
-                "manual_section" : "", "manual_group" : "",
+            "manual_section": "",
+            "manual_group": "",
                 "author" : [],
                 "date" : "",
                 "copyright" : "",
@@ -222,18 +233,14 b' class Translator(nodes.NodeVisitor):'
                 'field_name' : ('.TP\n.B ', '\n'),
                 'literal' : ('\\fB', '\\fP'),
                 'literal_block' : ('.sp\n.nf\n.ft C\n', '\n.ft P\n.fi\n'),
-
                 'option_list_item' : ('.TP\n', ''),
-
                 'reference' : (r'\%', r'\:'),
                 'emphasis': ('\\fI', '\\fP'),
                 'strong' : ('\\fB', '\\fP'),
                 'term' : ('\n.B ', '\n'),
                 'title_reference' : ('\\fI', '\\fP'),
-
                 'topic-title' : ('.SS ',),
                 'sidebar-title' : ('.SS ',),
-
                 'problematic' : ('\n.nf\n', '\n.fi\n'),
                     }
         # NOTE don't specify the newline before a dot-command, but ensure
@@ -244,8 +251,8 b' class Translator(nodes.NodeVisitor):'
         line/comment."""
         prefix = '.\\" '
         out_text = ''.join(
-            [(prefix + in_line + '\n')
-            for in_line in text.split('\n')])
+            [(prefix + in_line + '\n') for in_line in text.split('\n')]
+        )
         return out_text
 
     def comment(self, text):
@@ -268,13 +275,18 b' class Translator(nodes.NodeVisitor):'
             if self.body[i] == '.sp\n':
                 if self.body[i - 1][:4] in ('.BI ','.IP '):
                     self.body[i] = '.\n'
-                elif (self.body[i - 1][:3] == '.B ' and
-                    self.body[i - 2][:4] == '.TP\n'):
+                elif (
+                    self.body[i - 1][:3] == '.B '
+                    and self.body[i - 2][:4] == '.TP\n'
+                ):
                     self.body[i] = '.\n'
-                elif (self.body[i - 1] == '\n' and
-                    self.body[i - 2][0] != '.' and
-                    (self.body[i - 3][:7] == '.TP\n.B '
-                        or self.body[i - 3][:4] == '\n.B ')
+                elif (
+                    self.body[i - 1] == '\n'
+                    and self.body[i - 2][0] != '.'
+                    and (
+                        self.body[i - 3][:7] == '.TP\n.B '
+                        or self.body[i - 3][:4] == '\n.B '
+                    )
                      ):
                     self.body[i] = '.\n'
         return ''.join(self.head + self.body + self.foot)
@@ -358,6 +370,7 b' class Translator(nodes.NodeVisitor):'
 
             def get_width(self):
                 return self._indent
+
             def __repr__(self):
                 return 'enum_style-%s' % list(self._style)
 
@@ -376,10 +389,12 b' class Translator(nodes.NodeVisitor):'
         self._list_char.pop()
 
     def header(self):
-        tmpl = (".TH %(title_upper)s %(manual_section)s"
+        tmpl = (
+            ".TH %(title_upper)s %(manual_section)s"
                 " \"%(date)s\" \"%(version)s\" \"%(manual_group)s\"\n"
                 ".SH NAME\n"
-                "%(title)s \\- %(subtitle)s\n")
+            "%(title)s \\- %(subtitle)s\n"
+        )
         return tmpl % self._docinfo
 
     def append_header(self):
@@ -400,8 +415,7 b' class Translator(nodes.NodeVisitor):'
 
     def visit_admonition(self, node, name=None):
         if name:
-            self.body.append('.IP %s\n' %
-                        self.language.labels.get(name, name))
+            self.body.append('.IP %s\n' % self.language.labels.get(name, name))
 
     def depart_admonition(self, node):
         self.body.append('.RE\n')
@@ -488,8 +502,7 b' class Translator(nodes.NodeVisitor):'
     def write_colspecs(self):
         self.body.append("%s.\n" % ('L '*len(self.colspecs)))
 
-    def visit_comment(self, node,
-                      sub=re.compile('-(?=-)').sub):
+    def visit_comment(self, node, sub=re.compile('-(?=-)').sub):
         self.body.append(self.comment(node.astext()))
         raise nodes.SkipNode()
 
@@ -575,21 +588,33 b' class Translator(nodes.NodeVisitor):'
 
     def depart_document(self, node):
         if self._docinfo['author']:
-            self.body.append('.SH AUTHOR\n%s\n'
-                    % ', '.join(self._docinfo['author']))
-        skip = ('author', 'copyright', 'date',
-                'manual_group', 'manual_section',
+            self.body.append(
+                '.SH AUTHOR\n%s\n' % ', '.join(self._docinfo['author'])
+            )
+        skip = (
+            'author',
+            'copyright',
+            'date',
+            'manual_group',
+            'manual_section',
                 'subtitle',
-                'title', 'title_upper', 'version')
+            'title',
+            'title_upper',
+            'version',
+        )
         for name in self._docinfo_keys:
             if name == 'address':
-                self.body.append("\n%s:\n%s%s.nf\n%s\n.fi\n%s%s" % (
+                self.body.append(
+                    "\n%s:\n%s%s.nf\n%s\n.fi\n%s%s"
+                    % (
                                     self.language.labels.get(name, name),
                                     self.defs['indent'][0] % 0,
                                     self.defs['indent'][0] % BLOCKQOUTE_INDENT,
                                     self._docinfo[name],
                                     self.defs['indent'][1],
-                                    self.defs['indent'][1]))
+                        self.defs['indent'][1],
+                    )
+                )
             elif name not in skip:
                 if name in self._docinfo_names:
                     label = self._docinfo_names[name]
@@ -597,10 +622,10 b' class Translator(nodes.NodeVisitor):'
                     label = self.language.labels.get(name, name)
                 self.body.append("\n%s: %s\n" % (label, self._docinfo[name]))
         if self._docinfo['copyright']:
-            self.body.append('.SH COPYRIGHT\n%s\n'
-                    % self._docinfo['copyright'])
-        self.body.append(self.comment(
-                        'Generated by docutils manpage writer.\n'))
+            self.body.append('.SH COPYRIGHT\n%s\n' % self._docinfo['copyright'])
+        self.body.append(
+            self.comment('Generated by docutils manpage writer.\n')
+        )
 
     def visit_emphasis(self, node):
         self.body.append(self.defs['emphasis'][0])
@@ -611,11 +636,13 b' class Translator(nodes.NodeVisitor):'
     def visit_entry(self, node):
         # a cell in a table row
         if 'morerows' in node:
-            self.document.reporter.warning('"table row spanning" not supported',
-                    base_node=node)
+            self.document.reporter.warning(
+                '"table row spanning" not supported', base_node=node
+            )
         if 'morecols' in node:
             self.document.reporter.warning(
-                    '"table cell spanning" not supported', base_node=node)
+                '"table cell spanning" not supported', base_node=node
+            )
         self.context.append(len(self.body))
 
     def depart_entry(self, node):
@@ -675,8 +702,7 b' class Translator(nodes.NodeVisitor):'
         self.dedent()
 
     def visit_footer(self, node):
-        self.document.reporter.warning('"footer" not supported',
-                base_node=node)
+        self.document.reporter.warning('"footer" not supported', base_node=node)
 
     def depart_footer(self, node):
         pass
@@ -690,8 +716,9 b' class Translator(nodes.NodeVisitor):'
         pass
 
     def footnote_backrefs(self, node):
-        self.document.reporter.warning('"footnote_backrefs" not supported',
-                base_node=node)
+        self.document.reporter.warning(
+            '"footnote_backrefs" not supported', base_node=node
+        )
 
     def visit_footnote_reference(self, node):
         self.body.append('['+self.deunicode(node.astext())+']')
@@ -736,8 +763,7 b' class Translator(nodes.NodeVisitor):'
         self.body.append('\n')
 
     def visit_image(self, node):
-        self.document.reporter.warning('"image" not supported',
-                base_node=node)
+        self.document.reporter.warning('"image" not supported', base_node=node)
         text = []
         if 'alt' in node.attributes:
             text.append(node.attributes['alt'])
@@ -753,11 +779,11 b' class Translator(nodes.NodeVisitor):'
 
     def visit_label(self, node):
         # footnote and citation
-        if (isinstance(node.parent, nodes.footnote)
-            or isinstance(node.parent, nodes.citation)):
+        if isinstance(node.parent, nodes.footnote) or isinstance(
+            node.parent, nodes.citation
+        ):
             raise nodes.SkipNode()
-        self.document.reporter.warning('"unsupported "label"',
-                base_node=node)
+        self.document.reporter.warning('"unsupported "label"', base_node=node)
         self.body.append('[')
 
     def depart_label(self, node):
@@ -794,9 +820,10 b' class Translator(nodes.NodeVisitor):'
 
     def visit_list_item(self, node):
         # man 7 man argues to use ".IP" instead of ".TP"
-        self.body.append('.IP %s %d\n' % (
-                next(self._list_char[-1]),
-                self._list_char[-1].get_width(),))
+        self.body.append(
+            '.IP %s %d\n'
+            % (next(self._list_char[-1]), self._list_char[-1].get_width(),)
+        )
 
     def depart_list_item(self, node):
         pass
@@ -968,8 +995,9 b' class Translator(nodes.NodeVisitor):'
         raise nodes.SkipNode()
 
     def visit_substitution_reference(self, node):
-        self.document.reporter.warning('"substitution_reference" not supported',
-                base_node=node)
+        self.document.reporter.warning(
+            '"substitution_reference" not supported', base_node=node
+        )
 
     def visit_subtitle(self, node):
         if isinstance(node.parent, nodes.sidebar):
@@ -995,8 +1023,10 b' class Translator(nodes.NodeVisitor):'
             line = ', line %s' % node['line']
         else:
             line = ''
-        self.body.append('.IP "System Message: %s/%s (%s:%s)"\n'
-                         % (node['type'], node['level'], node['source'], line))
+        self.body.append(
+            '.IP "System Message: %s/%s (%s:%s)"\n'
+            % (node['type'], node['level'], node['source'], line)
+        )
 
     def depart_system_message(self, node):
         pass
@@ -1111,7 +1141,9 b' class Translator(nodes.NodeVisitor):'
     depart_warning = depart_admonition
 
     def unimplemented_visit(self, node):
-        raise NotImplementedError('visiting unimplemented node type: %s'
-                                  % node.__class__.__name__)
+        raise NotImplementedError(
+            'visiting unimplemented node type: %s' % node.__class__.__name__
+        )
+
 
 # vim: set fileencoding=utf-8 et ts=4 ai :

hgdemandimport/__init__.py

@@ -71,8 +71,11 b' isenabled = demandimport.isenabled'
 disable = demandimport.disable
 deactivated = demandimport.deactivated
 
+
 def enable():
     # chg pre-imports modules so do not enable demandimport for it
-    if ('CHGINTERNALMARK' not in os.environ
-        and os.environ.get('HGDEMANDIMPORT') != 'disable'):
+    if (
+        'CHGINTERNALMARK' not in os.environ
+        and os.environ.get('HGDEMANDIMPORT') != 'disable'
+    ):
         demandimport.enable()

hgdemandimport/demandimportpy2.py

@@ -38,6 +38,7 b' contextmanager = contextlib.contextmanag'
 
 nothing = object()
 
+
 def _hgextimport(importfunc, name, globals, *args, **kwargs):
     try:
         return importfunc(name, globals, *args, **kwargs)
@@ -53,6 +54,7 b' def _hgextimport(importfunc, name, globa'
         # retry to import with "hgext_" prefix
         return importfunc(hgextname, globals, *args, **kwargs)
 
+
 class _demandmod(object):
     """module demand-loader and proxy
 
@@ -67,8 +69,9 b' class _demandmod(object):'
         else:
             head = name
             after = []
-        object.__setattr__(self, r"_data",
-                           (head, globals, locals, after, level, set()))
+        object.__setattr__(
+            self, r"_data", (head, globals, locals, after, level, set())
+        )
         object.__setattr__(self, r"_module", None)
 
     def _extend(self, name):
@@ -91,7 +94,8 b' class _demandmod(object):'
             with tracing.log('demandimport %s', self._data[0]):
                 head, globals, locals, after, level, modrefs = self._data
                 mod = _hgextimport(
-                    _origimport, head, globals, locals, None, level)
+                    _origimport, head, globals, locals, None, level
+                )
                 if mod is self:
                     # In this case, _hgextimport() above should imply
                     # _demandimport(). Otherwise, _hgextimport() never
@@ -115,8 +119,11 b' class _demandmod(object):'
                     if '.' in p:
                         h, t = p.split('.', 1)
                     if getattr(mod, h, nothing) is nothing:
-                        setattr(mod, h, _demandmod(
-                            p, mod.__dict__, mod.__dict__, level=1))
+                        setattr(
+                            mod,
+                            h,
+                            _demandmod(p, mod.__dict__, mod.__dict__, level=1),
+                        )
                     elif t:
                         subload(getattr(mod, h), t)
 
@@ -164,8 +171,10 b' class _demandmod(object):'
         self._load()
         return self._module.__doc__
 
+
 _pypy = '__pypy__' in sys.builtin_module_names
 
+
 def _demandimport(name, globals=None, locals=None, fromlist=None, level=-1):
     if locals is None or name in ignores or fromlist == ('*',):
         # these cases we can't really delay
@@ -244,8 +253,9 b' def _demandimport(name, globals=None, lo'
         if level >= 0:
             if name:
                 # "from a import b" or "from .a import b" style
-                rootmod = _hgextimport(_origimport, name, globals, locals,
-                                       level=level)
+                rootmod = _hgextimport(
+                    _origimport, name, globals, locals, level=level
+                )
                 mod = chainmodules(rootmod, name)
             elif _pypy:
                 # PyPy's __import__ throws an exception if invoked
@@ -260,8 +270,9 b' def _demandimport(name, globals=None, lo'
                     mn = mn.rsplit('.', level - 1)[0]
                     mod = sys.modules[mn]
             else:
-                mod = _hgextimport(_origimport, name, globals, locals,
-                                   level=level)
+                mod = _hgextimport(
+                    _origimport, name, globals, locals, level=level
+                )
 
             for x in fromlist:
                 processfromitem(mod, x)
@@ -278,23 +289,29 b' def _demandimport(name, globals=None, lo'
 
         return mod
 
+
 ignores = set()
 
+
 def init(ignoreset):
     global ignores
     ignores = ignoreset
 
+
 def isenabled():
     return builtins.__import__ == _demandimport
 
+
 def enable():
     "enable global demand-loading of modules"
     builtins.__import__ = _demandimport
 
+
 def disable():
     "disable global demand-loading of modules"
     builtins.__import__ = _origimport
 
+
 @contextmanager
 def deactivated():
     "context manager for disabling demandimport in 'with' blocks"

hgdemandimport/demandimportpy3.py

@@ -36,10 +36,12 b' from . import tracing'
 
 _deactivated = False
 
+
 class _lazyloaderex(importlib.util.LazyLoader):
     """This is a LazyLoader except it also follows the _deactivated global and
     the ignore list.
     """
+
     def exec_module(self, module):
         """Make the module load lazily."""
         with tracing.log('demandimport %s', module):
@@ -48,14 +50,18 b' class _lazyloaderex(importlib.util.LazyL'
             else:
                 super().exec_module(module)
 
+
 # This is 3.6+ because with Python 3.5 it isn't possible to lazily load
 # extensions. See the discussion in https://bugs.python.org/issue26186 for more.
 _extensions_loader = _lazyloaderex.factory(
-    importlib.machinery.ExtensionFileLoader)
+    importlib.machinery.ExtensionFileLoader
+)
 _bytecode_loader = _lazyloaderex.factory(
-    importlib.machinery.SourcelessFileLoader)
+    importlib.machinery.SourcelessFileLoader
+)
 _source_loader = _lazyloaderex.factory(importlib.machinery.SourceFileLoader)
 
+
 def _makefinder(path):
     return importlib.machinery.FileFinder(
         path,
@@ -65,15 +71,19 b' def _makefinder(path):'
         (_bytecode_loader, importlib.machinery.BYTECODE_SUFFIXES),
     )
 
+
 ignores = set()
 
+
 def init(ignoreset):
     global ignores
     ignores = ignoreset
 
+
 def isenabled():
     return _makefinder in sys.path_hooks and not _deactivated
 
+
 def disable():
     try:
         while True:
@@ -81,9 +91,11 b' def disable():'
     except ValueError:
         pass
 
+
 def enable():
     sys.path_hooks.insert(0, _makefinder)
 
+
 @contextlib.contextmanager
 def deactivated():
     # This implementation is a bit different from Python 2's. Python 3

hgdemandimport/tracing.py

@@ -14,6 +14,7 b' import os'
 _checked = False
 _session = 'none'
 
+
 def _isactive():
     global _pipe, _session, _checked
     if _pipe is None:
@@ -26,6 +27,7 b' def _isactive():'
         _session = os.environ.get('HGCATAPULTSESSION', 'none')
     return True
 
+
 @contextlib.contextmanager
 def log(whencefmt, *whenceargs):
     if not _isactive():
@@ -48,6 +50,7 b' def log(whencefmt, *whenceargs):'
         except IOError:
             pass
 
+
 def counter(label, amount, *labelargs):
     if not _isactive():
         return

hgext/__init__.py

@@ -1,3 +1,4 b''
 from __future__ import absolute_import
 import pkgutil
+
 __path__ = pkgutil.extend_path(__path__, __name__)

hgext/absorb.py

@@ -53,9 +53,7 b' from mercurial import ('
     scmutil,
     util,
 )
-from mercurial.utils import (
-    stringutil,
-)
+from mercurial.utils import stringutil
 
 # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
@@ -81,8 +79,10 b' colortable = {'
 
 defaultdict = collections.defaultdict
 
+
 class nullui(object):
     """blank ui object doing nothing"""
+
     debugflag = False
     verbose = False
     quiet = True
@@ -90,16 +90,20 b' class nullui(object):'
     def __getitem__(name):
         def nullfunc(*args, **kwds):
             return
+
         return nullfunc
 
+
 class emptyfilecontext(object):
     """minimal filecontext representing an empty file"""
+
     def data(self):
         return ''
 
     def node(self):
         return node.nullid
 
+
 def uniq(lst):
     """list -> list. remove duplicated items without changing the order"""
     seen = set()
@@ -110,6 +114,7 b' def uniq(lst):'
             result.append(x)
     return result
 
+
 def getdraftstack(headctx, limit=None):
     """(ctx, int?) -> [ctx]. get a linear stack of non-public changesets.
 
@@ -132,6 +137,7 b' def getdraftstack(headctx, limit=None):'
     result.reverse()
     return result
 
+
 def getfilestack(stack, path, seenfctxs=None):
     """([ctx], str, set) -> [fctx], {ctx: fctx}
 
@@ -213,10 +219,12 b' def getfilestack(stack, path, seenfctxs='
     # remove uniq and find a different way to identify fctxs.
     return uniq(fctxs), fctxmap
 
+
 class overlaystore(patch.filestore):
     """read-only, hybrid store based on a dict and ctx.
     memworkingcopy: {path: content}, overrides file contents.
     """
+
     def __init__(self, basectx, memworkingcopy):
         self.basectx = basectx
         self.memworkingcopy = memworkingcopy
@@ -234,6 +242,7 b' class overlaystore(patch.filestore):'
         copy = fctx.copysource()
         return content, mode, copy
 
+
 def overlaycontext(memworkingcopy, ctx, parents=None, extra=None):
     """({path: content}, ctx, (p1node, p2node)?, {}?) -> memctx
     memworkingcopy overrides file contents.
@@ -249,9 +258,17 b' def overlaycontext(memworkingcopy, ctx, '
     files = set(ctx.files()).union(memworkingcopy)
     store = overlaystore(ctx, memworkingcopy)
     return context.memctx(
-        repo=ctx.repo(), parents=parents, text=desc,
-        files=files, filectxfn=store, user=user, date=date,
-        branch=None, extra=extra)
+        repo=ctx.repo(),
+        parents=parents,
+        text=desc,
+        files=files,
+        filectxfn=store,
+        user=user,
+        date=date,
+        branch=None,
+        extra=extra,
+    )
+
 
 class filefixupstate(object):
     """state needed to apply fixups to a single file
@@ -346,9 +363,10 b' class filefixupstate(object):'
             blines = self.targetlines[b1:b2]
             if self.ui.debugflag:
                 idx = (max(rev - 1, 0)) // 2
-                self.ui.write(_('%s: chunk %d:%d -> %d lines\n')
-                              % (node.short(self.fctxs[idx].node()),
-                                 a1, a2, len(blines)))
+                self.ui.write(
+                    _('%s: chunk %d:%d -> %d lines\n')
+                    % (node.short(self.fctxs[idx].node()), a1, a2, len(blines))
+                )
             self.linelog.replacelines(rev, a1, a2, b1, b2)
         if self.opts.get('edit_lines', False):
             self.finalcontents = self._checkoutlinelogwithedits()
@@ -386,8 +404,9 b' class filefixupstate(object):'
             # pure insertion, check nearby lines. ignore lines belong
             # to the public (first) changeset (i.e. annotated[i][0] == 1)
             nearbylinenums = {a2, max(0, a1 - 1)}
-            involved = [annotated[i]
-                        for i in nearbylinenums if annotated[i][0] != 1]
+            involved = [
+                annotated[i] for i in nearbylinenums if annotated[i][0] != 1
+            ]
         involvedrevs = list(set(r for r, l in involved))
         newfixups = []
         if len(involvedrevs) == 1 and self._iscontinuous(a1, a2 - 1, True):
@@ -448,18 +467,26 b' class filefixupstate(object):'
         """() -> [str]. prompt all lines for edit"""
         alllines = self.linelog.getalllines()
         # header
-        editortext = (_('HG: editing %s\nHG: "y" means the line to the right '
-                        'exists in the changeset to the top\nHG:\n')
-                      % self.fctxs[-1].path())
+        editortext = (
+            _(
+                'HG: editing %s\nHG: "y" means the line to the right '
+                'exists in the changeset to the top\nHG:\n'
+            )
+            % self.fctxs[-1].path()
+        )
         # [(idx, fctx)]. hide the dummy emptyfilecontext
-        visiblefctxs = [(i, f)
+        visiblefctxs = [
+            (i, f)
                         for i, f in enumerate(self.fctxs)
-                        if not isinstance(f, emptyfilecontext)]
+            if not isinstance(f, emptyfilecontext)
+        ]
         for i, (j, f) in enumerate(visiblefctxs):
-            editortext += (_('HG: %s/%s %s %s\n') %
-                           ('|' * i, '-' * (len(visiblefctxs) - i + 1),
+            editortext += _('HG: %s/%s %s %s\n') % (
+                '|' * i,
+                '-' * (len(visiblefctxs) - i + 1),
                             node.short(f.node()),
-                            f.description().split('\n',1)[0]))
+                f.description().split('\n', 1)[0],
+            )
         editortext += _('HG: %s\n') % ('|' * len(visiblefctxs))
         # figure out the lifetime of a line, this is relatively inefficient,
         # but probably fine
@@ -470,10 +497,15 b' class filefixupstate(object):'
                 lineset[l].add(i)
         # append lines
         for l in alllines:
-            editortext += ('    %s : %s' %
-                           (''.join([('y' if i in lineset[l] else ' ')
-                                     for i, _f in visiblefctxs]),
-                            self._getline(l)))
+            editortext += '    %s : %s' % (
+                ''.join(
+                    [
+                        ('y' if i in lineset[l] else ' ')
+                        for i, _f in visiblefctxs
+                    ]
+                ),
+                self._getline(l),
+            )
         # run editor
         editedtext = self.ui.edit(editortext, '', action='absorb')
         if not editedtext:
@@ -489,7 +521,8 b' class filefixupstate(object):'
                 raise error.Abort(_('malformed line: %s') % l)
             linecontent = l[colonpos + 2:]
             for i, ch in enumerate(
-                    pycompat.bytestr(l[leftpadpos:colonpos - 1])):
+                pycompat.bytestr(l[leftpadpos : colonpos - 1])
+            ):
                 if ch == 'y':
                     contents[visiblefctxs[i][0]] += linecontent
         # chunkstats is hard to calculate if anything changes, therefore
@@ -539,8 +572,12 b' class filefixupstate(object):'
             lastrev = pcurrentchunk[0][0]
             lasta2 = pcurrentchunk[0][2]
             lastb2 = pcurrentchunk[0][4]
-            if (a1 == lasta2 and b1 == lastb2 and rev == lastrev and
-                    self._iscontinuous(max(a1 - 1, 0), a1)):
+            if (
+                a1 == lasta2
+                and b1 == lastb2
+                and rev == lastrev
+                and self._iscontinuous(max(a1 - 1, 0), a1)
+            ):
                 # merge into currentchunk
                 pcurrentchunk[0][2] = a2
                 pcurrentchunk[0][4] = b2
@@ -551,7 +588,6 b' class filefixupstate(object):'
         return result
 
     def _showchanges(self, fm, alines, blines, chunk, fixups):
-
         def trim(line):
             if line.endswith('\n'):
                 line = line[:-1]
@@ -568,9 +604,12 b' class filefixupstate(object):'
                 bidxs[i - b1] = (max(idx, 1) - 1) // 2
 
         fm.startitem()
-        fm.write('hunk', '        %s\n',
-                 '@@ -%d,%d +%d,%d @@'
-                 % (a1, a2 - a1, b1, b2 - b1), label='diff.hunk')
+        fm.write(
+            'hunk',
+            '        %s\n',
+            '@@ -%d,%d +%d,%d @@' % (a1, a2 - a1, b1, b2 - b1),
+            label='diff.hunk',
+        )
         fm.data(path=self.path, linetype='hunk')
 
         def writeline(idx, diffchar, line, linetype, linelabel):
@@ -582,16 +621,24 b' class filefixupstate(object):'
                 node = ctx.hex()
                 self.ctxaffected.add(ctx.changectx())
             fm.write('node', '%-7.7s ', node, label='absorb.node')
-            fm.write('diffchar ' + linetype, '%s%s\n', diffchar, line,
-                     label=linelabel)
+            fm.write(
+                'diffchar ' + linetype,
+                '%s%s\n',
+                diffchar,
+                line,
+                label=linelabel,
+            )
             fm.data(path=self.path, linetype=linetype)
 
         for i in pycompat.xrange(a1, a2):
-            writeline(aidxs[i - a1], '-', trim(alines[i]), 'deleted',
-                      'diff.deleted')
+            writeline(
+                aidxs[i - a1], '-', trim(alines[i]), 'deleted', 'diff.deleted'
+            )
         for i in pycompat.xrange(b1, b2):
-            writeline(bidxs[i - b1], '+', trim(blines[i]), 'inserted',
-                      'diff.inserted')
+            writeline(
+                bidxs[i - b1], '+', trim(blines[i]), 'inserted', 'diff.inserted'
+            )
+
 
 class fixupstate(object):
     """state needed to run absorb
@@ -648,9 +695,11 b' class fixupstate(object):'
             targetfctx = targetctx[path]
             fctxs, ctx2fctx = getfilestack(self.stack, path, seenfctxs)
             # ignore symbolic links or binary, or unchanged files
-            if any(f.islink() or stringutil.binary(f.data())
+            if any(
+                f.islink() or stringutil.binary(f.data())
                    for f in [targetfctx] + fctxs
-                   if not isinstance(f, emptyfilecontext)):
+                if not isinstance(f, emptyfilecontext)
+            ):
                 continue
             if targetfctx.data() == fctxs[-1].data() and not editopt:
                 continue
@@ -677,8 +726,10 b' class fixupstate(object):'
     @property
     def chunkstats(self):
         """-> {path: chunkstats}. collect chunkstats from filefixupstates"""
-        return dict((path, state.chunkstats)
-                    for path, state in self.fixupmap.iteritems())
+        return dict(
+            (path, state.chunkstats)
+            for path, state in self.fixupmap.iteritems()
+        )
 
     def commit(self):
         """commit changes. update self.finalnode, self.replacemap"""
@@ -698,8 +749,10 b' class fixupstate(object):'
             # chunkstats for each file
             for path, stat in chunkstats.iteritems():
                 if stat[0]:
-                    ui.write(_('%s: %d of %d chunk(s) applied\n')
-                             % (path, stat[0], stat[1]))
+                    ui.write(
+                        _('%s: %d of %d chunk(s) applied\n')
+                        % (path, stat[0], stat[1])
+                    )
         elif not ui.quiet:
             # a summary for all files
             stats = chunkstats.values()
@@ -733,7 +786,9 b' class fixupstate(object):'
                 self.replacemap[ctx.node()] = lastcommitted.node()
                 if memworkingcopy:
                     msg = _('%d file(s) changed, became %s') % (
-                        len(memworkingcopy), self._ctx2str(lastcommitted))
+                        len(memworkingcopy),
+                        self._ctx2str(lastcommitted),
+                    )
                 else:
                     msg = _('became %s') % self._ctx2str(lastcommitted)
             if self.ui.verbose and msg:
@@ -766,16 +821,19 b' class fixupstate(object):'
 
     def _movebookmarks(self, tr):
         repo = self.repo
-        needupdate = [(name, self.replacemap[hsh])
+        needupdate = [
+            (name, self.replacemap[hsh])
                       for name, hsh in repo._bookmarks.iteritems()
-                      if hsh in self.replacemap]
+            if hsh in self.replacemap
+        ]
         changes = []
         for name, hsh in needupdate:
             if hsh:
                 changes.append((name, hsh))
                 if self.ui.verbose:
-                    self.ui.write(_('moving bookmark %s to %s\n')
-                                  % (name, node.hex(hsh)))
+                    self.ui.write(
+                        _('moving bookmark %s to %s\n') % (name, node.hex(hsh))
+                    )
             else:
                 changes.append((name, None))
                 if self.ui.verbose:
@@ -798,8 +856,10 b' class fixupstate(object):'
         restore = noop
         if util.safehasattr(dirstate, '_fsmonitorstate'):
             bak = dirstate._fsmonitorstate.invalidate
+
             def restore():
                 dirstate._fsmonitorstate.invalidate = bak
+
             dirstate._fsmonitorstate.invalidate = noop
         try:
             with dirstate.parentchange():
@@ -852,11 +912,15 b' class fixupstate(object):'
         return obsolete.isenabled(self.repo, obsolete.createmarkersopt)
 
     def _cleanupoldcommits(self):
-        replacements = {k: ([v] if v is not None else [])
-                        for k, v in self.replacemap.iteritems()}
+        replacements = {
+            k: ([v] if v is not None else [])
+            for k, v in self.replacemap.iteritems()
+        }
         if replacements:
-            scmutil.cleanupnodes(self.repo, replacements, operation='absorb',
-                                 fixphase=True)
+            scmutil.cleanupnodes(
+                self.repo, replacements, operation='absorb', fixphase=True
+            )
+
 
 def _parsechunk(hunk):
     """(crecord.uihunk or patch.recordhunk) -> (path, (a1, a2, [bline]))"""
@@ -874,6 +938,7 b' def _parsechunk(hunk):'
     blines = [l[1:] for l in patchlines[1:] if not l.startswith('-')]
     return path, (a1, a2, blines)
 
+
 def overlaydiffcontext(ctx, chunks):
     """(ctx, [crecord.uihunk]) -> memctx
 
@@ -905,6 +970,7 b' def overlaydiffcontext(ctx, chunks):'
         memworkingcopy[path] = ''.join(lines)
     return overlaycontext(memworkingcopy, ctx)
 
+
 def absorb(ui, repo, stack=None, targetctx=None, pats=None, opts=None):
     """pick fixup chunks from targetctx, apply them to stack.
 
@@ -919,9 +985,10 b' def absorb(ui, repo, stack=None, targetc'
             raise error.Abort(_('cannot absorb into a merge'))
         stack = getdraftstack(headctx, limit)
         if limit and len(stack) >= limit:
-            ui.warn(_('absorb: only the recent %d changesets will '
-                      'be analysed\n')
-                    % limit)
+            ui.warn(
+                _('absorb: only the recent %d changesets will ' 'be analysed\n')
+                % limit
+            )
     if not stack:
         raise error.Abort(_('no mutable changeset to change'))
     if targetctx is None: # default to working copy
@@ -953,13 +1020,19 b' def absorb(ui, repo, stack=None, targetc'
             fm.data(linetype='changeset')
             fm.write('node', '%-7.7s ', ctx.hex(), label='absorb.node')
             descfirstline = ctx.description().splitlines()[0]
-            fm.write('descfirstline', '%s\n', descfirstline,
-                     label='absorb.description')
+            fm.write(
+                'descfirstline',
+                '%s\n',
+                descfirstline,
+                label='absorb.description',
+            )
         fm.end()
     if not opts.get('dry_run'):
-        if (not opts.get('apply_changes') and
-            state.ctxaffected and
-            ui.promptchoice("apply changes (yn)? $$ &Yes $$ &No", default=1)):
+        if (
+            not opts.get('apply_changes')
+            and state.ctxaffected
+            and ui.promptchoice("apply changes (yn)? $$ &Yes $$ &No", default=1)
+        ):
             raise error.Abort(_('absorb cancelled\n'))
 
         state.apply()
@@ -969,20 +1042,45 b' def absorb(ui, repo, stack=None, targetc'
             ui.write(_('nothing applied\n'))
     return state
 
-@command('absorb',
-         [('a', 'apply-changes', None,
-           _('apply changes without prompting for confirmation')),
-          ('p', 'print-changes', None,
-           _('always print which changesets are modified by which changes')),
-          ('i', 'interactive', None,
-           _('interactively select which chunks to apply (EXPERIMENTAL)')),
-          ('e', 'edit-lines', None,
-           _('edit what lines belong to which changesets before commit '
-             '(EXPERIMENTAL)')),
-         ] + commands.dryrunopts + commands.templateopts + commands.walkopts,
+
+@command(
+    'absorb',
+    [
+        (
+            'a',
+            'apply-changes',
+            None,
+            _('apply changes without prompting for confirmation'),
+        ),
+        (
+            'p',
+            'print-changes',
+            None,
+            _('always print which changesets are modified by which changes'),
+        ),
+        (
+            'i',
+            'interactive',
+            None,
+            _('interactively select which chunks to apply (EXPERIMENTAL)'),
+        ),
+        (
+            'e',
+            'edit-lines',
+            None,
+            _(
+                'edit what lines belong to which changesets before commit '
+                '(EXPERIMENTAL)'
+            ),
+        ),
+    ]
+    + commands.dryrunopts
+    + commands.templateopts
+    + commands.walkopts,
          _('hg absorb [OPTION] [FILE]...'),
          helpcategory=command.CATEGORY_COMMITTING,
-         helpbasic=True)
+    helpbasic=True,
+)
 def absorbcmd(ui, repo, *pats, **opts):
     """incorporate corrections into the stack of draft changesets
 

hgext/acl.py

@@ -224,9 +224,7 b' from mercurial import ('
     registrar,
     util,
 )
-from mercurial.utils import (
-    procutil,
-)
+from mercurial.utils import procutil
 
 urlreq = util.urlreq
 
@@ -240,33 +238,29 b' configtable = {}'
 configitem = registrar.configitem(configtable)
 
 # deprecated config: acl.config
-configitem('acl', 'config',
-    default=None,
+configitem(
+    'acl', 'config', default=None,
 )
-configitem('acl.groups', '.*',
-    default=None,
-    generic=True,
+configitem(
+    'acl.groups', '.*', default=None, generic=True,
 )
-configitem('acl.deny.branches', '.*',
-    default=None,
-    generic=True,
+configitem(
+    'acl.deny.branches', '.*', default=None, generic=True,
 )
-configitem('acl.allow.branches', '.*',
-    default=None,
-    generic=True,
+configitem(
+    'acl.allow.branches', '.*', default=None, generic=True,
 )
-configitem('acl.deny', '.*',
-    default=None,
-    generic=True,
+configitem(
+    'acl.deny', '.*', default=None, generic=True,
 )
-configitem('acl.allow', '.*',
-    default=None,
-    generic=True,
+configitem(
+    'acl.allow', '.*', default=None, generic=True,
 )
-configitem('acl', 'sources',
-    default=lambda: ['serve'],
+configitem(
+    'acl', 'sources', default=lambda: ['serve'],
 )
 
+
 def _getusers(ui, group):
 
     # First, try to use group definition from section [acl.groups]
@@ -281,6 +275,7 b' def _getusers(ui, group):'
     except KeyError:
         raise error.Abort(_("group '%s' is undefined") % group)
 
+
 def _usermatch(ui, user, usersorgroups):
 
     if usersorgroups == '*':
@@ -293,29 +288,35 b' def _usermatch(ui, user, usersorgroups):'
             # if ug is a user  name: !username
             # if ug is a group name: !@groupname
             ug = ug[1:]
-            if (not ug.startswith('@') and user != ug
-                or ug.startswith('@') and user not in _getusers(ui, ug[1:])):
+            if (
+                not ug.startswith('@')
+                and user != ug
+                or ug.startswith('@')
+                and user not in _getusers(ui, ug[1:])
+            ):
                 return True
 
         # Test for user or group. Format:
         # if ug is a user  name: username
         # if ug is a group name: @groupname
-        elif (user == ug
-              or ug.startswith('@') and user in _getusers(ui, ug[1:])):
+        elif user == ug or ug.startswith('@') and user in _getusers(ui, ug[1:]):
             return True
 
     return False
 
+
 def buildmatch(ui, repo, user, key):
     '''return tuple of (match function, list enabled).'''
     if not ui.has_section(key):
         ui.debug('acl: %s not enabled\n' % key)
         return None
 
-    pats = [pat for pat, users in ui.configitems(key)
-            if _usermatch(ui, user, users)]
-    ui.debug('acl: %s enabled, %d entries for user %s\n' %
-             (key, len(pats), user))
+    pats = [
+        pat for pat, users in ui.configitems(key) if _usermatch(ui, user, users)
+    ]
+    ui.debug(
+        'acl: %s enabled, %d entries for user %s\n' % (key, len(pats), user)
+    )
 
     # Branch-based ACL
     if not repo:
@@ -332,6 +333,7 b' def buildmatch(ui, repo, user, key):'
         return match.match(repo.root, '', pats)
     return util.never
 
+
 def ensureenabled(ui):
     """make sure the extension is enabled when used as hook
 
@@ -345,16 +347,22 b' def ensureenabled(ui):'
     ui.setconfig('extensions', 'acl', '', source='internal')
     extensions.loadall(ui, ['acl'])
 
+
 def hook(ui, repo, hooktype, node=None, source=None, **kwargs):
 
     ensureenabled(ui)
 
     if hooktype not in ['pretxnchangegroup', 'pretxncommit', 'prepushkey']:
         raise error.Abort(
-            _('config error - hook type "%s" cannot stop '
-              'incoming changesets, commits, nor bookmarks') % hooktype)
-    if (hooktype == 'pretxnchangegroup' and
-        source not in ui.configlist('acl', 'sources')):
+            _(
+                'config error - hook type "%s" cannot stop '
+                'incoming changesets, commits, nor bookmarks'
+            )
+            % hooktype
+        )
+    if hooktype == 'pretxnchangegroup' and source not in ui.configlist(
+        'acl', 'sources'
+    ):
         ui.debug('acl: changes have source "%s" - skipping\n' % source)
         return
 
@@ -374,6 +382,7 b' def hook(ui, repo, hooktype, node=None, '
     else:
         _txnhook(ui, repo, hooktype, node, source, user, **kwargs)
 
+
 def _pkhook(ui, repo, hooktype, node, source, user, **kwargs):
     if kwargs[r'namespace'] == 'bookmarks':
         bookmark = kwargs[r'key']
@@ -382,22 +391,38 b' def _pkhook(ui, repo, hooktype, node, so'
         denybookmarks = buildmatch(ui, None, user, 'acl.deny.bookmarks')
 
         if denybookmarks and denybookmarks(bookmark):
-            raise error.Abort(_('acl: user "%s" denied on bookmark "%s"'
-                               ' (changeset "%s")')
-                               % (user, bookmark, ctx))
+            raise error.Abort(
+                _('acl: user "%s" denied on bookmark "%s"' ' (changeset "%s")')
+                % (user, bookmark, ctx)
+            )
         if allowbookmarks and not allowbookmarks(bookmark):
-            raise error.Abort(_('acl: user "%s" not allowed on bookmark "%s"'
-                               ' (changeset "%s")')
-                               % (user, bookmark, ctx))
-        ui.debug('acl: bookmark access granted: "%s" on bookmark "%s"\n'
-                 % (ctx, bookmark))
+            raise error.Abort(
+                _(
+                    'acl: user "%s" not allowed on bookmark "%s"'
+                    ' (changeset "%s")'
+                )
+                % (user, bookmark, ctx)
+            )
+        ui.debug(
+            'acl: bookmark access granted: "%s" on bookmark "%s"\n'
+            % (ctx, bookmark)
+        )
+
 
 def _txnhook(ui, repo, hooktype, node, source, user, **kwargs):
     # deprecated config: acl.config
     cfg = ui.config('acl', 'config')
     if cfg:
-        ui.readconfig(cfg, sections=['acl.groups', 'acl.allow.branches',
-            'acl.deny.branches', 'acl.allow', 'acl.deny'])
+        ui.readconfig(
+            cfg,
+            sections=[
+                'acl.groups',
+                'acl.allow.branches',
+                'acl.deny.branches',
+                'acl.allow',
+                'acl.deny',
+            ],
+        )
 
     allowbranches = buildmatch(ui, None, user, 'acl.allow.branches')
     denybranches = buildmatch(ui, None, user, 'acl.deny.branches')
@@ -408,21 +433,31 b' def _txnhook(ui, repo, hooktype, node, s'
         ctx = repo[rev]
         branch = ctx.branch()
         if denybranches and denybranches(branch):
-            raise error.Abort(_('acl: user "%s" denied on branch "%s"'
-                               ' (changeset "%s")')
-                               % (user, branch, ctx))
+            raise error.Abort(
+                _('acl: user "%s" denied on branch "%s"' ' (changeset "%s")')
+                % (user, branch, ctx)
+            )
         if allowbranches and not allowbranches(branch):
-            raise error.Abort(_('acl: user "%s" not allowed on branch "%s"'
-                               ' (changeset "%s")')
-                               % (user, branch, ctx))
-        ui.debug('acl: branch access granted: "%s" on branch "%s"\n'
-        % (ctx, branch))
+            raise error.Abort(
+                _(
+                    'acl: user "%s" not allowed on branch "%s"'
+                    ' (changeset "%s")'
+                )
+                % (user, branch, ctx)
+            )
+        ui.debug(
+            'acl: branch access granted: "%s" on branch "%s"\n' % (ctx, branch)
+        )
 
         for f in ctx.files():
             if deny and deny(f):
-                raise error.Abort(_('acl: user "%s" denied on "%s"'
-                ' (changeset "%s")') % (user, f, ctx))
+                raise error.Abort(
+                    _('acl: user "%s" denied on "%s"' ' (changeset "%s")')
+                    % (user, f, ctx)
+                )
             if allow and not allow(f):
-                raise error.Abort(_('acl: user "%s" not allowed on "%s"'
-                ' (changeset "%s")') % (user, f, ctx))
+                raise error.Abort(
+                    _('acl: user "%s" not allowed on "%s"' ' (changeset "%s")')
+                    % (user, f, ctx)
+                )
         ui.debug('acl: path access granted: "%s"\n' % ctx)

hgext/amend.py

@@ -29,20 +29,35 b" testedwith = 'ships-with-hg-core'"
 cmdtable = {}
 command = registrar.command(cmdtable)
 
-@command('amend',
-    [('A', 'addremove', None,
-      _('mark new/missing files as added/removed before committing')),
+
+@command(
+    'amend',
+    [
+        (
+            'A',
+            'addremove',
+            None,
+            _('mark new/missing files as added/removed before committing'),
+        ),
      ('e', 'edit', None, _('invoke editor on commit messages')),
      ('i', 'interactive', None, _('use interactive mode')),
-     (b'', b'close-branch', None,
-      _(b'mark a branch as closed, hiding it from the branch list')),
+        (
+            b'',
+            b'close-branch',
+            None,
+            _(b'mark a branch as closed, hiding it from the branch list'),
+        ),
      (b's', b'secret', None, _(b'use the secret phase for committing')),
      ('n', 'note', '', _('store a note on the amend')),
-    ] + cmdutil.walkopts + cmdutil.commitopts + cmdutil.commitopts2
+    ]
+    + cmdutil.walkopts
+    + cmdutil.commitopts
+    + cmdutil.commitopts2
       + cmdutil.commitopts3,
     _('[OPTION]... [FILE]...'),
     helpcategory=command.CATEGORY_COMMITTING,
-    inferrepo=True)
+    inferrepo=True,
+)
 def amend(ui, repo, *pats, **opts):
     """amend the working copy parent with all or specified outstanding changes
 

hgext/automv.py

@@ -35,22 +35,23 b' from mercurial import ('
     pycompat,
     registrar,
     scmutil,
-    similar
+    similar,
 )
 
 configtable = {}
 configitem = registrar.configitem(configtable)
 
-configitem('automv', 'similarity',
-    default=95,
+configitem(
+    'automv', 'similarity', default=95,
 )
 
+
 def extsetup(ui):
-    entry = extensions.wrapcommand(
-        commands.table, 'commit', mvcheck)
+    entry = extensions.wrapcommand(commands.table, 'commit', mvcheck)
     entry[1].append(
-        ('', 'no-automv', None,
-         _('disable automatic file move detection')))
+        ('', 'no-automv', None, _('disable automatic file move detection'))
+    )
+
 
 def mvcheck(orig, ui, repo, *pats, **opts):
     """Hook to check for moves at commit time"""
@@ -65,14 +66,16 b' def mvcheck(orig, ui, repo, *pats, **opt'
             match = scmutil.match(repo[None], pats, opts)
             added, removed = _interestingfiles(repo, match)
             uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=True)
-            renames = _findrenames(repo, uipathfn, added, removed,
-                                   threshold / 100.0)
+            renames = _findrenames(
+                repo, uipathfn, added, removed, threshold / 100.0
+            )
 
     with repo.wlock():
         if renames is not None:
             scmutil._markchanges(repo, (), (), renames)
         return orig(ui, repo, *pats, **pycompat.strkwargs(opts))
 
+
 def _interestingfiles(repo, matcher):
     """Find what files were added or removed in this commit.
 
@@ -90,6 +93,7 b' def _interestingfiles(repo, matcher):'
 
     return added, removed
 
+
 def _findrenames(repo, uipathfn, added, removed, similarity):
     """Find what files in added are really moved files.
 
@@ -100,11 +104,13 b' def _findrenames(repo, uipathfn, added, '
     renames = {}
     if similarity > 0:
         for src, dst, score in similar.findrenames(
-                repo, added, removed, similarity):
+            repo, added, removed, similarity
+        ):
             if repo.ui.verbose:
                 repo.ui.status(
-                    _('detected move of %s as %s (%d%% similar)\n') % (
-                        uipathfn(src), uipathfn(dst), score * 100))
+                    _('detected move of %s as %s (%d%% similar)\n')
+                    % (uipathfn(src), uipathfn(dst), score * 100)
+                )
             renames[dst] = src
     if renames:
         repo.ui.status(_('detected move of %d files\n') % len(renames))

hgext/beautifygraph.py

@@ -28,6 +28,7 b' from mercurial import ('
 # leave the attribute unspecified.
 testedwith = 'ships-with-hg-core'
 
+
 def prettyedge(before, edge, after):
     if edge == '~':
         return '\xE2\x95\xA7' # U+2567 ╧
@@ -49,15 +50,21 b' def prettyedge(before, edge, after):'
         return '\xE2\x94\xBC' # U+253C ┼
     return edge
 
+
 def convertedges(line):
     line = ' %s ' % line
     pretty = []
     for idx in pycompat.xrange(len(line) - 2):
-        pretty.append(prettyedge(line[idx:idx + 1],
+        pretty.append(
+            prettyedge(
+                line[idx : idx + 1],
                                  line[idx + 1:idx + 2],
-                                 line[idx + 2:idx + 3]))
+                line[idx + 2 : idx + 3],
+            )
+        )
     return ''.join(pretty)
 
+
 def getprettygraphnode(orig, *args, **kwargs):
     node = orig(*args, **kwargs)
     if node == 'o':
@@ -72,11 +79,13 b' def getprettygraphnode(orig, *args, **kw'
         return '\xE2\x95\xA4' # U+2564 ╤
     return node
 
+
 def outputprettygraph(orig, ui, graph, *args, **kwargs):
     (edges, text) = zip(*graph)
     graph = zip([convertedges(e) for e in edges], text)
     return orig(ui, graph, *args, **kwargs)
 
+
 def extsetup(ui):
     if ui.plain('graph'):
         return
@@ -86,8 +95,12 b' def extsetup(ui):'
         return
 
     if r'A' in encoding._wide:
-        ui.warn(_('beautifygraph: unsupported terminal settings, '
-                  'monospace narrow text required\n'))
+        ui.warn(
+            _(
+                'beautifygraph: unsupported terminal settings, '
+                'monospace narrow text required\n'
+            )
+        )
         return
 
     extensions.wrapfunction(graphmod, 'outputgraph', outputprettygraph)

hgext/blackbox.py

@@ -71,30 +71,33 b' command = registrar.command(cmdtable)'
 configtable = {}
 configitem = registrar.configitem(configtable)
 
-configitem('blackbox', 'dirty',
-    default=False,
+configitem(
+    'blackbox', 'dirty', default=False,
 )
-configitem('blackbox', 'maxsize',
-    default='1 MB',
+configitem(
+    'blackbox', 'maxsize', default='1 MB',
+)
+configitem(
+    'blackbox', 'logsource', default=False,
 )
-configitem('blackbox', 'logsource',
-    default=False,
+configitem(
+    'blackbox', 'maxfiles', default=7,
 )
-configitem('blackbox', 'maxfiles',
-    default=7,
+configitem(
+    'blackbox', 'track', default=lambda: ['*'],
 )
-configitem('blackbox', 'track',
-    default=lambda: ['*'],
-)
-configitem('blackbox', 'ignore',
+configitem(
+    'blackbox',
+    'ignore',
     default=lambda: ['chgserver', 'cmdserver', 'extension'],
 )
-configitem('blackbox', 'date-format',
-    default='%Y/%m/%d %H:%M:%S',
+configitem(
+    'blackbox', 'date-format', default='%Y/%m/%d %H:%M:%S',
 )
 
 _lastlogger = loggingutil.proxylogger()
 
+
 class blackboxlogger(object):
     def __init__(self, ui, repo):
         self._repo = repo
@@ -105,9 +108,9 b' class blackboxlogger(object):'
         self._inlog = False
 
     def tracked(self, event):
-        return ((b'*' in self._trackedevents
-                 and event not in self._ignoredevents)
-                or event in self._trackedevents)
+        return (
+            b'*' in self._trackedevents and event not in self._ignoredevents
+        ) or event in self._trackedevents
 
     def log(self, ui, event, msg, opts):
         # self._log() -> ctx.dirty() may create new subrepo instance, which
@@ -129,9 +132,10 b' class blackboxlogger(object):'
         changed = ''
         ctx = self._repo[None]
         parents = ctx.parents()
-        rev = ('+'.join([hex(p.node()) for p in parents]))
-        if (ui.configbool('blackbox', 'dirty') and
-            ctx.dirty(missing=True, merge=False, branch=False)):
+        rev = '+'.join([hex(p.node()) for p in parents])
+        if ui.configbool('blackbox', 'dirty') and ctx.dirty(
+            missing=True, merge=False, branch=False
+        ):
             changed = '+'
         if ui.configbool('blackbox', 'logsource'):
             src = ' [%s]' % event
@@ -141,20 +145,28 b' class blackboxlogger(object):'
             fmt = '%s %s @%s%s (%s)%s> %s'
             args = (date, user, rev, changed, pid, src, msg)
             with loggingutil.openlogfile(
-                    ui, self._repo.vfs, name='blackbox.log',
-                    maxfiles=self._maxfiles, maxsize=self._maxsize) as fp:
+                ui,
+                self._repo.vfs,
+                name='blackbox.log',
+                maxfiles=self._maxfiles,
+                maxsize=self._maxsize,
+            ) as fp:
                 fp.write(fmt % args)
         except (IOError, OSError) as err:
             # deactivate this to avoid failed logging again
             self._trackedevents.clear()
-            ui.debug('warning: cannot write to blackbox.log: %s\n' %
-                     encoding.strtolocal(err.strerror))
+            ui.debug(
+                'warning: cannot write to blackbox.log: %s\n'
+                % encoding.strtolocal(err.strerror)
+            )
             return
         _lastlogger.logger = self
 
+
 def uipopulate(ui):
     ui.setlogger(b'blackbox', _lastlogger)
 
+
 def reposetup(ui, repo):
     # During 'hg pull' a httppeer repo is created to represent the remote repo.
     # It doesn't have a .hg directory to put a blackbox in, so we don't do
@@ -174,12 +186,14 b' def reposetup(ui, repo):'
 
     repo._wlockfreeprefix.add('blackbox.log')
 
-@command('blackbox',
-    [('l', 'limit', 10, _('the number of events to show')),
-    ],
+
+@command(
+    'blackbox',
+    [('l', 'limit', 10, _('the number of events to show')),],
     _('hg blackbox [OPTION]...'),
     helpcategory=command.CATEGORY_MAINTENANCE,
-    helpbasic=True)
+    helpbasic=True,
+)
 def blackbox(ui, repo, *revs, **opts):
     '''view the recent repository events
     '''

hgext/bookflow.py

@@ -36,20 +36,26 b" configitem(MY_NAME, 'enable-branches', F"
 cmdtable = {}
 command = registrar.command(cmdtable)
 
+
 def commit_hook(ui, repo, **kwargs):
     active = repo._bookmarks.active
     if active:
         if active in ui.configlist(MY_NAME, 'protect'):
             raise error.Abort(
-                _('cannot commit, bookmark %s is protected') % active)
+                _('cannot commit, bookmark %s is protected') % active
+            )
         if not cwd_at_bookmark(repo, active):
             raise error.Abort(
-       _('cannot commit, working directory out of sync with active bookmark'),
-                hint=_("run 'hg up %s'") % active)
+                _(
+                    'cannot commit, working directory out of sync with active bookmark'
+                ),
+                hint=_("run 'hg up %s'") % active,
+            )
     elif ui.configbool(MY_NAME, 'require-bookmark', True):
         raise error.Abort(_('cannot commit without an active bookmark'))
     return 0
 
+
 def bookmarks_update(orig, repo, parents, node):
     if len(parents) == 2:
         # called during commit
@@ -58,43 +64,59 b' def bookmarks_update(orig, repo, parents'
         # called during update
         return False
 
+
 def bookmarks_addbookmarks(
-        orig, repo, tr, names, rev=None, force=False, inactive=False):
+    orig, repo, tr, names, rev=None, force=False, inactive=False
+):
     if not rev:
         marks = repo._bookmarks
         for name in names:
             if name in marks:
-                raise error.Abort(_(
+                raise error.Abort(
+                    _(
                     "bookmark %s already exists, to move use the --rev option"
-                    ) % name)
+                    )
+                    % name
+                )
     return orig(repo, tr, names, rev, force, inactive)
 
+
 def commands_commit(orig, ui, repo, *args, **opts):
     commit_hook(ui, repo)
     return orig(ui, repo, *args, **opts)
 
+
 def commands_pull(orig, ui, repo, *args, **opts):
     rc = orig(ui, repo, *args, **opts)
     active = repo._bookmarks.active
     if active and not cwd_at_bookmark(repo, active):
-        ui.warn(_(
+        ui.warn(
+            _(
             "working directory out of sync with active bookmark, run "
             "'hg up %s'"
-        ) % active)
+            )
+            % active
+        )
     return rc
 
+
 def commands_branch(orig, ui, repo, label=None, **opts):
     if label and not opts.get(r'clean') and not opts.get(r'rev'):
         raise error.Abort(
-         _("creating named branches is disabled and you should use bookmarks"),
-            hint="see 'hg help bookflow'")
+            _(
+                "creating named branches is disabled and you should use bookmarks"
+            ),
+            hint="see 'hg help bookflow'",
+        )
     return orig(ui, repo, label, **opts)
 
+
 def cwd_at_bookmark(repo, mark):
     mark_id = repo._bookmarks[mark]
     cur_id = repo.lookup('.')
     return cur_id == mark_id
 
+
 def uisetup(ui):
     extensions.wrapfunction(bookmarks, 'update', bookmarks_update)
     extensions.wrapfunction(bookmarks, 'addbookmarks', bookmarks_addbookmarks)

hgext/bugzilla.py

@@ -324,71 +324,80 b" testedwith = 'ships-with-hg-core'"
 configtable = {}
 configitem = registrar.configitem(configtable)
 
-configitem('bugzilla', 'apikey',
-    default='',
+configitem(
+    'bugzilla', 'apikey', default='',
+)
+configitem(
+    'bugzilla', 'bzdir', default='/var/www/html/bugzilla',
 )
-configitem('bugzilla', 'bzdir',
-    default='/var/www/html/bugzilla',
+configitem(
+    'bugzilla', 'bzemail', default=None,
 )
-configitem('bugzilla', 'bzemail',
-    default=None,
+configitem(
+    'bugzilla', 'bzurl', default='http://localhost/bugzilla/',
 )
-configitem('bugzilla', 'bzurl',
-    default='http://localhost/bugzilla/',
+configitem(
+    'bugzilla', 'bzuser', default=None,
 )
-configitem('bugzilla', 'bzuser',
-    default=None,
+configitem(
+    'bugzilla', 'db', default='bugs',
 )
-configitem('bugzilla', 'db',
-    default='bugs',
-)
-configitem('bugzilla', 'fixregexp',
-    default=(br'fix(?:es)?\s*(?:bugs?\s*)?,?\s*'
+configitem(
+    'bugzilla',
+    'fixregexp',
+    default=(
+        br'fix(?:es)?\s*(?:bugs?\s*)?,?\s*'
              br'(?:nos?\.?|num(?:ber)?s?)?\s*'
              br'(?P<ids>(?:#?\d+\s*(?:,?\s*(?:and)?)?\s*)+)'
-             br'\.?\s*(?:h(?:ours?)?\s*(?P<hours>\d*(?:\.\d+)?))?')
-)
-configitem('bugzilla', 'fixresolution',
-    default='FIXED',
+        br'\.?\s*(?:h(?:ours?)?\s*(?P<hours>\d*(?:\.\d+)?))?'
+    ),
 )
-configitem('bugzilla', 'fixstatus',
-    default='RESOLVED',
+configitem(
+    'bugzilla', 'fixresolution', default='FIXED',
 )
-configitem('bugzilla', 'host',
-    default='localhost',
+configitem(
+    'bugzilla', 'fixstatus', default='RESOLVED',
 )
-configitem('bugzilla', 'notify',
-    default=configitem.dynamicdefault,
+configitem(
+    'bugzilla', 'host', default='localhost',
 )
-configitem('bugzilla', 'password',
-    default=None,
+configitem(
+    'bugzilla', 'notify', default=configitem.dynamicdefault,
 )
-configitem('bugzilla', 'regexp',
-    default=(br'bugs?\s*,?\s*(?:#|nos?\.?|num(?:ber)?s?)?\s*'
-             br'(?P<ids>(?:\d+\s*(?:,?\s*(?:and)?)?\s*)+)'
-             br'\.?\s*(?:h(?:ours?)?\s*(?P<hours>\d*(?:\.\d+)?))?')
+configitem(
+    'bugzilla', 'password', default=None,
 )
-configitem('bugzilla', 'strip',
-    default=0,
+configitem(
+    'bugzilla',
+    'regexp',
+    default=(
+        br'bugs?\s*,?\s*(?:#|nos?\.?|num(?:ber)?s?)?\s*'
+        br'(?P<ids>(?:\d+\s*(?:,?\s*(?:and)?)?\s*)+)'
+        br'\.?\s*(?:h(?:ours?)?\s*(?P<hours>\d*(?:\.\d+)?))?'
+    ),
 )
-configitem('bugzilla', 'style',
-    default=None,
+configitem(
+    'bugzilla', 'strip', default=0,
 )
-configitem('bugzilla', 'template',
-    default=None,
+configitem(
+    'bugzilla', 'style', default=None,
 )
-configitem('bugzilla', 'timeout',
-    default=5,
+configitem(
+    'bugzilla', 'template', default=None,
 )
-configitem('bugzilla', 'user',
-    default='bugs',
+configitem(
+    'bugzilla', 'timeout', default=5,
 )
-configitem('bugzilla', 'usermap',
-    default=None,
+configitem(
+    'bugzilla', 'user', default='bugs',
 )
-configitem('bugzilla', 'version',
-    default=None,
+configitem(
+    'bugzilla', 'usermap', default=None,
 )
+configitem(
+    'bugzilla', 'version', default=None,
+)
+
 
 class bzaccess(object):
     '''Base class for access to Bugzilla.'''
@@ -434,6 +443,7 b' class bzaccess(object):'
         emails automatically.
         '''
 
+
 # Bugzilla via direct access to MySQL database.
 class bzmysql(bzaccess):
     '''Support for direct MySQL access to Bugzilla.
@@ -454,6 +464,7 b' class bzmysql(bzaccess):'
     def __init__(self, ui):
         try:
             import MySQLdb as mysql
+
             bzmysql._MySQLdb = mysql
         except ImportError as err:
             raise error.Abort(_('python mysql support not available: %s') % err)
@@ -465,12 +476,13 b' class bzmysql(bzaccess):'
         passwd = self.ui.config('bugzilla', 'password')
         db = self.ui.config('bugzilla', 'db')
         timeout = int(self.ui.config('bugzilla', 'timeout'))
-        self.ui.note(_('connecting to %s:%s as %s, password %s\n') %
-                     (host, db, user, '*' * len(passwd)))
-        self.conn = bzmysql._MySQLdb.connect(host=host,
-                                                   user=user, passwd=passwd,
-                                                   db=db,
-                                                   connect_timeout=timeout)
+        self.ui.note(
+            _('connecting to %s:%s as %s, password %s\n')
+            % (host, db, user, '*' * len(passwd))
+        )
+        self.conn = bzmysql._MySQLdb.connect(
+            host=host, user=user, passwd=passwd, db=db, connect_timeout=timeout
+        )
         self.cursor = self.conn.cursor()
         self.longdesc_id = self.get_longdesc_id()
         self.user_ids = {}
@@ -495,8 +507,10 b' class bzmysql(bzaccess):'
 
     def filter_real_bug_ids(self, bugs):
         '''filter not-existing bugs from set.'''
-        self.run('select bug_id from bugs where bug_id in %s' %
-                 bzmysql.sql_buglist(bugs.keys()))
+        self.run(
+            'select bug_id from bugs where bug_id in %s'
+            % bzmysql.sql_buglist(bugs.keys())
+        )
         existing = [id for (id,) in self.cursor.fetchall()]
         for id in bugs.keys():
             if id not in existing:
@@ -505,12 +519,16 b' class bzmysql(bzaccess):'
 
     def filter_cset_known_bug_ids(self, node, bugs):
         '''filter bug ids that already refer to this changeset from set.'''
-        self.run('''select bug_id from longdescs where
-                    bug_id in %s and thetext like "%%%s%%"''' %
-                 (bzmysql.sql_buglist(bugs.keys()), short(node)))
+        self.run(
+            '''select bug_id from longdescs where
+                    bug_id in %s and thetext like "%%%s%%"'''
+            % (bzmysql.sql_buglist(bugs.keys()), short(node))
+        )
         for (id,) in self.cursor.fetchall():
-            self.ui.status(_('bug %d already knows about changeset %s\n') %
-                           (id, short(node)))
+            self.ui.status(
+                _('bug %d already knows about changeset %s\n')
+                % (id, short(node))
+            )
             del bugs[id]
 
     def notify(self, bugs, committer):
@@ -534,8 +552,9 b' class bzmysql(bzaccess):'
             ret = fp.close()
             if ret:
                 self.ui.warn(out)
-                raise error.Abort(_('bugzilla notify command %s') %
-                                  procutil.explainexit(ret))
+                raise error.Abort(
+                    _('bugzilla notify command %s') % procutil.explainexit(ret)
+                )
         self.ui.status(_('done\n'))
 
     def get_user_id(self, user):
@@ -547,8 +566,11 b' class bzmysql(bzaccess):'
                 userid = int(user)
             except ValueError:
                 self.ui.note(_('looking up user %s\n') % user)
-                self.run('''select userid from profiles
-                            where login_name like %s''', user)
+                self.run(
+                    '''select userid from profiles
+                            where login_name like %s''',
+                    user,
+                )
                 all = self.cursor.fetchall()
                 if len(all) != 1:
                     raise KeyError(user)
@@ -567,13 +589,16 b' class bzmysql(bzaccess):'
             try:
                 defaultuser = self.ui.config('bugzilla', 'bzuser')
                 if not defaultuser:
-                    raise error.Abort(_('cannot find bugzilla user id for %s') %
-                                     user)
+                    raise error.Abort(
+                        _('cannot find bugzilla user id for %s') % user
+                    )
                 userid = self.get_user_id(defaultuser)
                 user = defaultuser
             except KeyError:
-                raise error.Abort(_('cannot find bugzilla user id for %s or %s')
-                                 % (user, defaultuser))
+                raise error.Abort(
+                    _('cannot find bugzilla user id for %s or %s')
+                    % (user, defaultuser)
+                )
         return (user, userid)
 
     def updatebug(self, bugid, newstate, text, committer):
@@ -586,22 +611,29 b' class bzmysql(bzaccess):'
 
         (user, userid) = self.get_bugzilla_user(committer)
         now = time.strftime(r'%Y-%m-%d %H:%M:%S')
-        self.run('''insert into longdescs
+        self.run(
+            '''insert into longdescs
                     (bug_id, who, bug_when, thetext)
                     values (%s, %s, %s, %s)''',
-                 (bugid, userid, now, text))
-        self.run('''insert into bugs_activity (bug_id, who, bug_when, fieldid)
+            (bugid, userid, now, text),
+        )
+        self.run(
+            '''insert into bugs_activity (bug_id, who, bug_when, fieldid)
                     values (%s, %s, %s, %s)''',
-                 (bugid, userid, now, self.longdesc_id))
+            (bugid, userid, now, self.longdesc_id),
+        )
         self.conn.commit()
 
+
 class bzmysql_2_18(bzmysql):
     '''support for bugzilla 2.18 series.'''
 
     def __init__(self, ui):
         bzmysql.__init__(self, ui)
         self.default_notify = (
-            "cd %(bzdir)s && perl -T contrib/sendbugmail.pl %(id)s %(user)s")
+            "cd %(bzdir)s && perl -T contrib/sendbugmail.pl %(id)s %(user)s"
+        )
+
 
 class bzmysql_3_0(bzmysql_2_18):
     '''support for bugzilla 3.0 series.'''
@@ -617,8 +649,10 b' class bzmysql_3_0(bzmysql_2_18):'
             raise error.Abort(_('unknown database schema'))
         return ids[0][0]
 
+
 # Bugzilla via XMLRPC interface.
 
+
 class cookietransportrequest(object):
     """A Transport request method that retains cookies over its lifetime.
 
@@ -636,6 +670,7 b' class cookietransportrequest(object):'
     # http://www.itkovian.net/base/transport-class-for-pythons-xml-rpc-lib/
 
     cookies = []
+
     def send_cookies(self, connection):
         if self.cookies:
             for cookie in self.cookies:
@@ -673,8 +708,12 b' class cookietransportrequest(object):'
             self.cookies.append(cookie)
 
         if response.status != 200:
-            raise xmlrpclib.ProtocolError(host + handler, response.status,
-                                          response.reason, response.msg.headers)
+            raise xmlrpclib.ProtocolError(
+                host + handler,
+                response.status,
+                response.reason,
+                response.msg.headers,
+            )
 
         payload = response.read()
         parser, unmarshaller = self.getparser()
@@ -683,6 +722,7 b' class cookietransportrequest(object):'
 
         return unmarshaller.close()
 
+
 # The explicit calls to the underlying xmlrpclib __init__() methods are
 # necessary. The xmlrpclib.Transport classes are old-style classes, and
 # it turns out their __init__() doesn't get called when doing multiple
@@ -692,11 +732,13 b' class cookietransport(cookietransportreq'
         if util.safehasattr(xmlrpclib.Transport, "__init__"):
             xmlrpclib.Transport.__init__(self, use_datetime)
 
+
 class cookiesafetransport(cookietransportrequest, xmlrpclib.SafeTransport):
     def __init__(self, use_datetime=0):
         if util.safehasattr(xmlrpclib.Transport, "__init__"):
             xmlrpclib.SafeTransport.__init__(self, use_datetime)
 
+
 class bzxmlrpc(bzaccess):
     """Support for access to Bugzilla via the Bugzilla XMLRPC API.
 
@@ -719,8 +761,9 b' class bzxmlrpc(bzaccess):'
         ver = self.bzproxy.Bugzilla.version()['version'].split('.')
         self.bzvermajor = int(ver[0])
         self.bzverminor = int(ver[1])
-        login = self.bzproxy.User.login({'login': user, 'password': passwd,
-                                         'restrict_login': True})
+        login = self.bzproxy.User.login(
+            {'login': user, 'password': passwd, 'restrict_login': True}
+        )
         self.bztoken = login.get('token', '')
 
     def transport(self, uri):
@@ -731,17 +774,20 b' class bzxmlrpc(bzaccess):'
 
     def get_bug_comments(self, id):
         """Return a string with all comment text for a bug."""
-        c = self.bzproxy.Bug.comments({'ids': [id],
-                                       'include_fields': ['text'],
-                                       'token': self.bztoken})
+        c = self.bzproxy.Bug.comments(
+            {'ids': [id], 'include_fields': ['text'], 'token': self.bztoken}
+        )
         return ''.join([t['text'] for t in c['bugs']['%d' % id]['comments']])
 
     def filter_real_bug_ids(self, bugs):
-        probe = self.bzproxy.Bug.get({'ids': sorted(bugs.keys()),
+        probe = self.bzproxy.Bug.get(
+            {
+                'ids': sorted(bugs.keys()),
                                       'include_fields': [],
                                       'permissive': True,
                                       'token': self.bztoken,
-                                      })
+            }
+        )
         for badbug in probe['faults']:
             id = badbug['id']
             self.ui.status(_('bug %d does not exist\n') % id)
@@ -750,8 +796,10 b' class bzxmlrpc(bzaccess):'
     def filter_cset_known_bug_ids(self, node, bugs):
         for id in sorted(bugs.keys()):
             if self.get_bug_comments(id).find(short(node)) != -1:
-                self.ui.status(_('bug %d already knows about changeset %s\n') %
-                               (id, short(node)))
+                self.ui.status(
+                    _('bug %d already knows about changeset %s\n')
+                    % (id, short(node))
+                )
                 del bugs[id]
 
     def updatebug(self, bugid, newstate, text, committer):
@@ -769,12 +817,17 b' class bzxmlrpc(bzaccess):'
             self.bzproxy.Bug.update(args)
         else:
             if 'fix' in newstate:
-                self.ui.warn(_("Bugzilla/XMLRPC needs Bugzilla 4.0 or later "
-                               "to mark bugs fixed\n"))
+                self.ui.warn(
+                    _(
+                        "Bugzilla/XMLRPC needs Bugzilla 4.0 or later "
+                        "to mark bugs fixed\n"
+                    )
+                )
             args['id'] = bugid
             args['comment'] = text
             self.bzproxy.Bug.add_comment(args)
 
+
 class bzxmlrpcemail(bzxmlrpc):
     """Read data from Bugzilla via XMLRPC, send updates via email.
 
@@ -823,15 +876,18 b' class bzxmlrpcemail(bzxmlrpc):'
         than the subject line, and leave a blank line after it.
         '''
         user = self.map_committer(committer)
-        matches = self.bzproxy.User.get({'match': [user],
-                                         'token': self.bztoken})
+        matches = self.bzproxy.User.get(
+            {'match': [user], 'token': self.bztoken}
+        )
         if not matches['users']:
             user = self.ui.config('bugzilla', 'user')
-            matches = self.bzproxy.User.get({'match': [user],
-                                             'token': self.bztoken})
+            matches = self.bzproxy.User.get(
+                {'match': [user], 'token': self.bztoken}
+            )
             if not matches['users']:
-                raise error.Abort(_("default bugzilla user %s email not found")
-                                  % user)
+                raise error.Abort(
+                    _("default bugzilla user %s email not found") % user
+                )
         user = matches['users'][0]['email']
         commands.append(self.makecommandline("id", bugid))
 
@@ -856,13 +912,16 b' class bzxmlrpcemail(bzxmlrpc):'
             cmds.append(self.makecommandline("resolution", self.fixresolution))
         self.send_bug_modify_email(bugid, cmds, text, committer)
 
+
 class NotFound(LookupError):
     pass
 
+
 class bzrestapi(bzaccess):
     """Read and write bugzilla data using the REST API available since
     Bugzilla 5.0.
     """
+
     def __init__(self, ui):
         bzaccess.__init__(self, ui)
         bz = self.ui.config('bugzilla', 'bzurl')
@@ -902,14 +961,15 b' class bzrestapi(bzaccess):'
     def _submit(self, burl, data, method='POST'):
         data = json.dumps(data)
         if method == 'PUT':
+
             class putrequest(util.urlreq.request):
                 def get_method(self):
                     return 'PUT'
+
             request_type = putrequest
         else:
             request_type = util.urlreq.request
-        req = request_type(burl, data,
-                           {'Content-Type': 'application/json'})
+        req = request_type(burl, data, {'Content-Type': 'application/json'})
         try:
             resp = url.opener(self.ui).open(req)
             return json.loads(resp.read())
@@ -941,8 +1001,9 b' class bzrestapi(bzaccess):'
             result = self._fetch(burl)
             comments = result['bugs'][pycompat.bytestr(bugid)]['comments']
             if any(sn in c['text'] for c in comments):
-                self.ui.status(_('bug %d already knows about changeset %s\n') %
-                               (bugid, sn))
+                self.ui.status(
+                    _('bug %d already knows about changeset %s\n') % (bugid, sn)
+                )
                 del bugs[bugid]
 
     def updatebug(self, bugid, newstate, text, committer):
@@ -969,11 +1030,10 b' class bzrestapi(bzaccess):'
             self.ui.debug('updated bug %s\n' % bugid)
         else:
             burl = self.apiurl(('bug', bugid, 'comment'))
-            self._submit(burl, {
-                'comment': text,
-                'is_private': False,
-                'is_markdown': False,
-            })
+            self._submit(
+                burl,
+                {'comment': text, 'is_private': False, 'is_markdown': False,},
+            )
             self.ui.debug('added comment to bug %s\n' % bugid)
 
     def notify(self, bugs, committer):
@@ -984,6 +1044,7 b' class bzrestapi(bzaccess):'
         '''
         pass
 
+
 class bugzilla(object):
     # supported versions of bugzilla. different versions have
     # different schemas.
@@ -1004,14 +1065,17 b' class bugzilla(object):'
         try:
             bzclass = bugzilla._versions[bzversion]
         except KeyError:
-            raise error.Abort(_('bugzilla version %s not supported') %
-                             bzversion)
+            raise error.Abort(
+                _('bugzilla version %s not supported') % bzversion
+            )
         self.bzdriver = bzclass(self.ui)
 
         self.bug_re = re.compile(
-            self.ui.config('bugzilla', 'regexp'), re.IGNORECASE)
+            self.ui.config('bugzilla', 'regexp'), re.IGNORECASE
+        )
         self.fix_re = re.compile(
-            self.ui.config('bugzilla', 'fixregexp'), re.IGNORECASE)
+            self.ui.config('bugzilla', 'fixregexp'), re.IGNORECASE
+        )
         self.split_re = re.compile(br'\D+')
 
     def find_bugs(self, ctx):
@@ -1093,31 +1157,39 b' class bugzilla(object):'
         if not tmpl:
             mapfile = self.ui.config('bugzilla', 'style')
         if not mapfile and not tmpl:
-            tmpl = _('changeset {node|short} in repo {root} refers '
-                     'to bug {bug}.\ndetails:\n\t{desc|tabindent}')
+            tmpl = _(
+                'changeset {node|short} in repo {root} refers '
+                'to bug {bug}.\ndetails:\n\t{desc|tabindent}'
+            )
         spec = logcmdutil.templatespec(tmpl, mapfile)
         t = logcmdutil.changesettemplater(self.ui, self.repo, spec)
         self.ui.pushbuffer()
-        t.show(ctx, changes=ctx.changeset(),
+        t.show(
+            ctx,
+            changes=ctx.changeset(),
                bug=pycompat.bytestr(bugid),
                hgweb=self.ui.config('web', 'baseurl'),
                root=self.repo.root,
-               webroot=webroot(self.repo.root))
+            webroot=webroot(self.repo.root),
+        )
         data = self.ui.popbuffer()
-        self.bzdriver.updatebug(bugid, newstate, data,
-                                stringutil.email(ctx.user()))
+        self.bzdriver.updatebug(
+            bugid, newstate, data, stringutil.email(ctx.user())
+        )
 
     def notify(self, bugs, committer):
         '''ensure Bugzilla users are notified of bug change.'''
         self.bzdriver.notify(bugs, committer)
 
+
 def hook(ui, repo, hooktype, node=None, **kwargs):
     '''add comment to bugzilla for each changeset that refers to a
     bugzilla bug id. only add a comment once per bug, so same change
     seen multiple times does not fill bug with duplicate data.'''
     if node is None:
-        raise error.Abort(_('hook type %s does not pass a changeset id') %
-                         hooktype)
+        raise error.Abort(
+            _('hook type %s does not pass a changeset id') % hooktype
+        )
     try:
         bz = bugzilla(ui, repo)
         ctx = repo[node]

hgext/censor.py

@@ -44,15 +44,21 b' command = registrar.command(cmdtable)'
 # leave the attribute unspecified.
 testedwith = 'ships-with-hg-core'
 
-@command('censor',
-    [('r', 'rev', '', _('censor file from specified revision'), _('REV')),
-     ('t', 'tombstone', '', _('replacement tombstone data'), _('TEXT'))],
+
+@command(
+    'censor',
+    [
+        ('r', 'rev', '', _('censor file from specified revision'), _('REV')),
+        ('t', 'tombstone', '', _('replacement tombstone data'), _('TEXT')),
+    ],
     _('-r REV [-t TEXT] [FILE]'),
-    helpcategory=command.CATEGORY_MAINTENANCE)
+    helpcategory=command.CATEGORY_MAINTENANCE,
+)
 def censor(ui, repo, path, rev='', tombstone='', **opts):
     with repo.wlock(), repo.lock():
         return _docensor(ui, repo, path, rev, tombstone, **opts)
 
+
 def _docensor(ui, repo, path, rev='', tombstone='', **opts):
     if not path:
         raise error.Abort(_('must specify file path to censor'))
@@ -88,13 +94,17 b" def _docensor(ui, repo, path, rev='', to"
             heads.append(hc)
     if heads:
         headlist = ', '.join([short(c.node()) for c in heads])
-        raise error.Abort(_('cannot censor file in heads (%s)') % headlist,
-            hint=_('clean/delete and commit first'))
+        raise error.Abort(
+            _('cannot censor file in heads (%s)') % headlist,
+            hint=_('clean/delete and commit first'),
+        )
 
     wp = wctx.parents()
     if ctx.node() in [p.node() for p in wp]:
-        raise error.Abort(_('cannot censor working directory'),
-            hint=_('clean/delete/update first'))
+        raise error.Abort(
+            _('cannot censor working directory'),
+            hint=_('clean/delete/update first'),
+        )
 
     with repo.transaction(b'censor') as tr:
         flog.censorrevision(tr, fnode, tombstone=tombstone)

hgext/children.py

@@ -35,13 +35,15 b' command = registrar.command(cmdtable)'
 # leave the attribute unspecified.
 testedwith = 'ships-with-hg-core'
 
-@command('children',
-    [('r', 'rev', '.',
-     _('show children of the specified revision'), _('REV')),
-    ] + templateopts,
+
+@command(
+    'children',
+    [('r', 'rev', '.', _('show children of the specified revision'), _('REV')),]
+    + templateopts,
     _('hg children [-r REV] [FILE]'),
     helpcategory=command.CATEGORY_CHANGE_NAVIGATION,
-    inferrepo=True)
+    inferrepo=True,
+)
 def children(ui, repo, file_=None, **opts):
     """show the children of the given or working directory revision
 

hgext/churn.py

@@ -34,6 +34,7 b' command = registrar.command(cmdtable)'
 # leave the attribute unspecified.
 testedwith = 'ships-with-hg-core'
 
+
 def changedlines(ui, repo, ctx1, ctx2, fns):
     added, removed = 0, 0
     fmatch = scmutil.matchfiles(repo, fns)
@@ -45,31 +46,38 b' def changedlines(ui, repo, ctx1, ctx2, f'
             removed += 1
     return (added, removed)
 
+
 def countrate(ui, repo, amap, *pats, **opts):
     """Calculate stats"""
     opts = pycompat.byteskwargs(opts)
     if opts.get('dateformat'):
+
         def getkey(ctx):
             t, tz = ctx.date()
             date = datetime.datetime(*time.gmtime(float(t) - tz)[:6])
             return encoding.strtolocal(
-                date.strftime(encoding.strfromlocal(opts['dateformat'])))
+                date.strftime(encoding.strfromlocal(opts['dateformat']))
+            )
+
     else:
         tmpl = opts.get('oldtemplate') or opts.get('template')
         tmpl = logcmdutil.maketemplater(ui, repo, tmpl)
+
         def getkey(ctx):
             ui.pushbuffer()
             tmpl.show(ctx)
             return ui.popbuffer()
 
-    progress = ui.makeprogress(_('analyzing'), unit=_('revisions'),
-                               total=len(repo))
+    progress = ui.makeprogress(
+        _('analyzing'), unit=_('revisions'), total=len(repo)
+    )
     rate = {}
     df = False
     if opts.get('date'):
         df = dateutil.matchdate(opts['date'])
 
     m = scmutil.match(repo[None], pats, opts)
+
     def prep(ctx, fns):
         rev = ctx.rev()
         if df and not df(ctx.date()[0]): # doesn't match date format
@@ -99,25 +107,54 b' def countrate(ui, repo, amap, *pats, **o'
     return rate
 
 
-@command('churn',
-    [('r', 'rev', [],
-     _('count rate for the specified revision or revset'), _('REV')),
-    ('d', 'date', '',
-     _('count rate for revisions matching date spec'), _('DATE')),
-    ('t', 'oldtemplate', '',
-     _('template to group changesets (DEPRECATED)'), _('TEMPLATE')),
-    ('T', 'template', '{author|email}',
-     _('template to group changesets'), _('TEMPLATE')),
-    ('f', 'dateformat', '',
-     _('strftime-compatible format for grouping by date'), _('FORMAT')),
+@command(
+    'churn',
+    [
+        (
+            'r',
+            'rev',
+            [],
+            _('count rate for the specified revision or revset'),
+            _('REV'),
+        ),
+        (
+            'd',
+            'date',
+            '',
+            _('count rate for revisions matching date spec'),
+            _('DATE'),
+        ),
+        (
+            't',
+            'oldtemplate',
+            '',
+            _('template to group changesets (DEPRECATED)'),
+            _('TEMPLATE'),
+        ),
+        (
+            'T',
+            'template',
+            '{author|email}',
+            _('template to group changesets'),
+            _('TEMPLATE'),
+        ),
+        (
+            'f',
+            'dateformat',
+            '',
+            _('strftime-compatible format for grouping by date'),
+            _('FORMAT'),
+        ),
     ('c', 'changesets', False, _('count rate by number of changesets')),
     ('s', 'sort', False, _('sort by key (default: sort by count)')),
     ('', 'diffstat', False, _('display added/removed lines separately')),
     ('', 'aliases', '', _('file with email aliases'), _('FILE')),
-    ] + cmdutil.walkopts,
+    ]
+    + cmdutil.walkopts,
     _("hg churn [-d DATE] [-r REV] [--aliases FILE] [FILE]"),
     helpcategory=command.CATEGORY_MAINTENANCE,
-    inferrepo=True)
+    inferrepo=True,
+)
 def churn(ui, repo, *pats, **opts):
     '''histogram of changes to the repository
 
@@ -154,6 +191,7 b' def churn(ui, repo, *pats, **opts):'
     a .hgchurn file will be looked for in the working directory root.
     Aliases will be split from the rightmost "=".
     '''
+
     def pad(s, l):
         return s + " " * (l - encoding.colwidth(s))
 
@@ -191,19 +229,25 b' def churn(ui, repo, *pats, **opts):'
 
     if opts.get(r'diffstat'):
         width -= 15
+
         def format(name, diffstat):
             added, removed = diffstat
-            return "%s %15s %s%s\n" % (pad(name, maxname),
+            return "%s %15s %s%s\n" % (
+                pad(name, maxname),
                                        '+%d/-%d' % (added, removed),
-                                       ui.label('+' * charnum(added),
-                                                'diffstat.inserted'),
-                                       ui.label('-' * charnum(removed),
-                                                'diffstat.deleted'))
+                ui.label('+' * charnum(added), 'diffstat.inserted'),
+                ui.label('-' * charnum(removed), 'diffstat.deleted'),
+            )
+
     else:
         width -= 6
+
         def format(name, count):
-            return "%s %6d %s\n" % (pad(name, maxname), sum(count),
-                                    '*' * charnum(sum(count)))
+            return "%s %6d %s\n" % (
+                pad(name, maxname),
+                sum(count),
+                '*' * charnum(sum(count)),
+            )
 
     def charnum(count):
         return int(count * width // maxcount)

hgext/clonebundles.py

@@ -203,6 +203,7 b' from mercurial import ('
 
 testedwith = 'ships-with-hg-core'
 
+
 def capabilities(orig, repo, proto):
     caps = orig(repo, proto)
 
@@ -214,5 +215,6 b' def capabilities(orig, repo, proto):'
 
     return caps
 
+
 def extsetup(ui):
     extensions.wrapfunction(wireprotov1server, '_capabilities', capabilities)

hgext/closehead.py

@@ -28,13 +28,16 b" testedwith = 'ships-with-hg-core'"
 
 commitopts = cmdutil.commitopts
 commitopts2 = cmdutil.commitopts2
-commitopts3 = [('r', 'rev', [],
-               _('revision to check'), _('REV'))]
+commitopts3 = [('r', 'rev', [], _('revision to check'), _('REV'))]
+
 
-@command('close-head|close-heads', commitopts + commitopts2 + commitopts3,
+@command(
+    'close-head|close-heads',
+    commitopts + commitopts2 + commitopts3,
     _('[OPTION]... [REV]...'),
     helpcategory=command.CATEGORY_CHANGE_MANAGEMENT,
-    inferrepo=True)
+    inferrepo=True,
+)
 def close_branch(ui, repo, *revs, **opts):
     """close the given head revisions
 
@@ -44,10 +47,18 b' def close_branch(ui, repo, *revs, **opts'
 
     The commit message must be specified with -l or -m.
     """
+
     def docommit(rev):
-        cctx = context.memctx(repo, parents=[rev, None], text=message,
-                              files=[], filectxfn=None, user=opts.get('user'),
-                              date=opts.get('date'), extra=extra)
+        cctx = context.memctx(
+            repo,
+            parents=[rev, None],
+            text=message,
+            files=[],
+            filectxfn=None,
+            user=opts.get('user'),
+            date=opts.get('date'),
+            extra=extra,
+        )
         tr = repo.transaction('commit')
         ret = repo.commitctx(cctx, True)
         bookmarks.update(repo, [rev, None], ret)

hgext/commitextras.py

@@ -37,36 +37,46 b' usedinternally = {'
     'transplant_source',
 }
 
+
 def extsetup(ui):
     entry = extensions.wrapcommand(commands.table, 'commit', _commit)
     options = entry[1]
-    options.append(('', 'extra', [],
-        _('set a changeset\'s extra values'), _("KEY=VALUE")))
+    options.append(
+        ('', 'extra', [], _('set a changeset\'s extra values'), _("KEY=VALUE"))
+    )
+
 
 def _commit(orig, ui, repo, *pats, **opts):
     if util.safehasattr(repo, 'unfiltered'):
         repo = repo.unfiltered()
+
     class repoextra(repo.__class__):
         def commit(self, *innerpats, **inneropts):
             extras = opts.get(r'extra')
             for raw in extras:
                 if '=' not in raw:
-                    msg = _("unable to parse '%s', should follow "
-                            "KEY=VALUE format")
+                    msg = _(
+                        "unable to parse '%s', should follow "
+                        "KEY=VALUE format"
+                    )
                     raise error.Abort(msg % raw)
                 k, v = raw.split('=', 1)
                 if not k:
                     msg = _("unable to parse '%s', keys can't be empty")
                     raise error.Abort(msg % raw)
                 if re.search(br'[^\w-]', k):
-                    msg = _("keys can only contain ascii letters, digits,"
-                            " '_' and '-'")
+                    msg = _(
+                        "keys can only contain ascii letters, digits,"
+                        " '_' and '-'"
+                    )
                     raise error.Abort(msg)
                 if k in usedinternally:
-                    msg = _("key '%s' is used internally, can't be set "
-                            "manually")
+                    msg = _(
+                        "key '%s' is used internally, can't be set " "manually"
+                    )
                     raise error.Abort(msg % k)
                 inneropts[r'extra'][k] = v
             return super(repoextra, self).commit(*innerpats, **inneropts)
+
     repo.__class__ = repoextra
     return orig(ui, repo, *pats, **opts)

hgext/convert/__init__.py

@@ -10,9 +10,7 b''
 from __future__ import absolute_import
 
 from mercurial.i18n import _
-from mercurial import (
-    registrar,
-)
+from mercurial import registrar
 
 from . import (
     convcmd,
@@ -30,28 +28,58 b" testedwith = 'ships-with-hg-core'"
 
 # Commands definition was moved elsewhere to ease demandload job.
 
-@command('convert',
-    [('', 'authors', '',
-      _('username mapping filename (DEPRECATED) (use --authormap instead)'),
-      _('FILE')),
+
+@command(
+    'convert',
+    [
+        (
+            '',
+            'authors',
+            '',
+            _(
+                'username mapping filename (DEPRECATED) (use --authormap instead)'
+            ),
+            _('FILE'),
+        ),
     ('s', 'source-type', '', _('source repository type'), _('TYPE')),
     ('d', 'dest-type', '', _('destination repository type'), _('TYPE')),
     ('r', 'rev', [], _('import up to source revision REV'), _('REV')),
     ('A', 'authormap', '', _('remap usernames using this file'), _('FILE')),
-    ('', 'filemap', '', _('remap file names using contents of file'),
-     _('FILE')),
-    ('', 'full', None,
-     _('apply filemap changes by converting all files again')),
-    ('', 'splicemap', '', _('splice synthesized history into place'),
-     _('FILE')),
-    ('', 'branchmap', '', _('change branch names while converting'),
-     _('FILE')),
+        (
+            '',
+            'filemap',
+            '',
+            _('remap file names using contents of file'),
+            _('FILE'),
+        ),
+        (
+            '',
+            'full',
+            None,
+            _('apply filemap changes by converting all files again'),
+        ),
+        (
+            '',
+            'splicemap',
+            '',
+            _('splice synthesized history into place'),
+            _('FILE'),
+        ),
+        (
+            '',
+            'branchmap',
+            '',
+            _('change branch names while converting'),
+            _('FILE'),
+        ),
     ('', 'branchsort', None, _('try to sort changesets by branches')),
     ('', 'datesort', None, _('try to sort changesets by date')),
     ('', 'sourcesort', None, _('preserve source changesets order')),
-    ('', 'closesort', None, _('try to reorder closed revisions'))],
+        ('', 'closesort', None, _('try to reorder closed revisions')),
+    ],
    _('hg convert [OPTION]... SOURCE [DEST [REVMAP]]'),
-   norepo=True)
+    norepo=True,
+)
 def convert(ui, src, dest=None, revmapfile=None, **opts):
     """convert a foreign SCM repository to a Mercurial one.
 
@@ -454,17 +482,24 b' def convert(ui, src, dest=None, revmapfi'
     """
     return convcmd.convert(ui, src, dest, revmapfile, **opts)
 
+
 @command('debugsvnlog', [], 'hg debugsvnlog', norepo=True)
 def debugsvnlog(ui, **opts):
     return subversion.debugsvnlog(ui, **opts)
 
-@command('debugcvsps',
+
+@command(
+    'debugcvsps',
     [
     # Main options shared with cvsps-2.1
     ('b', 'branches', [], _('only return changes on specified branches')),
     ('p', 'prefix', '', _('prefix to remove from file names')),
-    ('r', 'revisions', [],
-     _('only return changes after or between specified tags')),
+        (
+            'r',
+            'revisions',
+            [],
+            _('only return changes after or between specified tags'),
+        ),
     ('u', 'update-cache', None, _("update cvs log cache")),
     ('x', 'new-cache', None, _("create new cvs log cache")),
     ('z', 'fuzz', 60, _('set commit time fuzz in seconds')),
@@ -476,7 +511,8 b' def debugsvnlog(ui, **opts):'
     ('A', 'cvs-direct', None, _('ignored for compatibility')),
     ],
     _('hg debugcvsps [OPTION]... [PATH]...'),
-    norepo=True)
+    norepo=True,
+)
 def debugcvsps(ui, *args, **opts):
     '''create changeset information from CVS
 
@@ -490,34 +526,40 b' def debugcvsps(ui, *args, **opts):'
     dates.'''
     return cvsps.debugcvsps(ui, *args, **opts)
 
+
 def kwconverted(context, mapping, name):
     ctx = context.resource(mapping, 'ctx')
     rev = ctx.extra().get('convert_revision', '')
     if rev.startswith('svn:'):
         if name == 'svnrev':
-            return (b"%d" % subversion.revsplit(rev)[2])
+            return b"%d" % subversion.revsplit(rev)[2]
         elif name == 'svnpath':
             return subversion.revsplit(rev)[1]
         elif name == 'svnuuid':
             return subversion.revsplit(rev)[0]
     return rev
 
+
 templatekeyword = registrar.templatekeyword()
 
+
 @templatekeyword('svnrev', requires={'ctx'})
 def kwsvnrev(context, mapping):
     """String. Converted subversion revision number."""
     return kwconverted(context, mapping, 'svnrev')
 
+
 @templatekeyword('svnpath', requires={'ctx'})
 def kwsvnpath(context, mapping):
     """String. Converted subversion revision project path."""
     return kwconverted(context, mapping, 'svnpath')
 
+
 @templatekeyword('svnuuid', requires={'ctx'})
 def kwsvnuuid(context, mapping):
     """String. Converted subversion revision repository identifier."""
     return kwconverted(context, mapping, 'svnuuid')
 
+
 # tell hggettext to extract docstrings from these functions:
 i18nfunctions = [kwsvnrev, kwsvnpath, kwsvnuuid]

hgext/convert/bzr.py

@@ -12,18 +12,13 b' from __future__ import absolute_import'
 import os
 
 from mercurial.i18n import _
-from mercurial import (
-    demandimport,
-    error
-)
+from mercurial import demandimport, error
 from . import common
 
 # these do not work with demandimport, blacklist
-demandimport.IGNORES.update([
-        'bzrlib.transactions',
-        'bzrlib.urlutils',
-        'ElementPath',
-    ])
+demandimport.IGNORES.update(
+    ['bzrlib.transactions', 'bzrlib.urlutils', 'ElementPath',]
+)
 
 try:
     # bazaar imports
@@ -31,6 +26,7 b' try:'
     import bzrlib.errors
     import bzrlib.revision
     import bzrlib.revisionspec
+
     bzrdir = bzrlib.bzrdir
     errors = bzrlib.errors
     revision = bzrlib.revision
@@ -41,6 +37,7 b' except ImportError:'
 
 supportedkinds = ('file', 'symlink')
 
+
 class bzr_source(common.converter_source):
     """Reads Bazaar repositories by using the Bazaar Python libraries"""
 
@@ -48,8 +45,9 b' class bzr_source(common.converter_source'
         super(bzr_source, self).__init__(ui, repotype, path, revs=revs)
 
         if not os.path.exists(os.path.join(path, '.bzr')):
-            raise common.NoRepo(_('%s does not look like a Bazaar repository')
-                              % path)
+            raise common.NoRepo(
+                _('%s does not look like a Bazaar repository') % path
+            )
 
         try:
             # access bzrlib stuff
@@ -62,8 +60,9 b' class bzr_source(common.converter_source'
         try:
             self.sourcerepo = bzrdir.BzrDir.open(path).open_repository()
         except errors.NoRepositoryPresent:
-            raise common.NoRepo(_('%s does not look like a Bazaar repository')
-                              % path)
+            raise common.NoRepo(
+                _('%s does not look like a Bazaar repository') % path
+            )
         self._parentids = {}
         self._saverev = ui.configbool('convert', 'bzr.saverev')
 
@@ -78,11 +77,18 b' class bzr_source(common.converter_source'
             except (errors.NoWorkingTree, errors.NotLocalUrl):
                 tree = None
                 branch = dir.open_branch()
-            if (tree is not None and tree.bzrdir.root_transport.base !=
-                branch.bzrdir.root_transport.base):
-                self.ui.warn(_('warning: lightweight checkouts may cause '
+            if (
+                tree is not None
+                and tree.bzrdir.root_transport.base
+                != branch.bzrdir.root_transport.base
+            ):
+                self.ui.warn(
+                    _(
+                        'warning: lightweight checkouts may cause '
                                'conversion failures, try with a regular '
-                               'branch instead.\n'))
+                        'branch instead.\n'
+                    )
+                )
         except Exception:
             self.ui.note(_('bzr source type could not be determined\n'))
 
@@ -119,8 +125,9 b' class bzr_source(common.converter_source'
                     pass
                 revid = info.rev_id
             if revid is None:
-                raise error.Abort(_('%s is not a valid revision')
-                                  % self.revs[0])
+                raise error.Abort(
+                    _('%s is not a valid revision') % self.revs[0]
+                )
             heads = [revid]
         # Empty repositories return 'null:', which cannot be retrieved
         heads = [h for h in heads if h != 'null:']
@@ -139,8 +146,9 b' class bzr_source(common.converter_source'
         if kind == 'symlink':
             target = revtree.get_symlink_target(fileid)
             if target is None:
-                raise error.Abort(_('%s.%s symlink has no target')
-                                 % (name, rev))
+                raise error.Abort(
+                    _('%s.%s symlink has no target') % (name, rev)
+                )
             return target, mode
         else:
             sio = revtree.get_file(fileid)
@@ -171,13 +179,15 b' class bzr_source(common.converter_source'
         branch = self.recode(rev.properties.get('branch-nick', u'default'))
         if branch == 'trunk':
             branch = 'default'
-        return common.commit(parents=parents,
+        return common.commit(
+            parents=parents,
                 date='%d %d' % (rev.timestamp, -rev.timezone),
                 author=self.recode(rev.committer),
                 desc=self.recode(rev.message),
                 branch=branch,
                 rev=version,
-                saverev=self._saverev)
+            saverev=self._saverev,
+        )
 
     def gettags(self):
         bytetags = {}
@@ -216,11 +226,21 b' class bzr_source(common.converter_source'
 
         # Process the entries by reverse lexicographic name order to
         # handle nested renames correctly, most specific first.
-        curchanges = sorted(current.iter_changes(origin),
+        curchanges = sorted(
+            current.iter_changes(origin),
                             key=lambda c: c[1][0] or c[1][1],
-                            reverse=True)
-        for (fileid, paths, changed_content, versioned, parent, name,
-            kind, executable) in curchanges:
+            reverse=True,
+        )
+        for (
+            fileid,
+            paths,
+            changed_content,
+            versioned,
+            parent,
+            name,
+            kind,
+            executable,
+        ) in curchanges:
 
             if paths[0] == u'' or paths[1] == u'':
                 # ignore changes to tree root
@@ -260,9 +280,11 b' class bzr_source(common.converter_source'
                         changes.append((frompath, revid))
                         changes.append((topath, revid))
                         # add to mode cache
-                        mode = ((entry.executable and 'x')
+                        mode = (
+                            (entry.executable and 'x')
                                 or (entry.kind == 'symlink' and 's')
-                                or '')
+                            or ''
+                        )
                         self._modecache[(topath, revid)] = mode
                         # register the change as move
                         renames[topath] = frompath
@@ -290,8 +312,7 b' class bzr_source(common.converter_source'
 
             # populate the mode cache
             kind, executable = [e[1] for e in (kind, executable)]
-            mode = ((executable and 'x') or (kind == 'symlink' and 'l')
-                    or '')
+            mode = (executable and 'x') or (kind == 'symlink' and 'l') or ''
             self._modecache[(topath, revid)] = mode
             changes.append((topath, revid))
 

hgext/convert/common.py

@@ -22,20 +22,19 b' from mercurial import ('
     pycompat,
     util,
 )
-from mercurial.utils import (
-    procutil,
-)
+from mercurial.utils import procutil
 
 pickle = util.pickle
 propertycache = util.propertycache
 
+
 def _encodeornone(d):
     if d is None:
         return
     return d.encode('latin1')
 
+
 class _shlexpy3proxy(object):
-
     def __init__(self, l):
         self._l = l
 
@@ -53,6 +52,7 b' class _shlexpy3proxy(object):'
     def lineno(self):
         return self._l.lineno
 
+
 def shlexer(data=None, filepath=None, wordchars=None, whitespace=None):
     if data is None:
         if pycompat.ispy3:
@@ -62,7 +62,8 b' def shlexer(data=None, filepath=None, wo'
     else:
         if filepath is not None:
             raise error.ProgrammingError(
-                'shlexer only accepts data or filepath, not both')
+                'shlexer only accepts data or filepath, not both'
+            )
         if pycompat.ispy3:
             data = data.decode('latin1')
     l = shlex.shlex(data, infile=filepath, posix=True)
@@ -81,6 +82,7 b' def shlexer(data=None, filepath=None, wo'
         return _shlexpy3proxy(l)
     return l
 
+
 def encodeargs(args):
     def encodearg(s):
         lines = base64.encodestring(s)
@@ -90,13 +92,16 b' def encodeargs(args):'
     s = pickle.dumps(args)
     return encodearg(s)
 
+
 def decodeargs(s):
     s = base64.decodestring(s)
     return pickle.loads(s)
 
+
 class MissingTool(Exception):
     pass
 
+
 def checktool(exe, name=None, abort=True):
     name = name or exe
     if not procutil.findexe(exe):
@@ -106,15 +111,30 b' def checktool(exe, name=None, abort=True'
             exc = MissingTool
         raise exc(_('cannot find required "%s" tool') % name)
 
+
 class NoRepo(Exception):
     pass
 
+
 SKIPREV = 'SKIP'
 
+
 class commit(object):
-    def __init__(self, author, date, desc, parents, branch=None, rev=None,
-                 extra=None, sortkey=None, saverev=True, phase=phases.draft,
-                 optparents=None, ctx=None):
+    def __init__(
+        self,
+        author,
+        date,
+        desc,
+        parents,
+        branch=None,
+        rev=None,
+        extra=None,
+        sortkey=None,
+        saverev=True,
+        phase=phases.draft,
+        optparents=None,
+        ctx=None,
+    ):
         self.author = author or 'unknown'
         self.date = date or '0 0'
         self.desc = desc
@@ -128,6 +148,7 b' class commit(object):'
         self.phase = phase
         self.ctx = ctx # for hg to hg conversions
 
+
 class converter_source(object):
     """Conversion source interface"""
 
@@ -146,8 +167,10 b' class converter_source(object):'
             such format for their revision numbering
         """
         if not re.match(br'[0-9a-fA-F]{40,40}$', revstr):
-            raise error.Abort(_('%s entry %s is not a valid revision'
-                               ' identifier') % (mapname, revstr))
+            raise error.Abort(
+                _('%s entry %s is not a valid revision' ' identifier')
+                % (mapname, revstr)
+            )
 
     def before(self):
         pass
@@ -223,8 +246,9 b' class converter_source(object):'
             try:
                 return s.decode("latin-1").encode("utf-8")
             except UnicodeError:
-                return s.decode(pycompat.sysstr(encoding),
-                                "replace").encode("utf-8")
+                return s.decode(pycompat.sysstr(encoding), "replace").encode(
+                    "utf-8"
+                )
 
     def getchangedfiles(self, rev, i):
         """Return the files changed by rev compared to parent[i].
@@ -275,6 +299,7 b' class converter_source(object):'
         """
         return True
 
+
 class converter_sink(object):
     """Conversion sink (target) interface"""
 
@@ -301,8 +326,9 b' class converter_sink(object):'
         mapping equivalent authors identifiers for each system."""
         return None
 
-    def putcommit(self, files, copies, parents, commit, source, revmap, full,
-                  cleanp2):
+    def putcommit(
+        self, files, copies, parents, commit, source, revmap, full, cleanp2
+    ):
         """Create a revision with all changed files listed in 'files'
         and having listed parents. 'commit' is a commit object
         containing at a minimum the author, date, and message for this
@@ -369,6 +395,7 b' class converter_sink(object):'
         special cases."""
         raise NotImplementedError
 
+
 class commandline(object):
     def __init__(self, ui, command):
         self.ui = ui
@@ -403,11 +430,15 b' class commandline(object):'
 
     def _run(self, cmd, *args, **kwargs):
         def popen(cmdline):
-            p = subprocess.Popen(procutil.tonativestr(cmdline),
-                                 shell=True, bufsize=-1,
+            p = subprocess.Popen(
+                procutil.tonativestr(cmdline),
+                shell=True,
+                bufsize=-1,
                                  close_fds=procutil.closefds,
-                                 stdout=subprocess.PIPE)
+                stdout=subprocess.PIPE,
+            )
             return p
+
         return self._dorun(popen, cmd, *args, **kwargs)
 
     def _run2(self, cmd, *args, **kwargs):
@@ -495,6 +526,7 b' class commandline(object):'
         for l in self._limit_arglist(arglist, cmd, *args, **kwargs):
             self.run0(cmd, *(list(args) + l), **kwargs)
 
+
 class mapfile(dict):
     def __init__(self, ui, path):
         super(mapfile, self).__init__()
@@ -523,7 +555,8 b' class mapfile(dict):'
             except ValueError:
                 raise error.Abort(
                     _('syntax error in %s(%d): key/value pair expected')
-                    % (self.path, i + 1))
+                    % (self.path, i + 1)
+                )
             if key not in self:
                 self.order.append(key)
             super(mapfile, self).__setitem__(key, value)
@@ -535,8 +568,9 b' class mapfile(dict):'
                 self.fp = open(self.path, 'ab')
             except IOError as err:
                 raise error.Abort(
-                    _('could not open map file %r: %s') %
-                    (self.path, encoding.strtolocal(err.strerror)))
+                    _('could not open map file %r: %s')
+                    % (self.path, encoding.strtolocal(err.strerror))
+                )
         self.fp.write(util.tonativeeol('%s %s\n' % (key, value)))
         self.fp.flush()
         super(mapfile, self).__setitem__(key, value)
@@ -546,9 +580,11 b' class mapfile(dict):'
             self.fp.close()
             self.fp = None
 
+
 def makedatetimestamp(t):
     """Like dateutil.makedate() but for time t instead of current time"""
-    delta = (datetime.datetime.utcfromtimestamp(t) -
-             datetime.datetime.fromtimestamp(t))
+    delta = datetime.datetime.utcfromtimestamp(
+        t
+    ) - datetime.datetime.fromtimestamp(t)
     tz = delta.days * 86400 + delta.seconds
     return t, tz

hgext/convert/convcmd.py

@@ -54,12 +54,15 b' svn_source = subversion.svn_source'
 
 orig_encoding = 'ascii'
 
+
 def recode(s):
     if isinstance(s, pycompat.unicode):
         return s.encode(pycompat.sysstr(orig_encoding), 'replace')
     else:
         return s.decode('utf-8').encode(
-            pycompat.sysstr(orig_encoding), 'replace')
+            pycompat.sysstr(orig_encoding), 'replace'
+        )
+
 
 def mapbranch(branch, branchmap):
     '''
@@ -90,10 +93,11 b' def mapbranch(branch, branchmap):'
     branch = branchmap.get(branch or 'default', branch)
     # At some point we used "None" literal to denote the default branch,
     # attempt to use that for backward compatibility.
-    if (not branch):
+    if not branch:
         branch = branchmap.get('None', branch)
     return branch
 
+
 source_converters = [
     ('cvs', convert_cvs, 'branchsort'),
     ('git', convert_git, 'branchsort'),
@@ -111,6 +115,7 b' sink_converters = ['
     ('svn', svn_sink),
     ]
 
+
 def convertsource(ui, path, type, revs):
     exceptions = []
     if type and type not in [s[0] for s in source_converters]:
@@ -126,6 +131,7 b' def convertsource(ui, path, type, revs):'
             ui.write("%s\n" % pycompat.bytestr(inst.args[0]))
     raise error.Abort(_('%s: missing or unsupported repository') % path)
 
+
 def convertsink(ui, path, type):
     if type and type not in [s[0] for s in sink_converters]:
         raise error.Abort(_('%s: invalid destination repository type') % type)
@@ -139,12 +145,14 b' def convertsink(ui, path, type):'
             raise error.Abort('%s\n' % inst)
     raise error.Abort(_('%s: unknown repository type') % path)
 
+
 class progresssource(object):
     def __init__(self, ui, source, filecount):
         self.ui = ui
         self.source = source
-        self.progress = ui.makeprogress(_('getting files'), unit=_('files'),
-                                        total=filecount)
+        self.progress = ui.makeprogress(
+            _('getting files'), unit=_('files'), total=filecount
+        )
 
     def getfile(self, file, rev):
         self.progress.increment(item=file)
@@ -159,6 +167,7 b' class progresssource(object):'
     def close(self):
         self.progress.complete()
 
+
 class converter(object):
     def __init__(self, ui, source, dest, revmapfile, opts):
 
@@ -213,8 +222,13 b' class converter(object):'
                 line = list(lex)
                 # check number of parents
                 if not (2 <= len(line) <= 3):
-                    raise error.Abort(_('syntax error in %s(%d): child parent1'
-                                       '[,parent2] expected') % (path, i + 1))
+                    raise error.Abort(
+                        _(
+                            'syntax error in %s(%d): child parent1'
+                            '[,parent2] expected'
+                        )
+                        % (path, i + 1)
+                    )
                 for part in line:
                     self.source.checkrevformat(part)
                 child, p1, p2 = line[0], line[1:2], line[2:]
@@ -224,11 +238,11 b' class converter(object):'
                     m[child] = p1 + p2
          # if file does not exist or error reading, exit
         except IOError:
-            raise error.Abort(_('splicemap file not found or error reading %s:')
-                               % path)
+            raise error.Abort(
+                _('splicemap file not found or error reading %s:') % path
+            )
         return m
 
-
     def walktree(self, heads):
         '''Return a mapping that identifies the uncommitted parents of every
         uncommitted changeset.'''
@@ -236,8 +250,9 b' class converter(object):'
         known = set()
         parents = {}
         numcommits = self.source.numcommits()
-        progress = self.ui.makeprogress(_('scanning'), unit=_('revisions'),
-                                        total=numcommits)
+        progress = self.ui.makeprogress(
+            _('scanning'), unit=_('revisions'), total=numcommits
+        )
         while visit:
             n = visit.pop(0)
             if n in known:
@@ -266,8 +281,13 b' class converter(object):'
             if c not in parents:
                 if not self.dest.hascommitforsplicemap(self.map.get(c, c)):
                     # Could be in source but not converted during this run
-                    self.ui.warn(_('splice map revision %s is not being '
-                                   'converted, ignoring\n') % c)
+                    self.ui.warn(
+                        _(
+                            'splice map revision %s is not being '
+                            'converted, ignoring\n'
+                        )
+                        % c
+                    )
                 continue
             pc = []
             for p in splicemap[c]:
@@ -325,6 +345,7 b' class converter(object):'
             compression.
             """
             prev = [None]
+
             def picknext(nodes):
                 next = nodes[0]
                 for n in nodes:
@@ -333,26 +354,34 b' class converter(object):'
                         break
                 prev[0] = next
                 return next
+
             return picknext
 
         def makesourcesorter():
             """Source specific sort."""
             keyfn = lambda n: self.commitcache[n].sortkey
+
             def picknext(nodes):
                 return sorted(nodes, key=keyfn)[0]
+
             return picknext
 
         def makeclosesorter():
             """Close order sort."""
-            keyfn = lambda n: ('close' not in self.commitcache[n].extra,
-                               self.commitcache[n].sortkey)
+            keyfn = lambda n: (
+                'close' not in self.commitcache[n].extra,
+                self.commitcache[n].sortkey,
+            )
+
             def picknext(nodes):
                 return sorted(nodes, key=keyfn)[0]
+
             return picknext
 
         def makedatesorter():
             """Sort revisions by date."""
             dates = {}
+
             def getdate(n):
                 if n not in dates:
                     dates[n] = dateutil.parsedate(self.commitcache[n].date)
@@ -390,8 +419,10 b' class converter(object):'
                 try:
                     pendings[c].remove(n)
                 except ValueError:
-                    raise error.Abort(_('cycle detected between %s and %s')
-                                       % (recode(c), recode(n)))
+                    raise error.Abort(
+                        _('cycle detected between %s and %s')
+                        % (recode(c), recode(n))
+                    )
                 if not pendings[c]:
                     # Parents are converted, node is eligible
                     actives.insert(0, c)
@@ -408,8 +439,9 b' class converter(object):'
             self.ui.status(_('writing author map file %s\n') % authorfile)
             ofile = open(authorfile, 'wb+')
             for author in self.authors:
-                ofile.write(util.tonativeeol("%s=%s\n"
-                                             % (author, self.authors[author])))
+                ofile.write(
+                    util.tonativeeol("%s=%s\n" % (author, self.authors[author]))
+                )
             ofile.close()
 
     def readauthormap(self, authorfile):
@@ -464,19 +496,22 b' class converter(object):'
             for prev in commit.parents:
                 if prev not in self.commitcache:
                     self.cachecommit(prev)
-                pbranches.append((self.map[prev],
-                                  self.commitcache[prev].branch))
+                pbranches.append(
+                    (self.map[prev], self.commitcache[prev].branch)
+                )
         self.dest.setbranch(commit.branch, pbranches)
         try:
             parents = self.splicemap[rev]
-            self.ui.status(_('spliced in %s as parents of %s\n') %
-                           (_(' and ').join(parents), rev))
+            self.ui.status(
+                _('spliced in %s as parents of %s\n')
+                % (_(' and ').join(parents), rev)
+            )
             parents = [self.map.get(p, p) for p in parents]
         except KeyError:
             parents = [b[0] for b in pbranches]
-            parents.extend(self.map[x]
-                           for x in commit.optparents
-                           if x in self.map)
+            parents.extend(
+                self.map[x] for x in commit.optparents if x in self.map
+            )
         if len(pbranches) != 2:
             cleanp2 = set()
         if len(parents) < 3:
@@ -486,10 +521,12 b' class converter(object):'
             # changed files N-1 times. This tweak to the number of
             # files makes it so the progress bar doesn't overflow
             # itself.
-            source = progresssource(self.ui, self.source,
-                                    len(files) * (len(parents) - 1))
-        newnode = self.dest.putcommit(files, copies, parents, commit,
-                                      source, self.map, full, cleanp2)
+            source = progresssource(
+                self.ui, self.source, len(files) * (len(parents) - 1)
+            )
+        newnode = self.dest.putcommit(
+            files, copies, parents, commit, source, self.map, full, cleanp2
+        )
         source.close()
         self.source.converted(rev, newnode)
         self.map[rev] = newnode
@@ -509,8 +546,9 b' class converter(object):'
             c = None
 
             self.ui.status(_("converting...\n"))
-            progress = self.ui.makeprogress(_('converting'),
-                                            unit=_('revisions'), total=len(t))
+            progress = self.ui.makeprogress(
+                _('converting'), unit=_('revisions'), total=len(t)
+            )
             for i, c in enumerate(t):
                 num -= 1
                 desc = self.commitcache[c].desc
@@ -538,8 +576,11 b' class converter(object):'
                     if nrev and tagsparent:
                         # write another hash correspondence to override the
                         # previous one so we don't end up with extra tag heads
-                        tagsparents = [e for e in self.map.iteritems()
-                                       if e[1] == tagsparent]
+                        tagsparents = [
+                            e
+                            for e in self.map.iteritems()
+                            if e[1] == tagsparent
+                        ]
                         if tagsparents:
                             self.map[tagsparents[0][0]] = nrev
 
@@ -564,6 +605,7 b' class converter(object):'
             self.source.after()
         self.map.close()
 
+
 def convert(ui, src, dest=None, revmapfile=None, **opts):
     opts = pycompat.byteskwargs(opts)
     global orig_encoding
@@ -582,8 +624,9 b' def convert(ui, src, dest=None, revmapfi'
     destc = scmutil.wrapconvertsink(destc)
 
     try:
-        srcc, defaultsort = convertsource(ui, src, opts.get('source_type'),
-                                          opts.get('rev'))
+        srcc, defaultsort = convertsource(
+            ui, src, opts.get('source_type'), opts.get('rev')
+        )
     except Exception:
         for path in destc.created:
             shutil.rmtree(path, True)
@@ -599,7 +642,8 b' def convert(ui, src, dest=None, revmapfi'
         sortmode = defaultsort
 
     if sortmode == 'sourcesort' and not srcc.hasnativeorder():
-        raise error.Abort(_('--sourcesort is not supported by this data source')
+        raise error.Abort(
+            _('--sourcesort is not supported by this data source')
                          )
     if sortmode == 'closesort' and not srcc.hasnativeclose():
         raise error.Abort(_('--closesort is not supported by this data source'))

hgext/convert/cvs.py

@@ -34,6 +34,7 b' converter_source = common.converter_sour'
 makedatetimestamp = common.makedatetimestamp
 NoRepo = common.NoRepo
 
+
 class convert_cvs(converter_source):
     def __init__(self, ui, repotype, path, revs=None):
         super(convert_cvs, self).__init__(ui, repotype, path, revs=revs)
@@ -63,15 +64,17 b' class convert_cvs(converter_source):'
         maxrev = 0
         if self.revs:
             if len(self.revs) > 1:
-                raise error.Abort(_('cvs source does not support specifying '
-                                   'multiple revs'))
+                raise error.Abort(
+                    _('cvs source does not support specifying ' 'multiple revs')
+                )
             # TODO: handle tags
             try:
                 # patchset number?
                 maxrev = int(self.revs[0])
             except ValueError:
-                raise error.Abort(_('revision %s is not a patchset number')
-                                 % self.revs[0])
+                raise error.Abort(
+                    _('revision %s is not a patchset number') % self.revs[0]
+                )
 
         d = encoding.getcwd()
         try:
@@ -81,15 +84,18 b' class convert_cvs(converter_source):'
             if not self.ui.configbool('convert', 'cvsps.cache'):
                 cache = None
             db = cvsps.createlog(self.ui, cache=cache)
-            db = cvsps.createchangeset(self.ui, db,
+            db = cvsps.createchangeset(
+                self.ui,
+                db,
                 fuzz=int(self.ui.config('convert', 'cvsps.fuzz')),
                 mergeto=self.ui.config('convert', 'cvsps.mergeto'),
-                mergefrom=self.ui.config('convert', 'cvsps.mergefrom'))
+                mergefrom=self.ui.config('convert', 'cvsps.mergefrom'),
+            )
 
             for cs in db:
                 if maxrev and cs.id > maxrev:
                     break
-                id = (b"%d" % cs.id)
+                id = b"%d" % cs.id
                 cs.author = self.recode(cs.author)
                 self.lastbranch[cs.branch] = id
                 cs.comment = self.recode(cs.comment)
@@ -100,14 +106,19 b' class convert_cvs(converter_source):'
 
                 files = {}
                 for f in cs.entries:
-                    files[f.file] = "%s%s" % ('.'.join([(b"%d" % x)
-                                                        for x in f.revision]),
-                                              ['', '(DEAD)'][f.dead])
+                    files[f.file] = "%s%s" % (
+                        '.'.join([(b"%d" % x) for x in f.revision]),
+                        ['', '(DEAD)'][f.dead],
+                    )
 
                 # add current commit to set
-                c = commit(author=cs.author, date=date,
+                c = commit(
+                    author=cs.author,
+                    date=date,
                            parents=[(b"%d" % p.id) for p in cs.parents],
-                           desc=cs.comment, branch=cs.branch or '')
+                    desc=cs.comment,
+                    branch=cs.branch or '',
+                )
                 self.changeset[id] = c
                 self.files[id] = files
 
@@ -125,8 +136,9 b' class convert_cvs(converter_source):'
 
         if root.startswith(":pserver:"):
             root = root[9:]
-            m = re.match(r'(?:(.*?)(?::(.*?))?@)?([^:\/]*)(?::(\d*))?(.*)',
-                         root)
+            m = re.match(
+                r'(?:(.*?)(?::(.*?))?@)?([^:\/]*)(?::(\d*))?(.*)', root
+            )
             if m:
                 conntype = "pserver"
                 user, passw, serv, port, root = m.groups()
@@ -166,8 +178,18 b' class convert_cvs(converter_source):'
 
                 sck = socket.socket()
                 sck.connect((serv, port))
-                sck.send("\n".join(["BEGIN AUTH REQUEST", root, user, passw,
-                                    "END AUTH REQUEST", ""]))
+                sck.send(
+                    "\n".join(
+                        [
+                            "BEGIN AUTH REQUEST",
+                            root,
+                            user,
+                            passw,
+                            "END AUTH REQUEST",
+                            "",
+                        ]
+                    )
+                )
                 if sck.recv(128) != "I LOVE YOU\n":
                     raise error.Abort(_("CVS pserver authentication failed"))
 
@@ -205,16 +227,22 b' class convert_cvs(converter_source):'
         self.realroot = root
 
         self.writep.write("Root %s\n" % root)
-        self.writep.write("Valid-responses ok error Valid-requests Mode"
+        self.writep.write(
+            "Valid-responses ok error Valid-requests Mode"
                           " M Mbinary E Checked-in Created Updated"
-                          " Merged Removed\n")
+            " Merged Removed\n"
+        )
         self.writep.write("valid-requests\n")
         self.writep.flush()
         r = self.readp.readline()
         if not r.startswith("Valid-requests"):
-            raise error.Abort(_('unexpected response from CVS server '
-                               '(expected "Valid-requests", but got %r)')
-                             % r)
+            raise error.Abort(
+                _(
+                    'unexpected response from CVS server '
+                    '(expected "Valid-requests", but got %r)'
+                )
+                % r
+            )
         if "UseUnchanged" in r:
             self.writep.write("UseUnchanged\n")
             self.writep.flush()
@@ -225,7 +253,6 b' class convert_cvs(converter_source):'
         return self.heads
 
     def getfile(self, name, rev):
-
         def chunkedread(fp, count):
             # file-objects returned by socket.makefile() do not handle
             # large read() requests very well.
@@ -234,8 +261,9 b' class convert_cvs(converter_source):'
             while count > 0:
                 data = fp.read(min(count, chunksize))
                 if not data:
-                    raise error.Abort(_("%d bytes missing from remote file")
-                                     % count)
+                    raise error.Abort(
+                        _("%d bytes missing from remote file") % count
+                    )
                 count -= len(data)
                 output.write(data)
             return output.getvalue()

hgext/convert/cvsps.py

@@ -26,6 +26,7 b' from mercurial.utils import ('
 
 pickle = util.pickle
 
+
 class logentry(object):
     '''Class logentry has the following attributes:
         .author    - author name as CVS knows it
@@ -46,17 +47,22 b' class logentry(object):'
                       rlog output) or None
         .branchpoints - the branches that start at the current entry or empty
     '''
+
     def __init__(self, **entries):
         self.synthetic = False
         self.__dict__.update(entries)
 
     def __repr__(self):
-        items = (r"%s=%r"%(k, self.__dict__[k]) for k in sorted(self.__dict__))
+        items = (
+            r"%s=%r" % (k, self.__dict__[k]) for k in sorted(self.__dict__)
+        )
         return r"%s(%s)"%(type(self).__name__, r", ".join(items))
 
+
 class logerror(Exception):
     pass
 
+
 def getrepopath(cvspath):
     """Return the repository path from a CVS path.
 
@@ -96,12 +102,14 b' def getrepopath(cvspath):'
     repopath = parts[-1][parts[-1].find('/', start):]
     return repopath
 
+
 def createlog(ui, directory=None, root="", rlog=True, cache=None):
     '''Collect the CVS rlog'''
 
     # Because we store many duplicate commit log messages, reusing strings
     # saves a lot of memory and pickle storage space.
     _scache = {}
+
     def scache(s):
         "return a shared version of a string"
         return _scache.setdefault(s, s)
@@ -114,19 +122,24 b' def createlog(ui, directory=None, root="'
     re_00 = re.compile(b'RCS file: (.+)$')
     re_01 = re.compile(b'cvs \\[r?log aborted\\]: (.+)$')
     re_02 = re.compile(b'cvs (r?log|server): (.+)\n$')
-    re_03 = re.compile(b"(Cannot access.+CVSROOT)|"
-                       b"(can't create temporary directory.+)$")
+    re_03 = re.compile(
+        b"(Cannot access.+CVSROOT)|" b"(can't create temporary directory.+)$"
+    )
     re_10 = re.compile(b'Working file: (.+)$')
     re_20 = re.compile(b'symbolic names:')
     re_30 = re.compile(b'\t(.+): ([\\d.]+)$')
     re_31 = re.compile(b'----------------------------$')
-    re_32 = re.compile(b'======================================='
-                       b'======================================$')
+    re_32 = re.compile(
+        b'======================================='
+        b'======================================$'
+    )
     re_50 = re.compile(br'revision ([\d.]+)(\s+locked by:\s+.+;)?$')
-    re_60 = re.compile(br'date:\s+(.+);\s+author:\s+(.+);\s+state:\s+(.+?);'
+    re_60 = re.compile(
+        br'date:\s+(.+);\s+author:\s+(.+);\s+state:\s+(.+?);'
                        br'(\s+lines:\s+(\+\d+)?\s+(-\d+)?;)?'
                        br'(\s+commitid:\s+([^;]+);)?'
-                       br'(.*mergepoint:\s+([^;]+);)?')
+        br'(.*mergepoint:\s+([^;]+);)?'
+    )
     re_70 = re.compile(b'branches: (.+);$')
 
     file_added_re = re.compile(br'file [^/]+ was (initially )?added on branch')
@@ -178,17 +191,20 b' def createlog(ui, directory=None, root="'
         # are mapped to different cache file names.
         cachefile = root.split(":") + [directory, "cache"]
         cachefile = ['-'.join(re.findall(br'\w+', s)) for s in cachefile if s]
-        cachefile = os.path.join(cachedir,
-                                 '.'.join([s for s in cachefile if s]))
+        cachefile = os.path.join(
+            cachedir, '.'.join([s for s in cachefile if s])
+        )
 
     if cache == 'update':
         try:
             ui.note(_('reading cvs log cache %s\n') % cachefile)
             oldlog = pickle.load(open(cachefile, 'rb'))
             for e in oldlog:
-                if not (util.safehasattr(e, 'branchpoints') and
-                        util.safehasattr(e, 'commitid') and
-                        util.safehasattr(e, 'mergepoint')):
+                if not (
+                    util.safehasattr(e, 'branchpoints')
+                    and util.safehasattr(e, 'commitid')
+                    and util.safehasattr(e, 'mergepoint')
+                ):
                     ui.status(_('ignoring old cache\n'))
                     oldlog = []
                     break
@@ -310,8 +326,9 b' def createlog(ui, directory=None, root="'
             if re_31.match(line):
                 state = 5
             else:
-                assert not re_32.match(line), _('must have at least '
-                                                'some revisions')
+                assert not re_32.match(line), _(
+                    'must have at least ' 'some revisions'
+                )
 
         elif state == 5:
             # expecting revision number and possibly (ignored) lock indication
@@ -319,15 +336,16 b' def createlog(ui, directory=None, root="'
             # as this state is re-entered for subsequent revisions of a file.
             match = re_50.match(line)
             assert match, _('expected revision number')
-            e = logentry(rcs=scache(rcs),
+            e = logentry(
+                rcs=scache(rcs),
                          file=scache(filename),
-                         revision=tuple([int(x) for x in
-                                         match.group(1).split('.')]),
+                revision=tuple([int(x) for x in match.group(1).split('.')]),
                          branches=[],
                          parent=None,
                          commitid=None,
                          mergepoint=None,
-                         branchpoints=set())
+                branchpoints=set(),
+            )
 
             state = 6
 
@@ -343,9 +361,10 b' def createlog(ui, directory=None, root="'
             if len(d.split()) != 3:
                 # cvs log dates always in GMT
                 d = d + ' UTC'
-            e.date = dateutil.parsedate(d, ['%y/%m/%d %H:%M:%S',
-                                        '%Y/%m/%d %H:%M:%S',
-                                        '%Y-%m-%d %H:%M:%S'])
+            e.date = dateutil.parsedate(
+                d,
+                ['%y/%m/%d %H:%M:%S', '%Y/%m/%d %H:%M:%S', '%Y-%m-%d %H:%M:%S'],
+            )
             e.author = scache(match.group(2))
             e.dead = match.group(3).lower() == 'dead'
 
@@ -369,8 +388,9 b' def createlog(ui, directory=None, root="'
                 else:
                     myrev = '.'.join(myrev[:-2] + ['0', myrev[-2]])
                     branches = [b for b in branchmap if branchmap[b] == myrev]
-                    assert len(branches) == 1, ('unknown branch: %s'
-                                                % e.mergepoint)
+                    assert len(branches) == 1, (
+                        'unknown branch: %s' % e.mergepoint
+                    )
                     e.mergepoint = branches[0]
 
             e.comment = []
@@ -381,8 +401,10 b' def createlog(ui, directory=None, root="'
             # or store the commit log message otherwise
             m = re_70.match(line)
             if m:
-                e.branches = [tuple([int(y) for y in x.strip().split('.')])
-                                for x in m.group(1).split(';')]
+                e.branches = [
+                    tuple([int(y) for y in x.strip().split('.')])
+                    for x in m.group(1).split(';')
+                ]
                 state = 8
             elif re_31.match(line) and re_50.match(peek):
                 state = 5
@@ -417,13 +439,16 b' def createlog(ui, directory=None, root="'
         # creates a synthetic dead revision 1.1.x.1 on B2.  Don't drop
         # these revisions now, but mark them synthetic so
         # createchangeset() can take care of them.
-        if (store and
-              e.dead and
-              e.revision[-1] == 1 and      # 1.1 or 1.1.x.1
-              len(e.comment) == 1 and
-              file_added_re.match(e.comment[0])):
-            ui.debug('found synthetic revision in %s: %r\n'
-                     % (e.rcs, e.comment[0]))
+        if (
+            store
+            and e.dead
+            and e.revision[-1] == 1
+            and len(e.comment) == 1  # 1.1 or 1.1.x.1
+            and file_added_re.match(e.comment[0])
+        ):
+            ui.debug(
+                'found synthetic revision in %s: %r\n' % (e.rcs, e.comment[0])
+            )
             e.synthetic = True
 
         if store:
@@ -458,8 +483,9 b' def createlog(ui, directory=None, root="'
             rcsmap[e.rcs.replace('/Attic/', '/')] = e.rcs
 
             if len(log) % 100 == 0:
-                ui.status(stringutil.ellipsis('%d %s' % (len(log), e.file), 80)
-                          + '\n')
+                ui.status(
+                    stringutil.ellipsis('%d %s' % (len(log), e.file), 80) + '\n'
+                )
 
     log.sort(key=lambda x: (x.rcs, x.revision))
 
@@ -487,8 +513,12 b' def createlog(ui, directory=None, root="'
             log.sort(key=lambda x: x.date)
 
             if oldlog and oldlog[-1].date >= log[0].date:
-                raise logerror(_('log cache overlaps with new log entries,'
-                                 ' re-run without cache.'))
+                raise logerror(
+                    _(
+                        'log cache overlaps with new log entries,'
+                        ' re-run without cache.'
+                    )
+                )
 
             log = oldlog + log
 
@@ -502,6 +532,7 b' def createlog(ui, directory=None, root="'
 
     encodings = ui.configlist('convert', 'cvsps.logencoding')
     if encodings:
+
         def revstr(r):
             # this is needed, because logentry.revision is a tuple of "int"
             # (e.g. (1, 2) for "1.2")
@@ -511,24 +542,33 b' def createlog(ui, directory=None, root="'
             comment = entry.comment
             for e in encodings:
                 try:
-                    entry.comment = comment.decode(
-                        pycompat.sysstr(e)).encode('utf-8')
+                    entry.comment = comment.decode(pycompat.sysstr(e)).encode(
+                        'utf-8'
+                    )
                     if ui.debugflag:
-                        ui.debug("transcoding by %s: %s of %s\n" %
-                                 (e, revstr(entry.revision), entry.file))
+                        ui.debug(
+                            "transcoding by %s: %s of %s\n"
+                            % (e, revstr(entry.revision), entry.file)
+                        )
                     break
                 except UnicodeDecodeError:
                     pass # try next encoding
                 except LookupError as inst: # unknown encoding, maybe
-                    raise error.Abort(inst,
-                                      hint=_('check convert.cvsps.logencoding'
-                                             ' configuration'))
+                    raise error.Abort(
+                        inst,
+                        hint=_(
+                            'check convert.cvsps.logencoding' ' configuration'
+                        ),
+                    )
             else:
-                raise error.Abort(_("no encoding can transcode"
-                                    " CVS log message for %s of %s")
+                raise error.Abort(
+                    _(
+                        "no encoding can transcode"
+                        " CVS log message for %s of %s"
+                    )
                                   % (revstr(entry.revision), entry.file),
-                                  hint=_('check convert.cvsps.logencoding'
-                                         ' configuration'))
+                    hint=_('check convert.cvsps.logencoding' ' configuration'),
+                )
 
     hook.hook(ui, None, "cvslog", True, log=log)
 
@@ -550,6 +590,7 b' class changeset(object):'
         .mergepoint- the branch that has been merged from or None
         .branchpoints- the branches that start at the current entry or empty
     '''
+
     def __init__(self, **entries):
         self.id = None
         self.synthetic = False
@@ -559,6 +600,7 b' class changeset(object):'
         items = ("%s=%r"%(k, self.__dict__[k]) for k in sorted(self.__dict__))
         return "%s(%s)"%(type(self).__name__, ", ".join(items))
 
+
 def createchangeset(ui, log, fuzz=60, mergefrom=None, mergeto=None):
     '''Convert log into changesets.'''
 
@@ -574,9 +616,17 b' def createchangeset(ui, log, fuzz=60, me'
                 mindate[e.commitid] = min(e.date, mindate[e.commitid])
 
     # Merge changesets
-    log.sort(key=lambda x: (mindate.get(x.commitid, (-1, 0)),
-                            x.commitid or '', x.comment,
-                            x.author, x.branch or '', x.date, x.branchpoints))
+    log.sort(
+        key=lambda x: (
+            mindate.get(x.commitid, (-1, 0)),
+            x.commitid or '',
+            x.comment,
+            x.author,
+            x.branch or '',
+            x.date,
+            x.branchpoints,
+        )
+    )
 
     changesets = []
     files = set()
@@ -599,22 +649,35 b' def createchangeset(ui, log, fuzz=60, me'
         # first changeset and bar the next and MYBRANCH and MYBRANCH2
         # should both start off of the bar changeset. No provisions are
         # made to ensure that this is, in fact, what happens.
-        if not (c and e.branchpoints == c.branchpoints and
-                (# cvs commitids
-                 (e.commitid is not None and e.commitid == c.commitid) or
-                 (# no commitids, use fuzzy commit detection
-                  (e.commitid is None or c.commitid is None) and
-                   e.comment == c.comment and
-                   e.author == c.author and
-                   e.branch == c.branch and
-                   ((c.date[0] + c.date[1]) <=
-                    (e.date[0] + e.date[1]) <=
-                    (c.date[0] + c.date[1]) + fuzz) and
-                   e.file not in files))):
-            c = changeset(comment=e.comment, author=e.author,
-                          branch=e.branch, date=e.date,
-                          entries=[], mergepoint=e.mergepoint,
-                          branchpoints=e.branchpoints, commitid=e.commitid)
+        if not (
+            c
+            and e.branchpoints == c.branchpoints
+            and (  # cvs commitids
+                (e.commitid is not None and e.commitid == c.commitid)
+                or (  # no commitids, use fuzzy commit detection
+                    (e.commitid is None or c.commitid is None)
+                    and e.comment == c.comment
+                    and e.author == c.author
+                    and e.branch == c.branch
+                    and (
+                        (c.date[0] + c.date[1])
+                        <= (e.date[0] + e.date[1])
+                        <= (c.date[0] + c.date[1]) + fuzz
+                    )
+                    and e.file not in files
+                )
+            )
+        ):
+            c = changeset(
+                comment=e.comment,
+                author=e.author,
+                branch=e.branch,
+                date=e.date,
+                entries=[],
+                mergepoint=e.mergepoint,
+                branchpoints=e.branchpoints,
+                commitid=e.commitid,
+            )
             changesets.append(c)
 
             files = set()
@@ -665,6 +728,7 b' def createchangeset(ui, log, fuzz=60, me'
     # Sort changesets by date
 
     odd = set()
+
     def cscmp(l, r):
         d = sum(l.date) - sum(r.date)
         if d:
@@ -777,8 +841,9 b' def createchangeset(ui, log, fuzz=60, me'
 
             # Ensure no changeset has a synthetic changeset as a parent.
             while p.synthetic:
-                assert len(p.parents) <= 1, (
-                       _('synthetic changeset cannot have multiple parents'))
+                assert len(p.parents) <= 1, _(
+                    'synthetic changeset cannot have multiple parents'
+                )
                 if p.parents:
                     p = p.parents[0]
                 else:
@@ -802,9 +867,13 b' def createchangeset(ui, log, fuzz=60, me'
                 try:
                     candidate = changesets[branches[m]]
                 except KeyError:
-                    ui.warn(_("warning: CVS commit message references "
-                              "non-existent branch %r:\n%s\n")
-                            % (pycompat.bytestr(m), c.comment))
+                    ui.warn(
+                        _(
+                            "warning: CVS commit message references "
+                            "non-existent branch %r:\n%s\n"
+                        )
+                        % (pycompat.bytestr(m), c.comment)
+                    )
                 if m in branches and c.branch != m and not candidate.synthetic:
                     c.parents.append(candidate)
 
@@ -820,11 +889,15 b' def createchangeset(ui, log, fuzz=60, me'
                 if m in branches and c.branch != m:
                     # insert empty changeset for merge
                     cc = changeset(
-                        author=c.author, branch=m, date=c.date,
+                        author=c.author,
+                        branch=m,
+                        date=c.date,
                         comment='convert-repo: CVS merge from branch %s'
                         % c.branch,
-                        entries=[], tags=[],
-                        parents=[changesets[branches[m]], c])
+                        entries=[],
+                        tags=[],
+                        parents=[changesets[branches[m]], c],
+                    )
                     changesets.insert(i + 1, cc)
                     branches[m] = i + 1
 
@@ -853,8 +926,10 b' def createchangeset(ui, log, fuzz=60, me'
     if odd:
         for l, r in odd:
             if l.id is not None and r.id is not None:
-                ui.warn(_('changeset %d is both before and after %d\n')
-                        % (l.id, r.id))
+                ui.warn(
+                    _('changeset %d is both before and after %d\n')
+                    % (l.id, r.id)
+                )
 
     ui.status(_('%d changeset entries\n') % len(changesets))
 
@@ -901,8 +976,10 b' def debugcvsps(ui, *args, **opts):'
 
         if opts["ancestors"]:
             if cs.branch not in branches and cs.parents and cs.parents[0].id:
-                ancestors[cs.branch] = (changesets[cs.parents[0].id - 1].branch,
-                                        cs.parents[0].id)
+                ancestors[cs.branch] = (
+                    changesets[cs.parents[0].id - 1].branch,
+                    cs.parents[0].id,
+                )
             branches[cs.branch] = cs.id
 
         # limit by branches
@@ -914,19 +991,35 b' def debugcvsps(ui, *args, **opts):'
             #       bug-for-bug compatibility with cvsps.
             ui.write('---------------------\n')
             ui.write(('PatchSet %d \n' % cs.id))
-            ui.write(('Date: %s\n' % dateutil.datestr(cs.date,
-                                                 '%Y/%m/%d %H:%M:%S %1%2')))
+            ui.write(
+                (
+                    'Date: %s\n'
+                    % dateutil.datestr(cs.date, '%Y/%m/%d %H:%M:%S %1%2')
+                )
+            )
             ui.write(('Author: %s\n' % cs.author))
             ui.write(('Branch: %s\n' % (cs.branch or 'HEAD')))
-            ui.write(('Tag%s: %s \n' % (['', 's'][len(cs.tags) > 1],
-                                  ','.join(cs.tags) or '(none)')))
+            ui.write(
+                (
+                    'Tag%s: %s \n'
+                    % (
+                        ['', 's'][len(cs.tags) > 1],
+                        ','.join(cs.tags) or '(none)',
+                    )
+                )
+            )
             if cs.branchpoints:
-                ui.write(('Branchpoints: %s \n') %
-                         ', '.join(sorted(cs.branchpoints)))
+                ui.write(
+                    'Branchpoints: %s \n' % ', '.join(sorted(cs.branchpoints))
+                )
             if opts["parents"] and cs.parents:
                 if len(cs.parents) > 1:
-                    ui.write(('Parents: %s\n' %
-                             (','.join([(b"%d" % p.id) for p in cs.parents]))))
+                    ui.write(
+                        (
+                            'Parents: %s\n'
+                            % (','.join([(b"%d" % p.id) for p in cs.parents]))
+                        )
+                    )
                 else:
                     ui.write(('Parent: %d\n' % cs.parents[0].id))
 
@@ -939,28 +1032,30 b' def debugcvsps(ui, *args, **opts):'
                 if r:
                     ui.write(('Ancestors: %s\n' % (','.join(r))))
 
-            ui.write(('Log:\n'))
+            ui.write('Log:\n')
             ui.write('%s\n\n' % cs.comment)
-            ui.write(('Members: \n'))
+            ui.write('Members: \n')
             for f in cs.entries:
                 fn = f.file
                 if fn.startswith(opts["prefix"]):
                     fn = fn[len(opts["prefix"]):]
-                ui.write('\t%s:%s->%s%s \n' % (
+                ui.write(
+                    '\t%s:%s->%s%s \n'
+                    % (
                         fn,
                         '.'.join([b"%d" % x for x in f.parent]) or 'INITIAL',
                         '.'.join([(b"%d" % x) for x in f.revision]),
-                        ['', '(DEAD)'][f.dead]))
+                        ['', '(DEAD)'][f.dead],
+                    )
+                )
             ui.write('\n')
 
         # have we seen the start tag?
         if revisions and off:
-            if (revisions[0] == (b"%d" % cs.id) or
-                revisions[0] in cs.tags):
+            if revisions[0] == (b"%d" % cs.id) or revisions[0] in cs.tags:
                 off = False
 
         # see if we reached the end tag
         if len(revisions) > 1 and not off:
-            if (revisions[1] == (b"%d" % cs.id) or
-                revisions[1] in cs.tags):
+            if revisions[1] == (b"%d" % cs.id) or revisions[1] in cs.tags:
                 break

hgext/convert/darcs.py

@@ -19,6 +19,7 b' from mercurial import ('
 )
 from mercurial.utils import dateutil
 from . import common
+
 NoRepo = common.NoRepo
 
 # The naming drift of ElementTree is fun!
@@ -41,6 +42,7 b' except ImportError:'
             except ImportError:
                 pass
 
+
 class darcs_source(common.converter_source, common.commandline):
     def __init__(self, ui, repotype, path, revs=None):
         common.converter_source.__init__(self, ui, repotype, path, revs=revs)
@@ -54,8 +56,9 b' class darcs_source(common.converter_sour'
         common.checktool('darcs')
         version = self.run0('--version').splitlines()[0].strip()
         if version < '2.1':
-            raise error.Abort(_('darcs version 2.1 or newer needed (found %r)')
-                              % version)
+            raise error.Abort(
+                _('darcs version 2.1 or newer needed (found %r)') % version
+            )
 
         if "ElementTree" not in globals():
             raise error.Abort(_("Python ElementTree module is not available"))
@@ -71,19 +74,23 b' class darcs_source(common.converter_sour'
         format = self.format()
         if format:
             if format in ('darcs-1.0', 'hashed'):
-                raise NoRepo(_("%s repository format is unsupported, "
-                               "please upgrade") % format)
+                raise NoRepo(
+                    _("%s repository format is unsupported, " "please upgrade")
+                    % format
+                )
         else:
             self.ui.warn(_('failed to detect repository format!'))
 
     def before(self):
         self.tmppath = pycompat.mkdtemp(
-            prefix='convert-' + os.path.basename(self.path) + '-')
+            prefix='convert-' + os.path.basename(self.path) + '-'
+        )
         output, status = self.run('init', repodir=self.tmppath)
         self.checkexit(status)
 
-        tree = self.xml('changes', xml_output=True, summary=True,
-                        repodir=self.path)
+        tree = self.xml(
+            'changes', xml_output=True, summary=True, repodir=self.path
+        )
         tagname = None
         child = None
         for elt in tree.findall('patch'):
@@ -135,8 +142,9 b' class darcs_source(common.converter_sour'
 
     def manifest(self):
         man = []
-        output, status = self.run('show', 'files', no_directories=True,
-                                  repodir=self.tmppath)
+        output, status = self.run(
+            'show', 'files', no_directories=True, repodir=self.tmppath
+        )
         self.checkexit(status)
         for line in output.split('\n'):
             path = line[2:]
@@ -155,17 +163,24 b' class darcs_source(common.converter_sour'
         # etree can return unicode objects for name, comment, and author,
         # so recode() is used to ensure str objects are emitted.
         newdateformat = '%Y-%m-%d %H:%M:%S %1%2'
-        return common.commit(author=self.recode(elt.get('author')),
+        return common.commit(
+            author=self.recode(elt.get('author')),
                              date=dateutil.datestr(date, newdateformat),
                              desc=self.recode(desc).strip(),
-                             parents=self.parents[rev])
+            parents=self.parents[rev],
+        )
 
     def pull(self, rev):
-        output, status = self.run('pull', self.path, all=True,
+        output, status = self.run(
+            'pull',
+            self.path,
+            all=True,
                                   match='hash %s' % rev,
-                                  no_test=True, no_posthook=True,
+            no_test=True,
+            no_posthook=True,
                                   external_merge='/bin/false',
-                                  repodir=self.tmppath)
+            repodir=self.tmppath,
+        )
         if status:
             if output.find('We have conflicts in') == -1:
                 self.checkexit(status, output)

hgext/convert/filemap.py

@@ -14,8 +14,10 b' from mercurial import ('
     pycompat,
 )
 from . import common
+
 SKIPREV = common.SKIPREV
 
+
 def rpairs(path):
     '''Yield tuples with path split at '/', starting with the full path.
     No leading, trailing or double '/', please.
@@ -31,6 +33,7 b' def rpairs(path):'
         i = path.rfind('/', 0, i)
     yield '.', path
 
+
 def normalize(path):
     ''' We use posixpath.normpath to support cross-platform path format.
     However, it doesn't handle None input. So we wrap it up. '''
@@ -38,6 +41,7 b' def normalize(path):'
         return None
     return posixpath.normpath(path)
 
+
 class filemapper(object):
     '''Map and filter filenames when importing.
     A name can be mapped to itself, a new name, or None (omit from new
@@ -55,25 +59,31 b' class filemapper(object):'
 
     def parse(self, path):
         errs = 0
+
         def check(name, mapping, listname):
             if not name:
-                self.ui.warn(_('%s:%d: path to %s is missing\n') %
-                             (lex.infile, lex.lineno, listname))
+                self.ui.warn(
+                    _('%s:%d: path to %s is missing\n')
+                    % (lex.infile, lex.lineno, listname)
+                )
                 return 1
             if name in mapping:
-                self.ui.warn(_('%s:%d: %r already in %s list\n') %
-                             (lex.infile, lex.lineno, name, listname))
+                self.ui.warn(
+                    _('%s:%d: %r already in %s list\n')
+                    % (lex.infile, lex.lineno, name, listname)
+                )
                 return 1
-            if (name.startswith('/') or
-                name.endswith('/') or
-                '//' in name):
-                self.ui.warn(_('%s:%d: superfluous / in %s %r\n') %
-                             (lex.infile, lex.lineno, listname,
-                              pycompat.bytestr(name)))
+            if name.startswith('/') or name.endswith('/') or '//' in name:
+                self.ui.warn(
+                    _('%s:%d: superfluous / in %s %r\n')
+                    % (lex.infile, lex.lineno, listname, pycompat.bytestr(name))
+                )
                 return 1
             return 0
+
         lex = common.shlexer(
-            filepath=path, wordchars='!@#$%^&*()-=+[]{}|;:,./<>?')
+            filepath=path, wordchars='!@#$%^&*()-=+[]{}|;:,./<>?'
+        )
         cmd = lex.get_token()
         while cmd:
             if cmd == 'include':
@@ -93,8 +103,10 b' class filemapper(object):'
             elif cmd == 'source':
                 errs += self.parse(normalize(lex.get_token()))
             else:
-                self.ui.warn(_('%s:%d: unknown directive %r\n') %
-                             (lex.infile, lex.lineno, pycompat.bytestr(cmd)))
+                self.ui.warn(
+                    _('%s:%d: unknown directive %r\n')
+                    % (lex.infile, lex.lineno, pycompat.bytestr(cmd))
+                )
                 errs += 1
             cmd = lex.get_token()
         return errs
@@ -157,6 +169,7 b' class filemapper(object):'
     def active(self):
         return bool(self.include or self.exclude or self.rename)
 
+
 # This class does two additional things compared to a regular source:
 #
 # - Filter and rename files.  This is mostly wrapped by the filemapper
@@ -171,6 +184,7 b' class filemapper(object):'
 #   touch files we're interested in, but also merges that merge two
 #   or more interesting revisions.
 
+
 class filemap_source(common.converter_source):
     def __init__(self, ui, baseconverter, filemap):
         super(filemap_source, self).__init__(ui, baseconverter.repotype)
@@ -189,8 +203,9 b' class filemap_source(common.converter_so'
         self.children = {}
         self.seenchildren = {}
         # experimental config: convert.ignoreancestorcheck
-        self.ignoreancestorcheck = self.ui.configbool('convert',
-                                                      'ignoreancestorcheck')
+        self.ignoreancestorcheck = self.ui.configbool(
+            'convert', 'ignoreancestorcheck'
+        )
 
     def before(self):
         self.base.before()
@@ -348,8 +363,7 b' class filemap_source(common.converter_so'
             if p in self.wantedancestors:
                 wrev.update(self.wantedancestors[p])
             else:
-                self.ui.warn(_('warning: %s parent %s is missing\n') %
-                             (rev, p))
+                self.ui.warn(_('warning: %s parent %s is missing\n') % (rev, p))
         wrev.add(rev)
         self.wantedancestors[rev] = wrev
 
@@ -382,10 +396,13 b' class filemap_source(common.converter_so'
             if mp1 == SKIPREV or mp1 in knownparents:
                 continue
 
-            isancestor = (not self.ignoreancestorcheck and
-                          any(p2 for p2 in parents
-                              if p1 != p2 and mp1 != self.parentmap[p2]
-                                 and mp1 in self.wantedancestors[p2]))
+            isancestor = not self.ignoreancestorcheck and any(
+                p2
+                for p2 in parents
+                if p1 != p2
+                and mp1 != self.parentmap[p2]
+                and mp1 in self.wantedancestors[p2]
+            )
             if not isancestor and not hasbranchparent and len(parents) > 1:
                 # This could be expensive, avoid unnecessary calls.
                 if self._cachedcommit(p1).branch == branch:

hgext/convert/git.py

@@ -16,9 +16,8 b' from mercurial import ('
     pycompat,
 )
 
-from . import (
-    common,
-)
+from . import common
+
 
 class submodule(object):
     def __init__(self, path, node, url):
@@ -32,6 +31,7 b' class submodule(object):'
     def hgsubstate(self):
         return "%s %s" % (self.node, self.path)
 
+
 # Keys in extra fields that should not be copied if the user requests.
 bannedextrakeys = {
     # Git commit object built-ins.
@@ -44,6 +44,7 b' bannedextrakeys = {'
     'close',
 }
 
+
 class convert_git(common.converter_source, common.commandline):
     # Windows does not support GIT_DIR= construct while other systems
     # cannot remove environment variable. Just assume none have
@@ -78,8 +79,9 b' class convert_git(common.converter_sourc'
         if os.path.isdir(path + "/.git"):
             path += "/.git"
         if not os.path.exists(path + "/objects"):
-            raise common.NoRepo(_("%s does not look like a Git repository") %
-                                path)
+            raise common.NoRepo(
+                _("%s does not look like a Git repository") % path
+            )
 
         # The default value (50) is based on the default for 'git diff'.
         similarity = ui.configint('convert', 'git.similarity')
@@ -106,8 +108,10 b' class convert_git(common.converter_sourc'
         self.copyextrakeys = self.ui.configlist('convert', 'git.extrakeys')
         banned = set(self.copyextrakeys) & bannedextrakeys
         if banned:
-            raise error.Abort(_('copying of extra key is forbidden: %s') %
-                              _(', ').join(sorted(banned)))
+            raise error.Abort(
+                _('copying of extra key is forbidden: %s')
+                % _(', ').join(sorted(banned))
+            )
 
         committeractions = self.ui.configlist('convert', 'git.committeractions')
 
@@ -126,19 +130,31 b' class convert_git(common.converter_sourc'
                     messagealways = v or 'committer:'
 
         if messagedifferent and messagealways:
-            raise error.Abort(_('committeractions cannot define both '
-                                'messagedifferent and messagealways'))
+            raise error.Abort(
+                _(
+                    'committeractions cannot define both '
+                    'messagedifferent and messagealways'
+                )
+            )
 
         dropcommitter = 'dropcommitter' in committeractions
         replaceauthor = 'replaceauthor' in committeractions
 
         if dropcommitter and replaceauthor:
-            raise error.Abort(_('committeractions cannot define both '
-                                'dropcommitter and replaceauthor'))
+            raise error.Abort(
+                _(
+                    'committeractions cannot define both '
+                    'dropcommitter and replaceauthor'
+                )
+            )
 
         if dropcommitter and messagealways:
-            raise error.Abort(_('committeractions cannot define both '
-                                'dropcommitter and messagealways'))
+            raise error.Abort(
+                _(
+                    'committeractions cannot define both '
+                    'dropcommitter and messagealways'
+                )
+            )
 
         if not messagedifferent and not messagealways:
             messagedifferent = 'committer:'
@@ -176,13 +192,16 b' class convert_git(common.converter_sourc'
         self.catfilepipe[0].flush()
         info = self.catfilepipe[1].readline().split()
         if info[1] != ftype:
-            raise error.Abort(_('cannot read %r object at %s') % (
-                pycompat.bytestr(ftype), rev))
+            raise error.Abort(
+                _('cannot read %r object at %s')
+                % (pycompat.bytestr(ftype), rev)
+            )
         size = int(info[2])
         data = self.catfilepipe[1].read(size)
         if len(data) < size:
-            raise error.Abort(_('cannot read %r object at %s: unexpected size')
-                              % (ftype, rev))
+            raise error.Abort(
+                _('cannot read %r object at %s: unexpected size') % (ftype, rev)
+            )
         # read the trailing newline
         self.catfilepipe[1].read(1)
         return data
@@ -216,8 +235,10 b' class convert_git(common.converter_sourc'
         self.submodules = []
         c = config.config()
         # Each item in .gitmodules starts with whitespace that cant be parsed
-        c.parse('.gitmodules', '\n'.join(line.strip() for line in
-                               content.split('\n')))
+        c.parse(
+            '.gitmodules',
+            '\n'.join(line.strip() for line in content.split('\n')),
+        )
         for sec in c.sections():
             s = c[sec]
             if 'url' in s and 'path' in s:
@@ -228,15 +249,18 b' class convert_git(common.converter_sourc'
         if ret:
             # This can happen if a file is in the repo that has permissions
             # 160000, but there is no .gitmodules file.
-            self.ui.warn(_("warning: cannot read submodules config file in "
-                           "%s\n") % version)
+            self.ui.warn(
+                _("warning: cannot read submodules config file in " "%s\n")
+                % version
+            )
             return
 
         try:
             self.parsegitmodules(modules)
         except error.ParseError:
-            self.ui.warn(_("warning: unable to parse .gitmodules in %s\n")
-                         % version)
+            self.ui.warn(
+                _("warning: unable to parse .gitmodules in %s\n") % version
+            )
             return
 
         for m in self.submodules:
@@ -249,7 +273,9 b' class convert_git(common.converter_sourc'
         if full:
             raise error.Abort(_("convert from git does not support --full"))
         self.modecache = {}
-        cmd = ['diff-tree','-z', '--root', '-m', '-r'] + self.simopt + [version]
+        cmd = (
+            ['diff-tree', '-z', '--root', '-m', '-r'] + self.simopt + [version]
+        )
         output, status = self.gitrun(*cmd)
         if status:
             raise error.Abort(_('cannot read changes in %s') % version)
@@ -264,12 +290,13 b' class convert_git(common.converter_sourc'
         i = 0
 
         skipsubmodules = self.ui.configbool('convert', 'git.skipsubmodules')
+
         def add(entry, f, isdest):
             seen.add(f)
             h = entry[3]
-            p = (entry[1] == "100755")
-            s = (entry[1] == "120000")
-            renamesource = (not isdest and entry[4][0] == 'R')
+            p = entry[1] == "100755"
+            s = entry[1] == "120000"
+            renamesource = not isdest and entry[4][0] == 'R'
 
             if f == '.gitmodules':
                 if skipsubmodules:
@@ -377,18 +404,23 b' class convert_git(common.converter_sourc'
         date = tm + " " + (b"%d" % tz)
         saverev = self.ui.configbool('convert', 'git.saverev')
 
-        c = common.commit(parents=parents, date=date, author=author,
+        c = common.commit(
+            parents=parents,
+            date=date,
+            author=author,
                           desc=message,
                           rev=version,
                           extra=extra,
-                          saverev=saverev)
+            saverev=saverev,
+        )
         return c
 
     def numcommits(self):
         output, ret = self.gitrunlines('rev-list', '--all')
         if ret:
-            raise error.Abort(_('cannot retrieve number of commits in %s')
-                              % self.path)
+            raise error.Abort(
+                _('cannot retrieve number of commits in %s') % self.path
+            )
         return len(output)
 
     def gettags(self):
@@ -425,8 +457,9 b' class convert_git(common.converter_sourc'
     def getchangedfiles(self, version, i):
         changes = []
         if i is None:
-            output, status = self.gitrunlines('diff-tree', '--root', '-m',
-                                              '-r', version)
+            output, status = self.gitrunlines(
+                'diff-tree', '--root', '-m', '-r', version
+            )
             if status:
                 raise error.Abort(_('cannot read changes in %s') % version)
             for l in output:
@@ -435,9 +468,15 b' class convert_git(common.converter_sourc'
                 m, f = l[:-1].split("\t")
                 changes.append(f)
         else:
-            output, status = self.gitrunlines('diff-tree', '--name-only',
-                                              '--root', '-r', version,
-                                              '%s^%d' % (version, i + 1), '--')
+            output, status = self.gitrunlines(
+                'diff-tree',
+                '--name-only',
+                '--root',
+                '-r',
+                version,
+                '%s^%d' % (version, i + 1),
+                '--',
+            )
             if status:
                 raise error.Abort(_('cannot read changes in %s') % version)
             changes = [f.rstrip('\n') for f in output]
@@ -452,7 +491,7 b' class convert_git(common.converter_sourc'
         reftypes = [
             # (git prefix, hg prefix)
             ('refs/remotes/origin/', remoteprefix + '/'),
-            ('refs/heads/', '')
+            ('refs/heads/', ''),
         ]
 
         exclude = {

hgext/convert/gnuarch.py

@@ -26,8 +26,8 b' from mercurial.utils import ('
 )
 from . import common
 
+
 class gnuarch_source(common.converter_source, common.commandline):
-
     class gnuarch_rev(object):
         def __init__(self, rev):
             self.rev = rev
@@ -45,8 +45,9 b' class gnuarch_source(common.converter_so'
         super(gnuarch_source, self).__init__(ui, repotype, path, revs=revs)
 
         if not os.path.exists(os.path.join(path, '{arch}')):
-            raise common.NoRepo(_("%s does not look like a GNU Arch repository")
-                         % path)
+            raise common.NoRepo(
+                _("%s does not look like a GNU Arch repository") % path
+            )
 
         # Could use checktool, but we want to check for baz or tla.
         self.execmd = None
@@ -74,8 +75,9 b' class gnuarch_source(common.converter_so'
 
     def before(self):
         # Get registered archives
-        self.archives = [i.rstrip('\n')
-                         for i in self.runlines0('archives', '-n')]
+        self.archives = [
+            i.rstrip('\n') for i in self.runlines0('archives', '-n')
+        ]
 
         if self.execmd == 'tla':
             output = self.run0('tree-version', self.path)
@@ -85,8 +87,9 b' class gnuarch_source(common.converter_so'
 
         # Get name of temporary directory
         version = self.treeversion.split('/')
-        self.tmppath = os.path.join(pycompat.fsencode(tempfile.gettempdir()),
-                                    'hg-%s' % version[1])
+        self.tmppath = os.path.join(
+            pycompat.fsencode(tempfile.gettempdir()), 'hg-%s' % version[1]
+        )
 
         # Generate parents dictionary
         self.parents[None] = []
@@ -97,14 +100,20 b' class gnuarch_source(common.converter_so'
 
             archive = treeversion.split('/')[0]
             if archive not in self.archives:
-                self.ui.status(_('tree analysis stopped because it points to '
-                                 'an unregistered archive %s...\n') % archive)
+                self.ui.status(
+                    _(
+                        'tree analysis stopped because it points to '
+                        'an unregistered archive %s...\n'
+                    )
+                    % archive
+                )
                 break
 
             # Get the complete list of revisions for that tree version
             output, status = self.runlines('revisions', '-r', '-f', treeversion)
-            self.checkexit(status, 'failed retrieving revisions for %s'
-                           % treeversion)
+            self.checkexit(
+                status, 'failed retrieving revisions for %s' % treeversion
+            )
 
             # No new iteration unless a revision has a continuation-of header
             treeversion = None
@@ -132,7 +141,8 b' class gnuarch_source(common.converter_so'
                 # by the continuation-of header.
                 if self.changes[rev].continuationof:
                     treeversion = '--'.join(
-                        self.changes[rev].continuationof.split('--')[:-1])
+                        self.changes[rev].continuationof.split('--')[:-1]
+                    )
                     break
 
                 # If we reached a base-0 revision w/o any continuation-of
@@ -189,9 +199,13 b' class gnuarch_source(common.converter_so'
 
     def getcommit(self, rev):
         changes = self.changes[rev]
-        return common.commit(author=changes.author, date=changes.date,
-                             desc=changes.summary, parents=self.parents[rev],
-                             rev=rev)
+        return common.commit(
+            author=changes.author,
+            date=changes.date,
+            desc=changes.summary,
+            parents=self.parents[rev],
+            rev=rev,
+        )
 
     def gettags(self):
         return self.tags
@@ -207,8 +221,7 b' class gnuarch_source(common.converter_so'
 
     def _update(self, rev):
         self.ui.debug('applying revision %s...\n' % rev)
-        changeset, status = self.runlines('replay', '-d', self.tmppath,
-                                              rev)
+        changeset, status = self.runlines('replay', '-d', self.tmppath, rev)
         if status:
             # Something went wrong while merging (baz or tla
             # issue?), get latest revision and try from there
@@ -216,8 +229,9 b' class gnuarch_source(common.converter_so'
             self._obtainrevision(rev)
         else:
             old_rev = self.parents[rev][0]
-            self.ui.debug('computing changeset between %s and %s...\n'
-                          % (old_rev, rev))
+            self.ui.debug(
+                'computing changeset between %s and %s...\n' % (old_rev, rev)
+            )
             self._parsechangeset(changeset, rev)
 
     def _getfile(self, name, rev):
@@ -286,21 +300,23 b' class gnuarch_source(common.converter_so'
 
             # Commit date
             self.changes[rev].date = dateutil.datestr(
-                dateutil.strdate(catlog['Standard-date'],
-                             '%Y-%m-%d %H:%M:%S'))
+                dateutil.strdate(catlog['Standard-date'], '%Y-%m-%d %H:%M:%S')
+            )
 
             # Commit author
             self.changes[rev].author = self.recode(catlog['Creator'])
 
             # Commit description
-            self.changes[rev].summary = '\n\n'.join((catlog['Summary'],
-                                                    catlog.get_payload()))
+            self.changes[rev].summary = '\n\n'.join(
+                (catlog['Summary'], catlog.get_payload())
+            )
             self.changes[rev].summary = self.recode(self.changes[rev].summary)
 
             # Commit revision origin when dealing with a branch or tag
             if 'Continuation-of' in catlog:
                 self.changes[rev].continuationof = self.recode(
-                    catlog['Continuation-of'])
+                    catlog['Continuation-of']
+                )
         except Exception:
             raise error.Abort(_('could not parse cat-log of %s') % rev)
 

hgext/convert/hg.py

@@ -37,14 +37,17 b' from mercurial import ('
     util,
 )
 from mercurial.utils import dateutil
+
 stringio = util.stringio
 
 from . import common
+
 mapfile = common.mapfile
 NoRepo = common.NoRepo
 
 sha1re = re.compile(br'\b[0-9a-f]{12,40}\b')
 
+
 class mercurial_sink(common.converter_sink):
     def __init__(self, ui, repotype, path):
         common.converter_sink.__init__(self, ui, repotype, path)
@@ -56,8 +59,9 b' class mercurial_sink(common.converter_si'
             try:
                 self.repo = hg.repository(self.ui, path)
                 if not self.repo.local():
-                    raise NoRepo(_('%s is not a local Mercurial repository')
-                                 % path)
+                    raise NoRepo(
+                        _('%s is not a local Mercurial repository') % path
+                    )
             except error.RepoError as err:
                 ui.traceback()
                 raise NoRepo(err.args[0])
@@ -66,13 +70,15 b' class mercurial_sink(common.converter_si'
                 ui.status(_('initializing destination %s repository\n') % path)
                 self.repo = hg.repository(self.ui, path, create=True)
                 if not self.repo.local():
-                    raise NoRepo(_('%s is not a local Mercurial repository')
-                                 % path)
+                    raise NoRepo(
+                        _('%s is not a local Mercurial repository') % path
+                    )
                 self.created.append(path)
             except error.RepoError:
                 ui.traceback()
-                raise NoRepo(_("could not create hg repository %s as sink")
-                             % path)
+                raise NoRepo(
+                    _("could not create hg repository %s as sink") % path
+                )
         self.lock = None
         self.wlock = None
         self.filemapmode = False
@@ -100,7 +106,7 b' class mercurial_sink(common.converter_si'
         if not self.clonebranches:
             return
 
-        setbranch = (branch != self.lastbranch)
+        setbranch = branch != self.lastbranch
         self.lastbranch = branch
         if not branch:
             branch = 'default'
@@ -130,8 +136,9 b' class mercurial_sink(common.converter_si'
                 pbranchpath = os.path.join(self.path, pbranch)
                 prepo = hg.peer(self.ui, {}, pbranchpath)
                 self.ui.note(_('pulling from %s into %s\n') % (pbranch, branch))
-                exchange.pull(self.repo, prepo,
-                              [prepo.lookup(h) for h in heads])
+                exchange.pull(
+                    self.repo, prepo, [prepo.lookup(h) for h in heads]
+                )
             self.before()
 
     def _rewritetags(self, source, revmap, data):
@@ -166,8 +173,9 b' class mercurial_sink(common.converter_si'
             if revid != nodemod.nullhex:
                 revmap = self.subrevmaps.get(subpath)
                 if revmap is None:
-                    revmap = mapfile(self.ui,
-                                     self.repo.wjoin(subpath, '.hg/shamap'))
+                    revmap = mapfile(
+                        self.ui, self.repo.wjoin(subpath, '.hg/shamap')
+                    )
                     self.subrevmaps[subpath] = revmap
 
                     # It is reasonable that one or more of the subrepos don't
@@ -184,8 +192,10 b' class mercurial_sink(common.converter_si'
                 newid = revmap.get(revid)
                 if not newid:
                     if len(revmap) > 0:
-                        self.ui.warn(_("%s is missing from %s/.hg/shamap\n") %
-                                     (revid, subpath))
+                        self.ui.warn(
+                            _("%s is missing from %s/.hg/shamap\n")
+                            % (revid, subpath)
+                        )
                 else:
                     revid = newid
 
@@ -204,8 +214,15 b' class mercurial_sink(common.converter_si'
         anc = [p1ctx.ancestor(p2ctx)]
         # Calculate what files are coming from p2
         actions, diverge, rename = mergemod.calculateupdates(
-            self.repo, p1ctx, p2ctx, anc, branchmerge=True,
-            force=True, acceptremote=False, followcopies=False)
+            self.repo,
+            p1ctx,
+            p2ctx,
+            anc,
+            branchmerge=True,
+            force=True,
+            acceptremote=False,
+            followcopies=False,
+        )
 
         for file, (action, info, msg) in actions.iteritems():
             if source.targetfilebelongstosource(file):
@@ -216,10 +233,14 b' class mercurial_sink(common.converter_si'
             # If the file requires actual merging, abort. We don't have enough
             # context to resolve merges correctly.
             if action in ['m', 'dm', 'cd', 'dc']:
-                raise error.Abort(_("unable to convert merge commit "
+                raise error.Abort(
+                    _(
+                        "unable to convert merge commit "
                     "since target parents do not merge cleanly (file "
-                    "%s, parents %s and %s)") % (file, p1ctx,
-                                                 p2ctx))
+                        "%s, parents %s and %s)"
+                    )
+                    % (file, p1ctx, p2ctx)
+                )
             elif action == 'k':
                 # 'keep' means nothing changed from p1
                 continue
@@ -227,8 +248,9 b' class mercurial_sink(common.converter_si'
                 # Any other change means we want to take the p2 version
                 yield file
 
-    def putcommit(self, files, copies, parents, commit, source, revmap, full,
-                  cleanp2):
+    def putcommit(
+        self, files, copies, parents, commit, source, revmap, full, cleanp2
+    ):
         files = dict(files)
 
         def getfilectx(repo, memctx, f):
@@ -251,8 +273,15 b' class mercurial_sink(common.converter_si'
                 data = self._rewritetags(source, revmap, data)
             if f == '.hgsubstate':
                 data = self._rewritesubstate(source, data)
-            return context.memfilectx(self.repo, memctx, f, data, 'l' in mode,
-                                      'x' in mode, copies.get(f))
+            return context.memfilectx(
+                self.repo,
+                memctx,
+                f,
+                data,
+                'l' in mode,
+                'x' in mode,
+                copies.get(f),
+            )
 
         pl = []
         for p in parents:
@@ -285,8 +314,12 b' class mercurial_sink(common.converter_si'
         if sourcename:
             extra['convert_source'] = sourcename
 
-        for label in ('source', 'transplant_source', 'rebase_source',
-                      'intermediate-source'):
+        for label in (
+            'source',
+            'transplant_source',
+            'rebase_source',
+            'intermediate-source',
+        ):
             node = extra.get(label)
 
             if node is None:
@@ -326,13 +359,25 b' class mercurial_sink(common.converter_si'
                     p2files.add(file)
                     fileset.add(file)
 
-            ctx = context.memctx(self.repo, (p1, p2), text, fileset,
-                                 getfilectx, commit.author, commit.date, extra)
+            ctx = context.memctx(
+                self.repo,
+                (p1, p2),
+                text,
+                fileset,
+                getfilectx,
+                commit.author,
+                commit.date,
+                extra,
+            )
 
             # We won't know if the conversion changes the node until after the
             # commit, so copy the source's phase for now.
-            self.repo.ui.setconfig('phases', 'new-commit',
-                                   phases.phasenames[commit.phase], 'convert')
+            self.repo.ui.setconfig(
+                'phases',
+                'new-commit',
+                phases.phasenames[commit.phase],
+                'convert',
+            )
 
             with self.repo.transaction("convert") as tr:
                 if self.repo.ui.config('convert', 'hg.preserve-hash'):
@@ -347,8 +392,9 b' class mercurial_sink(common.converter_si'
                 if commit.rev != node:
                     ctx = self.repo[node]
                     if ctx.phase() < phases.draft:
-                        phases.registernew(self.repo, tr, phases.draft,
-                                           [ctx.node()])
+                        phases.registernew(
+                            self.repo, tr, phases.draft, [ctx.node()]
+                        )
 
             text = "(octopus merge fixup)\n"
             p2 = node
@@ -372,7 +418,8 b' class mercurial_sink(common.converter_si'
             for h in heads:
                 if '.hgtags' in self.repo[h]:
                     oldlines.update(
-                        set(self.repo[h]['.hgtags'].data().splitlines(True)))
+                        set(self.repo[h]['.hgtags'].data().splitlines(True))
+                    )
         oldlines = sorted(list(oldlines))
 
         newlines = sorted([("%s %s\n" % (tags[tag], tag)) for tag in tags])
@@ -398,15 +445,23 b' class mercurial_sink(common.converter_si'
             return None, None
 
         data = "".join(newlines)
+
         def getfilectx(repo, memctx, f):
             return context.memfilectx(repo, memctx, f, data, False, False, None)
 
         self.ui.status(_("updating tags\n"))
         date = "%d 0" % int(time.mktime(time.gmtime()))
         extra = {'branch': self.tagsbranch}
-        ctx = context.memctx(self.repo, (tagparent, None), "update tags",
-                             [".hgtags"], getfilectx, "convert-repo", date,
-                             extra)
+        ctx = context.memctx(
+            self.repo,
+            (tagparent, None),
+            "update tags",
+            [".hgtags"],
+            getfilectx,
+            "convert-repo",
+            date,
+            extra,
+        )
         node = self.repo.commitctx(ctx)
         return nodemod.hex(node), nodemod.hex(tagparent)
 
@@ -423,8 +478,10 b' class mercurial_sink(common.converter_si'
             tr = self.repo.transaction('bookmark')
             self.ui.status(_("updating bookmarks\n"))
             destmarks = self.repo._bookmarks
-            changes = [(bookmark, nodemod.bin(updatedbookmark[bookmark]))
-                       for bookmark in updatedbookmark]
+            changes = [
+                (bookmark, nodemod.bin(updatedbookmark[bookmark]))
+                for bookmark in updatedbookmark
+            ]
             destmarks.applychanges(self.repo, tr, changes)
             tr.close()
         finally:
@@ -436,11 +493,17 b' class mercurial_sink(common.converter_si'
 
     def hascommitforsplicemap(self, rev):
         if rev not in self.repo and self.clonebranches:
-            raise error.Abort(_('revision %s not found in destination '
+            raise error.Abort(
+                _(
+                    'revision %s not found in destination '
                                'repository (lookups with clonebranches=true '
-                               'are not implemented)') % rev)
+                    'are not implemented)'
+                )
+                % rev
+            )
         return rev in self.repo
 
+
 class mercurial_source(common.converter_source):
     def __init__(self, ui, repotype, path, revs=None):
         common.converter_source.__init__(self, ui, repotype, path, revs)
@@ -468,8 +531,9 b' class mercurial_source(common.converter_'
                 try:
                     startnode = self.repo.lookup(startnode)
                 except error.RepoError:
-                    raise error.Abort(_('%s is not a valid start revision')
-                                     % startnode)
+                    raise error.Abort(
+                        _('%s is not a valid start revision') % startnode
+                    )
                 startrev = self.repo.changelog.rev(startnode)
                 children = {startnode: 1}
                 for r in self.repo.changelog.descendants([startrev]):
@@ -483,8 +547,9 b' class mercurial_source(common.converter_'
                 self._heads = self.repo.heads()
         else:
             if revs or startnode is not None:
-                raise error.Abort(_('hg.revs cannot be combined with '
-                                   'hg.startrev or --rev'))
+                raise error.Abort(
+                    _('hg.revs cannot be combined with ' 'hg.startrev or --rev')
+                )
             nodes = set()
             parents = set()
             for r in scmutil.revrange(self.repo, [hgrevs]):
@@ -580,9 +645,9 b' class mercurial_source(common.converter_'
         optparents = [p.hex() for p in ctx.parents() if p and p not in _parents]
         crev = rev
 
-        return common.commit(author=ctx.user(),
-                             date=dateutil.datestr(ctx.date(),
-                                               '%Y-%m-%d %H:%M:%S %1%2'),
+        return common.commit(
+            author=ctx.user(),
+            date=dateutil.datestr(ctx.date(), '%Y-%m-%d %H:%M:%S %1%2'),
                              desc=ctx.description(),
                              rev=crev,
                              parents=parents,
@@ -592,17 +657,26 b' class mercurial_source(common.converter_'
                              sortkey=ctx.rev(),
                              saverev=self.saverev,
                              phase=ctx.phase(),
-                             ctx=ctx)
+            ctx=ctx,
+        )
 
     def numcommits(self):
         return len(self.repo)
 
     def gettags(self):
         # This will get written to .hgtags, filter non global tags out.
-        tags = [t for t in self.repo.tagslist()
-                if self.repo.tagtype(t[0]) == 'global']
-        return dict([(name, nodemod.hex(node)) for name, node in tags
-                     if self.keep(node)])
+        tags = [
+            t
+            for t in self.repo.tagslist()
+            if self.repo.tagtype(t[0]) == 'global'
+        ]
+        return dict(
+            [
+                (name, nodemod.hex(node))
+                for name, node in tags
+                if self.keep(node)
+            ]
+        )
 
     def getchangedfiles(self, rev, i):
         ctx = self._changectx(rev)

hgext/convert/monotone.py

@@ -19,12 +19,17 b' from mercurial.utils import dateutil'
 
 from . import common
 
+
 class monotone_source(common.converter_source, common.commandline):
     def __init__(self, ui, repotype, path=None, revs=None):
         common.converter_source.__init__(self, ui, repotype, path, revs)
         if revs and len(revs) > 1:
-            raise error.Abort(_('monotone source does not support specifying '
-                               'multiple revs'))
+            raise error.Abort(
+                _(
+                    'monotone source does not support specifying '
+                    'multiple revs'
+                )
+            )
         common.commandline.__init__(self, ui, 'mtn')
 
         self.ui = ui
@@ -32,8 +37,9 b' class monotone_source(common.converter_s'
         self.automatestdio = False
         self.revs = revs
 
-        norepo = common.NoRepo(_("%s does not look like a monotone repository")
-                             % path)
+        norepo = common.NoRepo(
+            _("%s does not look like a monotone repository") % path
+        )
         if not os.path.exists(os.path.join(path, '_MTN')):
             # Could be a monotone repository (SQLite db file)
             try:
@@ -53,22 +59,24 b' class monotone_source(common.converter_s'
         lines    = br'(?:.|\n)+'
 
         self.dir_re      = re.compile(space + "dir" + name)
-        self.file_re     = re.compile(space + "file" + name +
-                                      "content" + revision)
-        self.add_file_re = re.compile(space + "add_file" + name +
-                                      "content" + revision)
-        self.patch_re    = re.compile(space + "patch" + name +
-                                      "from" + revision + "to" + revision)
+        self.file_re = re.compile(space + "file" + name + "content" + revision)
+        self.add_file_re = re.compile(
+            space + "add_file" + name + "content" + revision
+        )
+        self.patch_re = re.compile(
+            space + "patch" + name + "from" + revision + "to" + revision
+        )
         self.rename_re   = re.compile(space + "rename" + name + "to" + name)
         self.delete_re   = re.compile(space + "delete" + name)
-        self.tag_re      = re.compile(space + "tag" + name + "revision" +
-                                      revision)
-        self.cert_re     = re.compile(lines + space + "name" + name +
-                                      "value" + value)
+        self.tag_re = re.compile(space + "tag" + name + "revision" + revision)
+        self.cert_re = re.compile(
+            lines + space + "name" + name + "value" + value
+        )
 
         attr = space + "file" + lines + space + "attr" + space
-        self.attr_execute_re = re.compile(attr  + '"mtn:execute"' +
-                                          space + '"true"')
+        self.attr_execute_re = re.compile(
+            attr + '"mtn:execute"' + space + '"true"'
+        )
 
         # cached data
         self.manifest_rev = None
@@ -140,13 +148,19 b' class monotone_source(common.converter_s'
         try:
             length = pycompat.long(lengthstr[:-1])
         except TypeError:
-            raise error.Abort(_('bad mtn packet - bad packet size %s')
-                % lengthstr)
+            raise error.Abort(
+                _('bad mtn packet - bad packet size %s') % lengthstr
+            )
 
         read = self.mtnreadfp.read(length)
         if len(read) != length:
-            raise error.Abort(_("bad mtn packet - unable to read full packet "
-                "read %s of %s") % (len(read), length))
+            raise error.Abort(
+                _(
+                    "bad mtn packet - unable to read full packet "
+                    "read %s of %s"
+                )
+                % (len(read), length)
+            )
 
         return (commandnbr, stream, length, read)
 
@@ -154,14 +168,16 b' class monotone_source(common.converter_s'
         retval = []
         while True:
             commandnbr, stream, length, output = self.mtnstdioreadpacket()
-            self.ui.debug('mtn: read packet %s:%s:%d\n' %
-                (commandnbr, stream, length))
+            self.ui.debug(
+                'mtn: read packet %s:%s:%d\n' % (commandnbr, stream, length)
+            )
 
             if stream == 'l':
                 # End of command
                 if output != '0':
-                    raise error.Abort(_("mtn command '%s' returned %s") %
-                        (command, output))
+                    raise error.Abort(
+                        _("mtn command '%s' returned %s") % (command, output)
+                    )
                 break
             elif stream in 'ew':
                 # Error, warning output
@@ -207,8 +223,12 b' class monotone_source(common.converter_s'
         return name in self.dirs
 
     def mtngetcerts(self, rev):
-        certs = {"author":"<missing>", "date":"<missing>",
-            "changelog":"<missing>", "branch":"<missing>"}
+        certs = {
+            "author": "<missing>",
+            "date": "<missing>",
+            "changelog": "<missing>",
+            "branch": "<missing>",
+        }
         certlist = self.mtnrun("certs", rev)
         # mtn < 0.45:
         #   key "[e-mail]"
@@ -237,8 +257,9 b' class monotone_source(common.converter_s'
 
     def getchanges(self, rev, full):
         if full:
-            raise error.Abort(_("convert from monotone does not support "
-                              "--full"))
+            raise error.Abort(
+                _("convert from monotone does not support " "--full")
+            )
         revision = self.mtnrun("get_revision", rev).split("\n\n")
         files = {}
         ignoremove = {}
@@ -286,7 +307,9 b' class monotone_source(common.converter_s'
             for tofile, fromfile in renamed.items():
                 self.ui.debug(
                     "copying file in renamed directory from '%s' to '%s'"
-                    % (fromfile, tofile), '\n')
+                    % (fromfile, tofile),
+                    '\n',
+                )
                 files[tofile] = rev
                 copies[tofile] = fromfile
             for fromfile in renamed.values():
@@ -318,7 +341,8 b' class monotone_source(common.converter_s'
             rev=rev,
             parents=self.mtnrun("parents", rev).splitlines(),
             branch=certs["branch"],
-            extra=extra)
+            extra=extra,
+        )
 
     def gettags(self):
         tags = {}
@@ -339,30 +363,40 b' class monotone_source(common.converter_s'
             versionstr = self.mtnrunsingle("interface_version")
             version = float(versionstr)
         except Exception:
-            raise error.Abort(_("unable to determine mtn automate interface "
-                "version"))
+            raise error.Abort(
+                _("unable to determine mtn automate interface " "version")
+            )
 
         if version >= 12.0:
             self.automatestdio = True
-            self.ui.debug("mtn automate version %f - using automate stdio\n" %
-                version)
+            self.ui.debug(
+                "mtn automate version %f - using automate stdio\n" % version
+            )
 
             # launch the long-running automate stdio process
-            self.mtnwritefp, self.mtnreadfp = self._run2('automate', 'stdio',
-                '-d', self.path)
+            self.mtnwritefp, self.mtnreadfp = self._run2(
+                'automate', 'stdio', '-d', self.path
+            )
             # read the headers
             read = self.mtnreadfp.readline()
             if read != 'format-version: 2\n':
-                raise error.Abort(_('mtn automate stdio header unexpected: %s')
-                    % read)
+                raise error.Abort(
+                    _('mtn automate stdio header unexpected: %s') % read
+                )
             while read != '\n':
                 read = self.mtnreadfp.readline()
                 if not read:
-                    raise error.Abort(_("failed to reach end of mtn automate "
-                        "stdio headers"))
+                    raise error.Abort(
+                        _(
+                            "failed to reach end of mtn automate "
+                            "stdio headers"
+                        )
+                    )
         else:
-            self.ui.debug("mtn automate version %s - not using automate stdio "
-                "(automate >= 12.0 - mtn >= 0.46 is needed)\n" % version)
+            self.ui.debug(
+                "mtn automate version %s - not using automate stdio "
+                "(automate >= 12.0 - mtn >= 0.46 is needed)\n" % version
+            )
 
     def after(self):
         if self.automatestdio:

hgext/convert/p4.py

@@ -22,6 +22,7 b' from mercurial.utils import ('
 
 from . import common
 
+
 def loaditer(f):
     "Yield the dictionary objects generated by p4"
     try:
@@ -33,6 +34,7 b' def loaditer(f):'
     except EOFError:
         pass
 
+
 def decodefilename(filename):
     """Perforce escapes special characters @, #, *, or %
     with %40, %23, %2A, or %25 respectively
@@ -47,6 +49,7 b' def decodefilename(filename):'
         filename = filename.replace(k, v)
     return filename
 
+
 class p4_source(common.converter_source):
     def __init__(self, ui, repotype, path, revs=None):
         # avoid import cycle
@@ -55,25 +58,30 b' class p4_source(common.converter_source)'
         super(p4_source, self).__init__(ui, repotype, path, revs=revs)
 
         if "/" in path and not path.startswith('//'):
-            raise common.NoRepo(_('%s does not look like a P4 repository') %
-                                path)
+            raise common.NoRepo(
+                _('%s does not look like a P4 repository') % path
+            )
 
         common.checktool('p4', abort=False)
 
         self.revmap = {}
-        self.encoding = self.ui.config('convert', 'p4.encoding',
-                                       convcmd.orig_encoding)
+        self.encoding = self.ui.config(
+            'convert', 'p4.encoding', convcmd.orig_encoding
+        )
         self.re_type = re.compile(
             br"([a-z]+)?(text|binary|symlink|apple|resource|unicode|utf\d+)"
-            br"(\+\w+)?$")
+            br"(\+\w+)?$"
+        )
         self.re_keywords = re.compile(
             br"\$(Id|Header|Date|DateTime|Change|File|Revision|Author)"
-            br":[^$\n]*\$")
+            br":[^$\n]*\$"
+        )
         self.re_keywords_old = re.compile(br"\$(Id|Header):[^$\n]*\$")
 
         if revs and len(revs) > 1:
-            raise error.Abort(_("p4 source does not support specifying "
-                               "multiple revisions"))
+            raise error.Abort(
+                _("p4 source does not support specifying " "multiple revisions")
+            )
 
     def setrevmap(self, revmap):
         """Sets the parsed revmap dictionary.
@@ -189,7 +197,7 b' class p4_source(common.converter_source)'
                 if filename:
                     files.append((filename, d["rev%d" % i]))
                     depotname[filename] = oldname
-                    if (d.get("action%d" % i) == "move/add"):
+                    if d.get("action%d" % i) == "move/add":
                         copiedfiles.append(filename)
                     localname[oldname] = filename
                 i += 1
@@ -198,8 +206,7 b' class p4_source(common.converter_source)'
             for filename in copiedfiles:
                 oldname = depotname[filename]
 
-                flcmd = ('p4 -G filelog %s'
-                         % procutil.shellquote(oldname))
+                flcmd = 'p4 -G filelog %s' % procutil.shellquote(oldname)
                 flstdout = procutil.popen(flcmd, mode='rb')
 
                 copiedfilename = None
@@ -208,8 +215,10 b' class p4_source(common.converter_source)'
 
                     i = 0
                     while ("change%d" % i) in d:
-                        if (d["change%d" % i] == change and
-                            d["action%d" % i] == "move/add"):
+                        if (
+                            d["change%d" % i] == change
+                            and d["action%d" % i] == "move/add"
+                        ):
                             j = 0
                             while ("file%d,%d" % (i, j)) in d:
                                 if d["how%d,%d" % (i, j)] == "moved from":
@@ -225,8 +234,10 b' class p4_source(common.converter_source)'
                 if copiedfilename:
                     copies[filename] = copiedfilename
                 else:
-                    ui.warn(_("cannot find source for copied file: %s@%s\n")
-                            % (filename, change))
+                    ui.warn(
+                        _("cannot find source for copied file: %s@%s\n")
+                        % (filename, change)
+                    )
 
             changeset[change] = c
             files_map[change] = files
@@ -272,8 +283,9 b' class p4_source(common.converter_source)'
         return self.heads
 
     def getfile(self, name, rev):
-        cmd = ('p4 -G print %s'
-               % procutil.shellquote("%s#%s" % (self.depotname[name], rev)))
+        cmd = 'p4 -G print %s' % procutil.shellquote(
+            "%s#%s" % (self.depotname[name], rev)
+        )
 
         lasterror = None
         while True:
@@ -304,8 +316,9 b' class p4_source(common.converter_source)'
                     p4type = self.re_type.match(d["type"])
                     if p4type:
                         mode = ""
-                        flags = ((p4type.group(1) or "")
-                               + (p4type.group(3) or ""))
+                        flags = (p4type.group(1) or "") + (
+                            p4type.group(3) or ""
+                        )
                         if "x" in flags:
                             mode = "x"
                         if p4type.group(2) == "symlink":
@@ -350,10 +363,15 b' class p4_source(common.converter_source)'
         if parents is None:
             parents = []
 
-        return common.commit(author=self.recode(obj["user"]),
+        return common.commit(
+            author=self.recode(obj["user"]),
             date=dateutil.datestr(date, '%Y-%m-%d %H:%M:%S %1%2'),
-            parents=parents, desc=desc, branch=None, rev=obj['change'],
-            extra={"p4": obj['change'], "convert_revision": obj['change']})
+            parents=parents,
+            desc=desc,
+            branch=None,
+            rev=obj['change'],
+            extra={"p4": obj['change'], "convert_revision": obj['change']},
+        )
 
     def _fetch_revision(self, rev):
         """Return an output of `p4 describe` including author, commit date as
@@ -369,7 +387,8 b' class p4_source(common.converter_source)'
             d = self._fetch_revision(rev)
             return self._construct_commit(d, parents=None)
         raise error.Abort(
-            _("cannot find %s in the revmap or parsed changesets") % rev)
+            _("cannot find %s in the revmap or parsed changesets") % rev
+        )
 
     def gettags(self):
         return {}