Merge lp:~jelmer/brz/ruff-format into lp:brz

[Jelmer Vernooij]

Drop flake8, use ruff for formatting

Drop flake8, use ruff for formatting

[Jelmer Vernooij (jelmer)]

review: Approve

[The Breezy Bot (the-breezy-bot)]

The attempt to merge lp:~jelmer/brz/ruff-format into lp:brz failed. Command exited with 2.
Below is the output from the failed tests.

Collecting setuptools-gettext
  Using cached setuptools_gettext-0.1.7-py3-none-any.whl.metadata (1.5 kB)
Requirement already satisfied: setuptools>=46.1 in ./lib/python3.11/site-packages (from setuptools-gettext) (68.1.2)
Using cached setuptools_gettext-0.1.7-py3-none-any.whl (5.5 kB)
Installing collected packages: setuptools-gettext
Successfully installed setuptools-gettext-0.1.7
Obtaining file:///tmp/tarmac/branch.yd5f78qt
  Installing build dependencies: started
  Installing build dependencies: finished with status 'done'
  Checking if build backend supports build_editable: started
  Checking if build backend supports build_editable: finished with status 'done'
  Getting requirements to build editable: started
  Getting requirements to build editable: finished with status 'done'
  Installing backend dependencies: started
  Installing backend dependencies: finished with status 'done'
  Preparing editable metadata (pyproject.toml): started
  Preparing editable metadata (pyproject.toml): finished with status 'done'
Requirement already satisfied: configobj in /usr/lib/python3/dist-packages (5.0.8)
Requirement already satisfied: fastbencode in /usr/lib/python3/dist-packages (0.2)
Requirement already satisfied: patiencediff in /usr/lib/python3/dist-packages (0.2.13)
Requirement already satisfied: merge3 in /usr/lib/python3/dist-packages (0.0.8)
Requirement already satisfied: dulwich>=0.21.6 in /usr/lib/python3/dist-packages (0.21.6)
Requirement already satisfied: urllib3>=1.24.1 in /usr/lib/python3/dist-packages (1.26.18)
Requirement already satisfied: pyyaml in /usr/lib/python3/dist-packages (6.0.1)
Collecting testtools>=0.9.5
  Using cached testtools-2.7.1-py3-none-any.whl.metadata (5.3 kB)
Collecting testscenarios
  Using cached testscenarios-0.5.0-py2.py3-none-any.whl (21 kB)
Collecting python-subunit
  Using cached python_subunit-1.4.3-py3-none-any.whl.metadata (22 kB)
Collecting cython>=0.29
  Using cached Cython-3.0.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (3.2 kB)
Collecting ruff
  Using cached ruff-0.1.4-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (22 kB)
Collecting docutils
  Using cached docutils-0.20.1-py3-none-any.whl.metadata (2.8 kB)
Requirement already satisfied: setuptools in ./lib/python3.11/site-packages (68.1.2)
Collecting sphinx
  Using cached sphinx-7.2.6-py3-none-any.whl.metadata (5.9 kB)
Collecting sphinx-epytext
  Using cached sphinx_epytext-0.0.4-py3-none-any.whl
Collecting fastimport
  Using cached fastimport-0.9.14-py2.py3-none-any.whl
Requirement already satisfied: launchpadlib>=1.6.3 in /usr/lib/python3/dist-packages (1.11.0)
Requirement already satisfied: paramiko>=1.6.2 in /usr/local/lib/python3.11/dist-packages (3.3.1)
Requirement already satisfied: gpg in /usr/lib/python3/dist-packages (1.18.0)
Requirement already satisfied: httplib2 in /usr/lib/python3/dist-packages (from launchpadlib>=1.6.3) (0.20.4)
Requirement already satisfied: lazr.restfulclient>=0.14.2 in /usr/lib/python3/dist-packages (from launchpadlib>=1.6.3) (0.14.5)
Re...

[The Breezy Bot (the-breezy-bot)]

The attempt to merge lp:~jelmer/brz/ruff-format into lp:brz failed. Command exited with 1.
Below is the output from the failed tests.

Collecting setuptools-gettext
  Downloading setuptools_gettext-0.1.7-py3-none-any.whl.metadata (1.5 kB)
Requirement already satisfied: setuptools>=46.1 in ./lib/python3.11/site-packages (from setuptools-gettext) (68.1.2)
Downloading setuptools_gettext-0.1.7-py3-none-any.whl (5.5 kB)
Installing collected packages: setuptools-gettext
Successfully installed setuptools-gettext-0.1.7
Obtaining file:///tmp/tarmac/branch.6aetwkax
  Installing build dependencies: started
  Installing build dependencies: finished with status 'done'
  Checking if build backend supports build_editable: started
  Checking if build backend supports build_editable: finished with status 'done'
  Getting requirements to build editable: started
  Getting requirements to build editable: finished with status 'done'
  Installing backend dependencies: started
  Installing backend dependencies: finished with status 'done'
  Preparing editable metadata (pyproject.toml): started
  Preparing editable metadata (pyproject.toml): finished with status 'done'
Requirement already satisfied: configobj in /usr/lib/python3/dist-packages (5.0.8)
Requirement already satisfied: fastbencode in /usr/lib/python3/dist-packages (0.2)
Requirement already satisfied: patiencediff in /usr/lib/python3/dist-packages (0.2.13)
Requirement already satisfied: merge3 in /usr/lib/python3/dist-packages (0.0.8)
Requirement already satisfied: dulwich>=0.21.6 in /usr/lib/python3/dist-packages (0.21.6)
Requirement already satisfied: urllib3>=1.24.1 in /usr/lib/python3/dist-packages (1.26.18)
Requirement already satisfied: pyyaml in /usr/lib/python3/dist-packages (6.0.1)
Collecting testtools>=0.9.5
  Downloading testtools-2.7.1-py3-none-any.whl.metadata (5.3 kB)
Collecting testscenarios
  Downloading testscenarios-0.5.0-py2.py3-none-any.whl (21 kB)
Collecting python-subunit
  Downloading python_subunit-1.4.3-py3-none-any.whl.metadata (22 kB)
Collecting cython>=0.29
  Using cached Cython-3.0.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (3.2 kB)
Collecting ruff
  Downloading ruff-0.1.4-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (22 kB)
Collecting docutils
  Downloading docutils-0.20.1-py3-none-any.whl.metadata (2.8 kB)
Requirement already satisfied: setuptools in ./lib/python3.11/site-packages (68.1.2)
Collecting sphinx
  Downloading sphinx-7.2.6-py3-none-any.whl.metadata (5.9 kB)
Collecting sphinx-epytext
  Downloading sphinx-epytext-0.0.4.tar.gz (3.6 kB)
  Preparing metadata (setup.py): started
  Preparing metadata (setup.py): finished with status 'done'
Collecting fastimport
  Downloading fastimport-0.9.14.tar.gz (41 kB)
     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 41.8/41.8 kB 2.1 MB/s eta 0:00:00
  Preparing metadata (setup.py): started
  Preparing metadata (setup.py): finished with status 'done'
Requirement already satisfied: launchpadlib>=1.6.3 in /usr/lib/python3/dist-packages (1.11.0)
Requirement already satisfied: paramiko>=1.6.2 in /usr/local/lib/python3.11/dist-packages (3.3.1)
Requirement already satisfied: gpg in /usr/lib/pyth...

[The Breezy Bot (the-breezy-bot)]

The attempt to merge lp:~jelmer/brz/ruff-format into lp:brz failed. Command exited with 2.
Below is the output from the failed tests.

Collecting setuptools-gettext
  Downloading setuptools_gettext-0.1.7-py3-none-any.whl.metadata (1.5 kB)
Requirement already satisfied: setuptools>=46.1 in ./lib/python3.11/site-packages (from setuptools-gettext) (68.1.2)
Downloading setuptools_gettext-0.1.7-py3-none-any.whl (5.5 kB)
Installing collected packages: setuptools-gettext
Successfully installed setuptools-gettext-0.1.7
Obtaining file:///tmp/tarmac/branch.5dxco0m3
  Installing build dependencies: started
  Installing build dependencies: finished with status 'done'
  Checking if build backend supports build_editable: started
  Checking if build backend supports build_editable: finished with status 'done'
  Getting requirements to build editable: started
  Getting requirements to build editable: finished with status 'done'
  Installing backend dependencies: started
  Installing backend dependencies: finished with status 'done'
  Preparing editable metadata (pyproject.toml): started
  Preparing editable metadata (pyproject.toml): finished with status 'done'
Requirement already satisfied: configobj in /usr/lib/python3/dist-packages (5.0.8)
Requirement already satisfied: fastbencode in /usr/lib/python3/dist-packages (0.2)
Requirement already satisfied: patiencediff in /usr/lib/python3/dist-packages (0.2.13)
Requirement already satisfied: merge3 in /usr/lib/python3/dist-packages (0.0.8)
Requirement already satisfied: dulwich>=0.21.6 in /usr/lib/python3/dist-packages (0.21.6)
Requirement already satisfied: urllib3>=1.24.1 in /usr/lib/python3/dist-packages (1.26.18)
Requirement already satisfied: pyyaml in /usr/lib/python3/dist-packages (6.0.1)
Collecting testtools>=0.9.5
  Downloading testtools-2.7.1-py3-none-any.whl.metadata (5.3 kB)
Collecting testscenarios
  Downloading testscenarios-0.5.0-py2.py3-none-any.whl (21 kB)
Collecting python-subunit
  Downloading python_subunit-1.4.3-py3-none-any.whl.metadata (22 kB)
Collecting cython>=0.29
  Using cached Cython-3.0.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (3.2 kB)
Collecting ruff
  Downloading ruff-0.1.4-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (22 kB)
Collecting docutils
  Downloading docutils-0.20.1-py3-none-any.whl.metadata (2.8 kB)
Requirement already satisfied: setuptools in ./lib/python3.11/site-packages (68.1.2)
Collecting sphinx
  Downloading sphinx-7.2.6-py3-none-any.whl.metadata (5.9 kB)
Collecting sphinx-epytext
  Downloading sphinx-epytext-0.0.4.tar.gz (3.6 kB)
  Preparing metadata (setup.py): started
  Preparing metadata (setup.py): finished with status 'done'
Collecting fastimport
  Downloading fastimport-0.9.14.tar.gz (41 kB)
     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 41.8/41.8 kB 2.2 MB/s eta 0:00:00
  Preparing metadata (setup.py): started
  Preparing metadata (setup.py): finished with status 'done'
Requirement already satisfied: launchpadlib>=1.6.3 in /usr/lib/python3/dist-packages (1.11.0)
Requirement already satisfied: paramiko>=1.6.2 in /usr/local/lib/python3.11/dist-packages (3.3.1)
Requirement already satisfied: gpg in /usr/lib/pyth...

[lp:~jelmer/brz/ruff-format]

7889. By Jelmer Vernooij on 2023-11-07

Drop flake8, use ruff for formatting

by jelmer review by jelmer

=== removed file '.flake8'
--- .flake8	2023-03-08 22:44:15 +0000
+++ .flake8	1970-01-01 00:00:00 +0000
@@ -1,44 +0,0 @@
-[flake8]
-# Ignore E402 ("module level import not at top of file"),
-# because even with the lazy import plugin it still triggers
-# for lazy_import statements before other imports.
-exclude = .git,__pycache__,build,dist,target,.eggs,lib
-ignore =
-   D
-   I
-   E12
-   E261
-   E265
-   E266
-   E301
-   E302
-   E303
-   E305
-   E306
-   E401
-   E402
-   E501
-   E502
-   E702
-   E704
-   E722
-   E731
-   E741
-   F401
-   F402
-   F403
-   F405
-   F811
-   F812
-   F821
-   F841
-   W391
-   W503
-   W504
-   W605
-filename = *.py
-
-[flake8:local-plugins]
-extension =
-	MC1 = flake8_lazy_import:LazyImport
-paths = ./tools/

=== modified file 'Makefile'
--- Makefile	2023-09-29 18:07:58 +0000
+++ Makefile	2023-11-07 18:55:36 +0000
@@ -32,7 +32,7 @@
 sw = $(sort $(wildcard $(1)))
 
 
-.PHONY: all clean realclean extensions flake8 api-docs check-nodocs check clippy clippy-fix ruff ruff-fix
+.PHONY: all clean realclean extensions api-docs check-nodocs check clippy clippy-fix
 
 all: extensions
 
@@ -40,7 +40,7 @@
 	@echo "building extension modules."
 	$(PYTHON) setup.py build_ext -i $(PYTHON_BUILDFLAGS)
 
-check: docs check-nodocs
+check:: docs check-nodocs
 
 check-nodocs: brz
 	-$(RM) -f selftest.log
@@ -67,20 +67,16 @@
 brz:
 	$(PYTHON) setup.py build_rust -i $(PYTHON_BUILDFLAGS)
 
-# Run Python style checker (apt-get install flake8)
-#
-# Note that at present this gives many false warnings, because it doesn't
-# know about identifiers loaded through lazy_import.
-flake8:
-	$(PYTHON) -m flake8 breezy
-
-fmt-check:
-	find crates breezy -name '*.rs' | xargs rustfmt --check
-	flake8 breezy
+check:: mypy
 
 mypy:
 	$(PYTHON) -m mypy breezy
 
+check:: cargo-check
+
+cargo-check:
+	cargo check --all
+
 clean:
 	$(PYTHON) setup.py clean
 	-find . -name "*.pyc" -o -name "*.pyo" -o -name "*.so" | xargs rm -f
@@ -320,8 +316,8 @@
 	rm -rf $$tmpdir
 
 reformat:
-	isort .
-	find breezy crates  -name '*.rs' | xargs rustfmt
+	cargo fmt --all
+	ruff format .
 
 clippy-fix:
 	cargo clippy --fix --all --allow-no-vcs
@@ -329,15 +325,31 @@
 clippy:
 	cargo clippy --all
 
+.PHONY: ruff
+
+check:: ruff
+
 ruff:
 	ruff check .
 
+.PHONY: ruff-fix
+
 ruff-fix:
 	ruff check --fix .
 
-fix: clippy ruff-fix
+fix:: clippy-fix ruff-fix
 	$(MAKE) reformat
 
+fmt-check:: rust-fmt-check
+
+rust-fmt-check:
+	cargo fmt --all --check
+
+fmt-check:: ruff-fmt-check
+
+ruff-fmt-check:
+	$(MAKE) ruff --check
+
 .testrepository:
 	testr init
 

=== modified file 'apport/source_brz.py'
--- apport/source_brz.py	2023-06-24 13:01:43 +0000
+++ apport/source_brz.py	2023-11-07 18:55:36 +0000
@@ -8,12 +8,13 @@
 
 from apport.hookutils import *  # noqa: F403
 
-brz_log = os.path.expanduser('~/.brz.log')
-dot_brz = os.path.expanduser('~/.config/breezy')
+brz_log = os.path.expanduser("~/.brz.log")
+dot_brz = os.path.expanduser("~/.config/breezy")
+
 
 def _add_log_tail(report):
     # may have already been added in-process
-    if 'BrzLogTail' in report:
+    if "BrzLogTail" in report:
         return
 
     with open(brz_log) as f:
@@ -23,33 +24,33 @@
     brz_log_tail = []
     blanks = 0
     for line in brz_log_lines:
-        if line == '\n':
+        if line == "\n":
             blanks += 1
         brz_log_tail.append(line)
         if blanks >= 2:
             break
 
     brz_log_tail.reverse()
-    report['BrzLogTail'] = ''.join(brz_log_tail)
+    report["BrzLogTail"] = "".join(brz_log_tail)
 
 
 def add_info(report):
     _add_log_tail(report)
-    if 'BrzPlugins' not in report:
+    if "BrzPlugins" not in report:
         # may already be present in-process
-        report['BrzPlugins'] = command_output(['brz', 'plugins', '-v'])
+        report["BrzPlugins"] = command_output(["brz", "plugins", "-v"])
 
     # by default assume brz crashes are upstream bugs; this relies on
     # having a brz entry under /etc/apport/crashdb.conf.d/
-    report['CrashDB'] = 'brz'
+    report["CrashDB"] = "brz"
 
     # these may contain some sensitive info (smtp_passwords)
     # TODO: strip that out and attach the rest
 
-    #attach_file_if_exists(report,
-    #	os.path.join(dot_brz, 'breezy.conf', 'BrzConfig')
-    #attach_file_if_exists(report,
-    #	os.path.join(dot_brz, 'locations.conf', 'BrzLocations')
+    # attach_file_if_exists(report,
+    # os.path.join(dot_brz, 'breezy.conf', 'BrzConfig')
+    # attach_file_if_exists(report,
+    # os.path.join(dot_brz, 'locations.conf', 'BrzLocations')
 
 
 # vim: expandtab shiftwidth=4

=== modified file 'breezy/__init__.py'
--- breezy/__init__.py	2023-09-27 23:19:21 +0000
+++ breezy/__init__.py	2023-11-07 18:55:36 +0000
@@ -39,8 +39,7 @@
 import sys
 
 __copyright__ = (
-    "Copyright 2005-2012 Canonical Ltd.\n"
-    "Copyright 2017-2023 Breezy developers"
+    "Copyright 2005-2012 Canonical Ltd.\n" "Copyright 2017-2023 Breezy developers"
 )
 
 # same format as sys.version_info: "A tuple containing the five components of
@@ -50,7 +49,7 @@
 # Python version 2.0 is (2, 0, 0, 'final', 0)."  Additionally we use a
 # releaselevel of 'dev' for unreleased under-development code.
 
-version_info = (3, 4, 0, 'dev', 0)
+version_info = (3, 4, 0, "dev", 0)
 
 
 def _format_version_tuple(version_info):
@@ -82,38 +81,38 @@
     1.4.0.wibble.0
     """
     if len(version_info) == 2:
-        main_version = '%d.%d' % version_info[:2]
+        main_version = "%d.%d" % version_info[:2]
     else:
-        main_version = '%d.%d.%d' % version_info[:3]
+        main_version = "%d.%d.%d" % version_info[:3]
     if len(version_info) <= 3:
         return main_version
 
     release_type = version_info[3]
     sub = version_info[4]
 
-    if release_type == 'final' and sub == 0:
-        sub_string = ''
-    elif release_type == 'final':
-        sub_string = '.' + str(sub)
-    elif release_type == 'dev' and sub == 0:
-        sub_string = '.dev'
-    elif release_type == 'dev':
-        sub_string = '.dev' + str(sub)
-    elif release_type in ('alpha', 'beta'):
+    if release_type == "final" and sub == 0:
+        sub_string = ""
+    elif release_type == "final":
+        sub_string = "." + str(sub)
+    elif release_type == "dev" and sub == 0:
+        sub_string = ".dev"
+    elif release_type == "dev":
+        sub_string = ".dev" + str(sub)
+    elif release_type in ("alpha", "beta"):
         if version_info[2] == 0:
-            main_version = '%d.%d' % version_info[:2]
-        sub_string = '.' + release_type[0] + str(sub)
-    elif release_type == 'candidate':
-        sub_string = '.rc' + str(sub)
+            main_version = "%d.%d" % version_info[:2]
+        sub_string = "." + release_type[0] + str(sub)
+    elif release_type == "candidate":
+        sub_string = ".rc" + str(sub)
     else:
-        return '.'.join(map(str, version_info))
+        return ".".join(map(str, version_info))
 
     return main_version + sub_string
 
 
 __version__ = _format_version_tuple(version_info)
 version_string = __version__
-_core_version_string = '.'.join(map(str, version_info[:3]))
+_core_version_string = ".".join(map(str, version_info[:3]))
 
 
 def _patch_filesystem_default_encoding(new_enc):
@@ -129,15 +128,14 @@
     """
     try:
         import ctypes
-        pythonapi = getattr(ctypes, 'pythonapi', None)
+
+        pythonapi = getattr(ctypes, "pythonapi", None)
         if pythonapi is not None:
-            old_ptr = ctypes.c_void_p.in_dll(pythonapi,
-                                             "Py_FileSystemDefaultEncoding")
-            has_enc = ctypes.c_int.in_dll(pythonapi,
-                                          "Py_HasFileSystemDefaultEncoding")
+            old_ptr = ctypes.c_void_p.in_dll(pythonapi, "Py_FileSystemDefaultEncoding")
+            has_enc = ctypes.c_int.in_dll(pythonapi, "Py_HasFileSystemDefaultEncoding")
             as_utf8 = ctypes.PYFUNCTYPE(
-                ctypes.POINTER(ctypes.c_char), ctypes.py_object)(
-                    ("PyUnicode_AsUTF8", pythonapi))
+                ctypes.POINTER(ctypes.c_char), ctypes.py_object
+            )(("PyUnicode_AsUTF8", pythonapi))
     except (ImportError, ValueError):
         return  # No ctypes or not CPython implementation, do nothing
     new_enc = sys.intern(new_enc)
@@ -154,7 +152,7 @@
 # just ensure a usable locale is set via the $LANG variable on posix systems.
 _fs_enc = sys.getfilesystemencoding()
 if getattr(sys, "_brz_default_fs_enc", None) is not None:
-    if (_fs_enc is None or codecs.lookup(_fs_enc).name == "ascii"):
+    if _fs_enc is None or codecs.lookup(_fs_enc).name == "ascii":
         _fs_enc = _patch_filesystem_default_encoding(sys._brz_default_fs_enc)  # type: ignore
 if _fs_enc is None:
     _fs_enc = "ascii"
@@ -202,8 +200,10 @@
         BzrLibraryState directly.
     """
     from breezy import library_state, trace
+
     if setup_ui:
         import breezy.ui
+
         stdin = stdin or sys.stdin
         stdout = stdout or sys.stdout
         stderr = stderr or sys.stderr
@@ -225,4 +225,5 @@
 
 def test_suite():
     import tests
+
     return tests.test_suite()

=== modified file 'breezy/__main__.py'
--- breezy/__main__.py	2023-05-12 08:24:43 +0000
+++ breezy/__main__.py	2023-11-07 18:55:36 +0000
@@ -21,23 +21,26 @@
 import sys
 
 profiling = False
-if '--profile-imports' in sys.argv:
+if "--profile-imports" in sys.argv:
     import profile_imports
+
     profile_imports.install()
     profiling = True
 
 
 if os.name == "posix":
     import locale
+
     try:
-        locale.setlocale(locale.LC_ALL, '')
+        locale.setlocale(locale.LC_ALL, "")
     except locale.Error as e:
         sys.stderr.write(
-            'brz: warning: %s\n'
-            '  bzr could not set the application locale.\n'
-            '  Although this should be no problem for bzr itself, it might\n'
-            '  cause problems with some plugins. To investigate the issue,\n'
-            '  look at the output of the locale(1p) tool.\n' % e)
+            "brz: warning: %s\n"
+            "  bzr could not set the application locale.\n"
+            "  Although this should be no problem for bzr itself, it might\n"
+            "  cause problems with some plugins. To investigate the issue,\n"
+            "  look at the output of the locale(1p) tool.\n" % e
+        )
     # Use better default than ascii with posix filesystems that deal in bytes
     # natively even when the C locale or no locale at all is given. Note that
     # we need an immortal string for the hack, hence the lack of a hyphen.
@@ -46,6 +49,7 @@
 
 def main():
     import breezy.breakin
+
     breezy.breakin.hook_debugger_to_signal()
 
     import breezy.commands
@@ -69,5 +73,5 @@
     os._exit(exit_val)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

=== modified file 'breezy/_annotator_py.py'
--- breezy/_annotator_py.py	2023-06-30 09:01:43 +0000
+++ breezy/_annotator_py.py	2023-11-07 18:55:36 +0000
@@ -81,8 +81,9 @@
                     parent_keys = ()
                     next_parent_map[key] = ()
                 self._update_needed_children(key, parent_keys)
-                needed_keys.update([key for key in parent_keys
-                                    if key not in parent_map])
+                needed_keys.update(
+                    [key for key in parent_keys if key not in parent_map]
+                )
             parent_map.update(next_parent_map)
             # _heads_provider does some graph caching, so it is only valid
             # while self._parent_map hasn't changed
@@ -100,15 +101,15 @@
         """
         keys, ann_keys = self._get_needed_keys(key)
         if pb is not None:
-            pb.update('getting stream', 0, len(keys))
-        stream = self._vf.get_record_stream(keys, 'topological', True)
+            pb.update("getting stream", 0, len(keys))
+        stream = self._vf.get_record_stream(keys, "topological", True)
         for _idx, record in enumerate(stream):
             if pb is not None:
-                pb.update('extracting', 0, len(keys))
-            if record.storage_kind == 'absent':
+                pb.update("extracting", 0, len(keys))
+            if record.storage_kind == "absent":
                 raise errors.RevisionNotPresent(record.key, self._vf)
             this_key = record.key
-            lines = record.get_bytes_as('lines')
+            lines = record.get_bytes_as("lines")
             num_lines = len(lines)
             self._text_cache[this_key] = lines
             yield this_key, lines, num_lines
@@ -132,28 +133,32 @@
         parent_annotations = self._annotations_cache[parent_key]
         # PatienceSequenceMatcher should probably be part of Policy
         from patiencediff import PatienceSequenceMatcher
-        matcher = PatienceSequenceMatcher(
-            None, parent_lines, text)
+
+        matcher = PatienceSequenceMatcher(None, parent_lines, text)
         matching_blocks = matcher.get_matching_blocks()
         return parent_annotations, matching_blocks
 
     def _update_from_first_parent(self, key, annotations, lines, parent_key):
         """Reannotate this text relative to its first parent."""
-        (parent_annotations,
-         matching_blocks) = self._get_parent_annotations_and_matches(
-             key, lines, parent_key)
+        (
+            parent_annotations,
+            matching_blocks,
+        ) = self._get_parent_annotations_and_matches(key, lines, parent_key)
 
         for parent_idx, lines_idx, match_len in matching_blocks:
             # For all matching regions we copy across the parent annotations
-            annotations[lines_idx:lines_idx + match_len] = \
-                parent_annotations[parent_idx:parent_idx + match_len]
+            annotations[lines_idx : lines_idx + match_len] = parent_annotations[
+                parent_idx : parent_idx + match_len
+            ]
 
-    def _update_from_other_parents(self, key, annotations, lines,
-                                   this_annotation, parent_key):
+    def _update_from_other_parents(
+        self, key, annotations, lines, this_annotation, parent_key
+    ):
         """Reannotate this text relative to a second (or more) parent."""
-        (parent_annotations,
-         matching_blocks) = self._get_parent_annotations_and_matches(
-             key, lines, parent_key)
+        (
+            parent_annotations,
+            matching_blocks,
+        ) = self._get_parent_annotations_and_matches(key, lines, parent_key)
 
         last_ann = None
         last_parent = None
@@ -167,8 +172,8 @@
         for parent_idx, lines_idx, match_len in matching_blocks:
             # For lines which match this parent, we will now resolve whether
             # this parent wins over the current annotation
-            ann_sub = annotations[lines_idx:lines_idx + match_len]
-            par_sub = parent_annotations[parent_idx:parent_idx + match_len]
+            ann_sub = annotations[lines_idx : lines_idx + match_len]
+            par_sub = parent_annotations[parent_idx : parent_idx + match_len]
             if ann_sub == par_sub:
                 continue
             for idx in range(match_len):
@@ -214,11 +219,11 @@
         annotations = [this_annotation] * num_lines
         parent_keys = self._parent_map[key]
         if parent_keys:
-            self._update_from_first_parent(key, annotations, text,
-                                           parent_keys[0])
+            self._update_from_first_parent(key, annotations, text, parent_keys[0])
             for parent in parent_keys[1:]:
-                self._update_from_other_parents(key, annotations, text,
-                                                this_annotation, parent)
+                self._update_from_other_parents(
+                    key, annotations, text, this_annotation, parent
+                )
         self._record_annotation(key, parent_keys, annotations)
 
     def add_special_text(self, key, parent_keys, text):
@@ -246,8 +251,7 @@
             lines the text of "key" as a list of lines
         """
         with ui.ui_factory.nested_progress_bar() as pb:
-            for text_key, text, num_lines in self._get_needed_texts(
-                    key, pb=pb):
+            for text_key, text, num_lines in self._get_needed_texts(key, pb=pb):
                 self._annotate_one(text_key, text, num_lines)
         try:
             annotations = self._annotations_cache[key]
@@ -281,6 +285,7 @@
             A list of tuples with a single annotation key for each line.
         """
         from .annotate import _break_annotation_tie
+
         custom_tiebreaker = _break_annotation_tie
         annotations, lines = self.annotate(key)
         out = []
@@ -295,7 +300,8 @@
                     # get the item out of the set
                     head = next(iter(the_heads))
                 else:
-                    head = self._resolve_annotation_tie(the_heads, line,
-                                                        custom_tiebreaker)
+                    head = self._resolve_annotation_tie(
+                        the_heads, line, custom_tiebreaker
+                    )
             append((head, line))
         return out

=== modified file 'breezy/_known_graph_py.py'
--- breezy/_known_graph_py.py	2023-09-29 18:19:23 +0000
+++ breezy/_known_graph_py.py	2023-11-07 18:55:36 +0000
@@ -24,7 +24,7 @@
 class _KnownGraphNode:
     """Represents a single object in the known graph."""
 
-    __slots__ = ('key', 'parent_keys', 'child_keys', 'gdfo')
+    __slots__ = ("key", "parent_keys", "child_keys", "gdfo")
 
     def __init__(self, key, parent_keys):
         self.key = key
@@ -34,15 +34,19 @@
         self.gdfo = None
 
     def __repr__(self):
-        return '{}({}  gdfo:{} par:{} child:{})'.format(
-            self.__class__.__name__, self.key, self.gdfo,
-            self.parent_keys, self.child_keys)
+        return "{}({}  gdfo:{} par:{} child:{})".format(
+            self.__class__.__name__,
+            self.key,
+            self.gdfo,
+            self.parent_keys,
+            self.child_keys,
+        )
 
 
 class _MergeSortNode:
     """Information about a specific node in the merge graph."""
 
-    __slots__ = ('key', 'merge_depth', 'revno', 'end_of_merge')
+    __slots__ = ("key", "merge_depth", "revno", "end_of_merge")
 
     def __init__(self, key, merge_depth, revno, end_of_merge):
         self.key = key
@@ -92,12 +96,10 @@
                 parent_node.child_keys.append(key)
 
     def _find_tails(self):
-        return [node for node in self._nodes.values()
-                if not node.parent_keys]
+        return [node for node in self._nodes.values() if not node.parent_keys]
 
     def _find_tips(self):
-        return [node for node in self._nodes.values()
-                if not node.child_keys]
+        return [node for node in self._nodes.values() if not node.child_keys]
 
     def _find_gdfo(self):
         nodes = self._nodes
@@ -157,8 +159,9 @@
                     return  # Identical content
                 else:
                     raise ValueError(
-                        f'Parent key mismatch, existing node {key}'
-                        f' has parents of {existing_parent_keys} not {parent_keys}')
+                        f"Parent key mismatch, existing node {key}"
+                        f" has parents of {existing_parent_keys} not {parent_keys}"
+                    )
         else:
             node = _KnownGraphNode(key, parent_keys)
             nodes[key] = node
@@ -301,7 +304,7 @@
         prefix_tips = {}
         for node in tips:
             if node.key.__class__ is str or len(node.key) == 1:
-                prefix = ''
+                prefix = ""
             else:
                 prefix = node.key[0]
             prefix_tips.setdefault(prefix, []).append(node)
@@ -310,8 +313,7 @@
 
         result = []
         for prefix in sorted(prefix_tips):
-            pending = sorted(prefix_tips[prefix], key=lambda n: n.key,
-                             reverse=True)
+            pending = sorted(prefix_tips[prefix], key=lambda n: n.key, reverse=True)
             while pending:
                 node = pending.pop()
                 if node.parent_keys is None:
@@ -333,17 +335,21 @@
     def merge_sort(self, tip_key):
         """Compute the merge sorted graph output."""
         from breezy import tsort
-        as_parent_map = {node.key: node.parent_keys
-                             for node in self._nodes.values()
-                             if node.parent_keys is not None}
+
+        as_parent_map = {
+            node.key: node.parent_keys
+            for node in self._nodes.values()
+            if node.parent_keys is not None
+        }
         # We intentionally always generate revnos and never force the
         # mainline_revisions
         # Strip the sequence_number that merge_sort generates
-        return [_MergeSortNode(key, merge_depth, revno, end_of_merge)
-                for _, key, merge_depth, revno, end_of_merge
-                in tsort.merge_sort(as_parent_map, tip_key,
-                                    mainline_revisions=None,
-                                    generate_revno=True)]
+        return [
+            _MergeSortNode(key, merge_depth, revno, end_of_merge)
+            for _, key, merge_depth, revno, end_of_merge in tsort.merge_sort(
+                as_parent_map, tip_key, mainline_revisions=None, generate_revno=True
+            )
+        ]
 
     def get_parent_keys(self, key):
         """Get the parents for a key.

=== modified file 'breezy/add.py'
--- breezy/add.py	2023-06-24 13:01:43 +0000
+++ breezy/add.py	2023-11-07 18:55:36 +0000
@@ -50,7 +50,7 @@
         :param kind: The kind of the object being added.
         """
         if self.should_print:
-            self._to_file.write(f'adding {_quote(path)}\n')
+            self._to_file.write(f"adding {_quote(path)}\n")
         return None
 
     def skip_file(self, tree, path, kind, stat_value=None):
@@ -74,9 +74,9 @@
     _max_size = None
 
     def skip_file(self, tree, path, kind, stat_value=None):
-        if kind != 'file':
+        if kind != "file":
             return False
-        opt_name = 'add.maximum_file_size'
+        opt_name = "add.maximum_file_size"
         if self._max_size is None:
             config = tree.get_config_stack()
             self._max_size = config.get(opt_name)
@@ -85,9 +85,11 @@
         else:
             file_size = stat_value.st_size
         if self._max_size > 0 and file_size > self._max_size:
-            ui.ui_factory.show_warning(gettext(
-                "skipping {0} (larger than {1} of {2} bytes)").format(
-                path, opt_name, self._max_size))
+            ui.ui_factory.show_warning(
+                gettext("skipping {0} (larger than {1} of {2} bytes)").format(
+                    path, opt_name, self._max_size
+                )
+            )
             return True
         return False
 
@@ -96,8 +98,7 @@
     """This class will try to extract file ids from another tree."""
 
     def __init__(self, base_tree, base_path, to_file=None, should_print=None):
-        super().__init__(to_file=to_file,
-                                                should_print=should_print)
+        super().__init__(to_file=to_file, should_print=should_print)
         self.base_tree = base_tree
         self.base_path = base_path
 
@@ -107,12 +108,11 @@
         file_id, base_path = self._get_base_file_id(path, parent_ie)
         if file_id is not None:
             if self.should_print:
-                self._to_file.write(f'adding {path} w/ file id from {base_path}\n')
+                self._to_file.write(f"adding {path} w/ file id from {base_path}\n")
         else:
             # we aren't doing anything special, so let the default
             # reporter happen
-            file_id = super().__call__(
-                inv, parent_ie, path, kind)
+            file_id = super().__call__(inv, parent_ie, path, kind)
         return file_id
 
     def _get_base_file_id(self, path, parent_ie):

=== modified file 'breezy/annotate.py'
--- breezy/annotate.py	2023-05-12 08:24:43 +0000
+++ breezy/annotate.py	2023-11-07 18:55:36 +0000
@@ -33,8 +33,9 @@
 from .revision import CURRENT_REVISION, Revision
 
 
-def annotate_file_tree(tree, path, to_file, verbose=False, full=False,
-                       show_ids=False, branch=None):
+def annotate_file_tree(
+    tree, path, to_file, verbose=False, full=False, show_ids=False, branch=None
+):
     """Annotate path in a tree.
 
     The tree should already be read_locked() when annotate_file_tree is called.
@@ -64,21 +65,22 @@
         # Should get some more pending commit attributes, like pending tags,
         # bugfixes etc.
         try:
-            committer = branch.get_config_stack().get('email')
+            committer = branch.get_config_stack().get("email")
         except errors.NoWhoami:
-            committer = 'local user'
+            committer = "local user"
         current_rev = Revision(
-                CURRENT_REVISION,
-                parent_ids=tree.get_parent_ids(),
-                committer=committer, message="?",
-                properties={},
-                inventory_sha1=None,
-                timestamp=round(time.time(), 3),
-                timezone=osutils.local_time_offset())
+            CURRENT_REVISION,
+            parent_ids=tree.get_parent_ids(),
+            committer=committer,
+            message="?",
+            properties={},
+            inventory_sha1=None,
+            timestamp=round(time.time(), 3),
+            timezone=osutils.local_time_offset(),
+        )
     else:
         current_rev = None
-    annotation = list(_expand_annotations(
-        annotations, branch, current_rev))
+    annotation = list(_expand_annotations(annotations, branch, current_rev))
     _print_annotations(annotation, verbose, to_file, full, encoding)
 
 
@@ -100,21 +102,26 @@
     max_revno_len = max(max_revno_len, 3)
 
     # Output the annotations
-    prevanno = ''
-    for (revno_str, author, date_str, _line_rev_id, text) in annotation:
+    prevanno = ""
+    for revno_str, author, date_str, _line_rev_id, text in annotation:
         if verbose:
-            anno = '%-*s %-*s %8s ' % (max_revno_len, revno_str,
-                                       max_origin_len, author, date_str)
+            anno = "%-*s %-*s %8s " % (
+                max_revno_len,
+                revno_str,
+                max_origin_len,
+                author,
+                date_str,
+            )
         else:
             if len(revno_str) > max_revno_len:
-                revno_str = revno_str[:max_revno_len - 1] + '>'
+                revno_str = revno_str[: max_revno_len - 1] + ">"
             anno = "%-*s %-7s " % (max_revno_len, revno_str, author[:7])
         if anno.lstrip() == "" and full:
             anno = prevanno
         # GZ 2017-05-21: Writing both unicode annotation and bytes from file
         # which the given to_file must cope with.
         to_file.write(anno)
-        to_file.write(f'| {text.decode(encoding)}\n')
+        to_file.write(f"| {text.decode(encoding)}\n")
         prevanno = anno
 
 
@@ -127,9 +134,10 @@
         if full or last_rev_id != origin:
             this = origin
         else:
-            this = b''
-        to_file.write('%*s | %s' % (
-            max_origin_len, this.decode('utf-8'), text.decode(encoding)))
+            this = b""
+        to_file.write(
+            "%*s | %s" % (max_origin_len, this.decode("utf-8"), text.decode(encoding))
+        )
         last_rev_id = origin
     return
 
@@ -145,6 +153,7 @@
     :param branch: A locked branch to query for revision details.
     """
     from . import tsort
+
     repository = branch.repository
     revision_ids = {o for o, t in annotations}
     if current_rev is not None:
@@ -158,19 +167,19 @@
         #      VF.get_known_graph_ancestry().
         graph = repository.get_graph()
         revision_graph = {
-            key: value for key, value in
-            graph.iter_ancestry(current_rev.parent_ids) if value is not None}
+            key: value
+            for key, value in graph.iter_ancestry(current_rev.parent_ids)
+            if value is not None
+        }
         revision_graph = _strip_NULL_ghosts(revision_graph)
         revision_graph[last_revision] = current_rev.parent_ids
         merge_sorted_revisions = tsort.merge_sort(
-            revision_graph,
-            last_revision,
-            None,
-            generate_revno=True)
+            revision_graph, last_revision, None, generate_revno=True
+        )
         revision_id_to_revno = {
             rev_id: revno
-            for seq_num, rev_id, depth, revno, end_of_merge in
-            merge_sorted_revisions}
+            for seq_num, rev_id, depth, revno, end_of_merge in merge_sorted_revisions
+        }
     else:
         # TODO(jelmer): Only look up the revision ids that we need (i.e. those
         # in revision_ids). Possibly add a HPSS call that can look those up
@@ -179,28 +188,26 @@
     last_origin = None
     revisions = {}
     if CURRENT_REVISION in revision_ids:
-        revision_id_to_revno[CURRENT_REVISION] = (
-            "%d?" % (branch.revno() + 1),)
+        revision_id_to_revno[CURRENT_REVISION] = ("%d?" % (branch.revno() + 1),)
         revisions[CURRENT_REVISION] = current_rev
     revisions.update(
-        entry for entry in
-        repository.iter_revisions(revision_ids)
-        if entry[1] is not None)
+        entry
+        for entry in repository.iter_revisions(revision_ids)
+        if entry[1] is not None
+    )
     for origin, text in annotations:
-        text = text.rstrip(b'\r\n')
+        text = text.rstrip(b"\r\n")
         if origin == last_origin:
-            (revno_str, author, date_str) = ('', '', '')
+            (revno_str, author, date_str) = ("", "", "")
         else:
             last_origin = origin
             if origin not in revisions:
-                (revno_str, author, date_str) = ('?', '?', '?')
+                (revno_str, author, date_str) = ("?", "?", "?")
             else:
-                revno_str = '.'.join(
-                    str(i) for i in revision_id_to_revno[origin])
+                revno_str = ".".join(str(i) for i in revision_id_to_revno[origin])
             rev = revisions[origin]
             tz = rev.timezone or 0
-            date_str = time.strftime('%Y%m%d',
-                                     time.gmtime(rev.timestamp + tz))
+            date_str = time.strftime("%Y%m%d", time.gmtime(rev.timestamp + tz))
             # a lazy way to get something like the email address
             # TODO: Get real email address
             author = rev.get_apparent_authors()[0]
@@ -210,9 +217,13 @@
         yield (revno_str, author, date_str, origin, text)
 
 
-def reannotate(parents_lines, new_lines, new_revision_id,
-               _left_matching_blocks=None,
-               heads_provider=None):
+def reannotate(
+    parents_lines,
+    new_lines,
+    new_revision_id,
+    _left_matching_blocks=None,
+    heads_provider=None,
+):
     """Create a new annotated version from new lines and parent annotations.
 
     :param parents_lines: List of annotated lines for all parents
@@ -231,19 +242,25 @@
     if len(parents_lines) == 0:
         lines = [(new_revision_id, line) for line in new_lines]
     elif len(parents_lines) == 1:
-        lines = _reannotate(parents_lines[0], new_lines, new_revision_id,
-                            _left_matching_blocks)
+        lines = _reannotate(
+            parents_lines[0], new_lines, new_revision_id, _left_matching_blocks
+        )
     elif len(parents_lines) == 2:
-        left = _reannotate(parents_lines[0], new_lines, new_revision_id,
-                           _left_matching_blocks)
-        lines = _reannotate_annotated(parents_lines[1], new_lines,
-                                      new_revision_id, left,
-                                      heads_provider)
+        left = _reannotate(
+            parents_lines[0], new_lines, new_revision_id, _left_matching_blocks
+        )
+        lines = _reannotate_annotated(
+            parents_lines[1], new_lines, new_revision_id, left, heads_provider
+        )
     else:
-        reannotations = [_reannotate(parents_lines[0], new_lines,
-                                     new_revision_id, _left_matching_blocks)]
-        reannotations.extend(_reannotate(p, new_lines, new_revision_id)
-                             for p in parents_lines[1:])
+        reannotations = [
+            _reannotate(
+                parents_lines[0], new_lines, new_revision_id, _left_matching_blocks
+            )
+        ]
+        reannotations.extend(
+            _reannotate(p, new_lines, new_revision_id) for p in parents_lines[1:]
+        )
         lines = []
         for annos in zip(*reannotations):
             origins = {a for a, l in annos}
@@ -261,26 +278,28 @@
     return lines
 
 
-def _reannotate(parent_lines, new_lines, new_revision_id,
-                matching_blocks=None):
+def _reannotate(parent_lines, new_lines, new_revision_id, matching_blocks=None):
     import patiencediff
+
     new_cur = 0
     if matching_blocks is None:
         plain_parent_lines = [l for r, l in parent_lines]
         matcher = patiencediff.PatienceSequenceMatcher(
-            None, plain_parent_lines, new_lines)
+            None, plain_parent_lines, new_lines
+        )
         matching_blocks = matcher.get_matching_blocks()
     lines = []
     for i, j, n in matching_blocks:
         for line in new_lines[new_cur:j]:
             lines.append((new_revision_id, line))
-        lines.extend(parent_lines[i:i + n])
+        lines.extend(parent_lines[i : i + n])
         new_cur = j + n
     return lines
 
 
 def _get_matching_blocks(old, new):
     import patiencediff
+
     matcher = patiencediff.PatienceSequenceMatcher(None, old, new)
     return matcher.get_matching_blocks()
 
@@ -309,10 +328,18 @@
     return sorted(annotated_lines)[0]
 
 
-def _find_matching_unannotated_lines(output_lines, plain_child_lines,
-                                     child_lines, start_child, end_child,
-                                     right_lines, start_right, end_right,
-                                     heads_provider, revision_id):
+def _find_matching_unannotated_lines(
+    output_lines,
+    plain_child_lines,
+    child_lines,
+    start_child,
+    end_child,
+    right_lines,
+    start_right,
+    end_right,
+    heads_provider,
+    revision_id,
+):
     """Find lines in plain_right_lines that match the existing lines.
 
     :param output_lines: Append final annotated lines to this list
@@ -344,8 +371,9 @@
     for right_idx, child_idx, match_len in match_blocks:
         # All the lines that don't match are just passed along
         if child_idx > last_child_idx:
-            output_extend(child_lines[start_child + last_child_idx:
-                                      start_child + child_idx])
+            output_extend(
+                child_lines[start_child + last_child_idx : start_child + child_idx]
+            )
         for offset in range(match_len):
             left = child_lines[start_child + child_idx + offset]
             right = right_lines[start_right + right_idx + offset]
@@ -370,15 +398,15 @@
                         # performance degradation as criss-cross merges will
                         # flip-flop the attribution.
                         if _break_annotation_tie is None:
-                            output_append(
-                                _old_break_annotation_tie([left, right]))
+                            output_append(_old_break_annotation_tie([left, right]))
                         else:
                             output_append(_break_annotation_tie([left, right]))
         last_child_idx = child_idx + match_len
 
 
-def _reannotate_annotated(right_parent_lines, new_lines, new_revision_id,
-                          annotated_lines, heads_provider):
+def _reannotate_annotated(
+    right_parent_lines, new_lines, new_revision_id, annotated_lines, heads_provider
+):
     """Update the annotations for a node based on another parent.
 
     :param right_parent_lines: A list of annotated lines for the right-hand
@@ -401,8 +429,7 @@
     # The line just after the last match from the right side
     last_right_idx = 0
     last_left_idx = 0
-    matching_left_and_right = _get_matching_blocks(right_parent_lines,
-                                                   annotated_lines)
+    matching_left_and_right = _get_matching_blocks(right_parent_lines, annotated_lines)
     for right_idx, left_idx, match_len in matching_left_and_right:
         # annotated lines from last_left_idx to left_idx did not match the
         # lines from last_right_idx to right_idx, the raw lines should be
@@ -412,17 +439,22 @@
             lines_extend(annotated_lines[last_left_idx:left_idx])
         else:
             # We need to see if any of the unannotated lines match
-            _find_matching_unannotated_lines(lines,
-                                             new_lines, annotated_lines,
-                                             last_left_idx, left_idx,
-                                             right_parent_lines,
-                                             last_right_idx, right_idx,
-                                             heads_provider,
-                                             new_revision_id)
+            _find_matching_unannotated_lines(
+                lines,
+                new_lines,
+                annotated_lines,
+                last_left_idx,
+                left_idx,
+                right_parent_lines,
+                last_right_idx,
+                right_idx,
+                heads_provider,
+                new_revision_id,
+            )
         last_right_idx = right_idx + match_len
         last_left_idx = left_idx + match_len
         # If left and right agree on a range, just push that into the output
-        lines_extend(annotated_lines[left_idx:left_idx + match_len])
+        lines_extend(annotated_lines[left_idx : left_idx + match_len])
     return lines
 
 

=== modified file 'breezy/archive/__init__.py'
--- breezy/archive/__init__.py	2023-05-12 08:24:43 +0000
+++ breezy/archive/__init__.py	2023-11-07 18:55:36 +0000
@@ -22,7 +22,6 @@
 
 
 class ArchiveFormatInfo:
-
     def __init__(self, extensions):
         self.extensions = extensions
 
@@ -40,14 +39,15 @@
 
     def register(self, key, factory, extensions, help=None):
         """Register an archive format."""
-        registry.Registry.register(self, key, factory, help,
-                                   ArchiveFormatInfo(extensions))
+        registry.Registry.register(
+            self, key, factory, help, ArchiveFormatInfo(extensions)
+        )
         self._register_extensions(key, extensions)
 
-    def register_lazy(self, key, module_name, member_name, extensions,
-                      help=None):
-        registry.Registry.register_lazy(self, key, module_name, member_name,
-                                        help, ArchiveFormatInfo(extensions))
+    def register_lazy(self, key, module_name, member_name, extensions, help=None):
+        registry.Registry.register_lazy(
+            self, key, module_name, member_name, help, ArchiveFormatInfo(extensions)
+        )
         self._register_extensions(key, extensions)
 
     def _register_extensions(self, name, extensions):
@@ -67,29 +67,45 @@
             return None
 
 
-def create_archive(format, tree, name, root=None, subdir=None,
-                   force_mtime=None, recurse_nested=False) -> Iterator[bytes]:
+def create_archive(
+    format, tree, name, root=None, subdir=None, force_mtime=None, recurse_nested=False
+) -> Iterator[bytes]:
     try:
         archive_fn = format_registry.get(format)
     except KeyError as exc:
         raise errors.NoSuchExportFormat(format) from exc
-    return cast(Iterator[bytes],
-                archive_fn(
-                    tree, name, root=root, subdir=subdir,
-                    force_mtime=force_mtime,
-                    recurse_nested=recurse_nested))
+    return cast(
+        Iterator[bytes],
+        archive_fn(
+            tree,
+            name,
+            root=root,
+            subdir=subdir,
+            force_mtime=force_mtime,
+            recurse_nested=recurse_nested,
+        ),
+    )
 
 
 format_registry = ArchiveFormatRegistry()
-format_registry.register_lazy('tar', 'breezy.archive.tar',
-                              'plain_tar_generator', ['.tar'], )
-format_registry.register_lazy('tgz', 'breezy.archive.tar',
-                              'tgz_generator', ['.tar.gz', '.tgz'])
-format_registry.register_lazy('tbz2', 'breezy.archive.tar',
-                              'tbz_generator', ['.tar.bz2', '.tbz2'])
-format_registry.register_lazy('tlzma', 'breezy.archive.tar',
-                              'tar_lzma_generator', ['.tar.lzma'])
-format_registry.register_lazy('txz', 'breezy.archive.tar',
-                              'tar_xz_generator', ['.tar.xz'])
-format_registry.register_lazy('zip', 'breezy.archive.zip',
-                              'zip_archive_generator', ['.zip'])
+format_registry.register_lazy(
+    "tar",
+    "breezy.archive.tar",
+    "plain_tar_generator",
+    [".tar"],
+)
+format_registry.register_lazy(
+    "tgz", "breezy.archive.tar", "tgz_generator", [".tar.gz", ".tgz"]
+)
+format_registry.register_lazy(
+    "tbz2", "breezy.archive.tar", "tbz_generator", [".tar.bz2", ".tbz2"]
+)
+format_registry.register_lazy(
+    "tlzma", "breezy.archive.tar", "tar_lzma_generator", [".tar.lzma"]
+)
+format_registry.register_lazy(
+    "txz", "breezy.archive.tar", "tar_xz_generator", [".tar.xz"]
+)
+format_registry.register_lazy(
+    "zip", "breezy.archive.zip", "zip_archive_generator", [".zip"]
+)

=== modified file 'breezy/archive/tar.py'
--- breezy/archive/tar.py	2023-11-01 20:32:05 +0000
+++ breezy/archive/tar.py	2023-11-07 18:55:36 +0000
@@ -58,7 +58,7 @@
         fileobj = BytesIO(content)
     elif entry.kind in ("directory", "tree-reference"):
         item.type = tarfile.DIRTYPE
-        item.name += '/'
+        item.name += "/"
         item.size = 0
         item.mode = 0o755
         fileobj = None
@@ -69,11 +69,15 @@
         item.linkname = tree.get_symlink_target(tree_path)
         fileobj = None
     else:
-        raise errors.BzrError(f"don't know how to export {{{final_path}}} of kind {entry.kind!r}")
+        raise errors.BzrError(
+            f"don't know how to export {{{final_path}}} of kind {entry.kind!r}"
+        )
     return (item, fileobj)
 
 
-def tarball_generator(tree, root, subdir=None, force_mtime=None, format='', recurse_nested=False):
+def tarball_generator(
+    tree, root, subdir=None, force_mtime=None, format="", recurse_nested=False
+):
     """Export tree contents to a tarball.
 
     Args:
@@ -89,9 +93,11 @@
     buf = BytesIO()
     with closing(tarfile.open(None, f"w:{format}", buf)) as ball, tree.lock_read():
         for final_path, tree_path, entry in _export_iter_entries(
-                tree, subdir, recurse_nested=recurse_nested):
+            tree, subdir, recurse_nested=recurse_nested
+        ):
             (item, fileobj) = prepare_tarball_item(
-                tree, root, final_path, tree_path, entry, force_mtime)
+                tree, root, final_path, tree_path, entry, force_mtime
+            )
             ball.addfile(item, fileobj)
             # Yield the data that was written so far, rinse, repeat.
             yield buf.getvalue()
@@ -108,15 +114,17 @@
     """
     with tree.lock_read():
         import gzip
+
         if force_mtime is not None:
             root_mtime = force_mtime
-        elif (getattr(tree, "repository", None) and
-              getattr(tree, "get_revision_id", None)):
+        elif getattr(tree, "repository", None) and getattr(
+            tree, "get_revision_id", None
+        ):
             # If this is a revision tree, use the revisions' timestamp
             rev = tree.repository.get_revision(tree.get_revision_id())
             root_mtime = rev.timestamp
-        elif tree.is_versioned(''):
-            root_mtime = tree.get_file_mtime('')
+        elif tree.is_versioned(""):
+            root_mtime = tree.get_file_mtime("")
         else:
             root_mtime = None
 
@@ -126,11 +134,10 @@
         # dest. (bug 102234)
         basename = os.path.basename(dest)
         buf = BytesIO()
-        zipstream = gzip.GzipFile(basename, 'w', fileobj=buf,
-                                  mtime=root_mtime)
+        zipstream = gzip.GzipFile(basename, "w", fileobj=buf, mtime=root_mtime)
         for chunk in tarball_generator(
-                tree, root, subdir, force_mtime,
-                recurse_nested=recurse_nested):
+            tree, root, subdir, force_mtime, recurse_nested=recurse_nested
+        ):
             zipstream.write(chunk)
             # Yield the data that was written so far, rinse, repeat.
             yield buf.getvalue()
@@ -148,30 +155,38 @@
     already exists, it will be clobbered, like with "tar -c".
     """
     return tarball_generator(
-        tree, root, subdir, force_mtime, format='bz2',
-        recurse_nested=recurse_nested)
-
-
-def plain_tar_generator(tree, dest, root, subdir,
-                        force_mtime=None, recurse_nested=False):
+        tree, root, subdir, force_mtime, format="bz2", recurse_nested=recurse_nested
+    )
+
+
+def plain_tar_generator(
+    tree, dest, root, subdir, force_mtime=None, recurse_nested=False
+):
     """Export this tree to a new tar file.
 
     `dest` will be created holding the contents of this tree; if it
     already exists, it will be clobbered, like with "tar -c".
     """
     return tarball_generator(
-        tree, root, subdir, force_mtime, format='',
-        recurse_nested=recurse_nested)
+        tree, root, subdir, force_mtime, format="", recurse_nested=recurse_nested
+    )
 
 
 def tar_xz_generator(tree, dest, root, subdir, force_mtime=None, recurse_nested=False):
     return tar_lzma_generator(
-        tree, dest, root, subdir, force_mtime, "xz",
-        recurse_nested=recurse_nested)
-
-
-def tar_lzma_generator(tree, dest, root, subdir, force_mtime=None,
-                       compression_format="alone", recurse_nested=False):
+        tree, dest, root, subdir, force_mtime, "xz", recurse_nested=recurse_nested
+    )
+
+
+def tar_lzma_generator(
+    tree,
+    dest,
+    root,
+    subdir,
+    force_mtime=None,
+    compression_format="alone",
+    recurse_nested=False,
+):
     """Export this tree to a new .tar.lzma file.
 
     `dest` will be created holding the contents of this tree; if it
@@ -180,18 +195,19 @@
     try:
         import lzma
     except ModuleNotFoundError as exc:
-        raise errors.DependencyNotPresent('lzma', e) from exc
+        raise errors.DependencyNotPresent("lzma", e) from exc
 
     compressor = lzma.LZMACompressor(
         format={
-            'xz': lzma.FORMAT_XZ,
-            'raw': lzma.FORMAT_RAW,
-            'alone': lzma.FORMAT_ALONE,
-            }[compression_format])
+            "xz": lzma.FORMAT_XZ,
+            "raw": lzma.FORMAT_RAW,
+            "alone": lzma.FORMAT_ALONE,
+        }[compression_format]
+    )
 
     for chunk in tarball_generator(
-            tree, root, subdir, force_mtime=force_mtime,
-            recurse_nested=recurse_nested):
+        tree, root, subdir, force_mtime=force_mtime, recurse_nested=recurse_nested
+    ):
         yield compressor.compress(chunk)
 
     yield compressor.flush()

=== modified file 'breezy/archive/zip.py'
--- breezy/archive/zip.py	2023-05-12 08:24:43 +0000
+++ breezy/archive/zip.py	2023-11-07 18:55:36 +0000
@@ -28,16 +28,17 @@
 
 # Windows expects this bit to be set in the 'external_attr' section,
 # or it won't consider the entry a directory.
-ZIP_DIRECTORY_BIT = (1 << 4)
-FILE_PERMISSIONS = (0o644 << 16)
-DIR_PERMISSIONS = (0o755 << 16)
+ZIP_DIRECTORY_BIT = 1 << 4
+FILE_PERMISSIONS = 0o644 << 16
+DIR_PERMISSIONS = 0o755 << 16
 
 _FILE_ATTR = stat.S_IFREG | FILE_PERMISSIONS
 _DIR_ATTR = stat.S_IFDIR | ZIP_DIRECTORY_BIT | DIR_PERMISSIONS
 
 
-def zip_archive_generator(tree, dest, root, subdir=None,
-                          force_mtime=None, recurse_nested=False):
+def zip_archive_generator(
+    tree, dest, root, subdir=None, force_mtime=None, recurse_nested=False
+):
     """Export this tree to a new zip file.
 
     `dest` will be created holding the contents of this tree; if it
@@ -45,10 +46,10 @@
     """
     compression = zipfile.ZIP_DEFLATED
     with tempfile.SpooledTemporaryFile() as buf:
-        with closing(zipfile.ZipFile(buf, "w", compression)) as zipf, \
-                tree.lock_read():
+        with closing(zipfile.ZipFile(buf, "w", compression)) as zipf, tree.lock_read():
             for dp, tp, ie in _export_iter_entries(
-                    tree, subdir, recurse_nested=recurse_nested):
+                tree, subdir, recurse_nested=recurse_nested
+            ):
                 mutter("  export {%s} kind %s to %s", tp, ie.kind, dest)
 
                 # zipfile.ZipFile switches all paths to forward
@@ -60,9 +61,7 @@
                 date_time = time.localtime(mtime)[:6]
                 filename = osutils.pathjoin(root, dp)
                 if ie.kind == "file":
-                    zinfo = zipfile.ZipInfo(
-                        filename=filename,
-                        date_time=date_time)
+                    zinfo = zipfile.ZipInfo(filename=filename, date_time=date_time)
                     zinfo.compress_type = compression
                     zinfo.external_attr = _FILE_ATTR
                     content = tree.get_file_text(tp)
@@ -72,15 +71,15 @@
                     # to the zip routine that they are really directories and
                     # not just empty files.
                     zinfo = zipfile.ZipInfo(
-                        filename=filename + '/',
-                        date_time=date_time)
+                        filename=filename + "/", date_time=date_time
+                    )
                     zinfo.compress_type = compression
                     zinfo.external_attr = _DIR_ATTR
-                    zipf.writestr(zinfo, '')
+                    zipf.writestr(zinfo, "")
                 elif ie.kind == "symlink":
                     zinfo = zipfile.ZipInfo(
-                        filename=(filename + '.lnk'),
-                        date_time=date_time)
+                        filename=(filename + ".lnk"), date_time=date_time
+                    )
                     zinfo.compress_type = compression
                     zinfo.external_attr = _FILE_ATTR
                     zipf.writestr(zinfo, tree.get_symlink_target(tp))

=== modified file 'breezy/atomicfile.py'
--- breezy/atomicfile.py	2023-05-12 08:24:43 +0000
+++ breezy/atomicfile.py	2023-11-07 18:55:36 +0000
@@ -25,9 +25,7 @@
 
 
 class AtomicFileAlreadyClosed(errors.PathError):
-
-    _fmt = ('"%(function)s" called on an AtomicFile after it was closed:'
-            ' "%(path)s"')
+    _fmt = '"%(function)s" called on an AtomicFile after it was closed:' ' "%(path)s"'
 
     def __init__(self, path, function):
         errors.PathError.__init__(self, path=path, extra=None)
@@ -43,9 +41,9 @@
     place or abort() to cancel.
     """
 
-    __slots__ = ['tmpfilename', 'realfilename', '_fd']
+    __slots__ = ["tmpfilename", "realfilename", "_fd"]
 
-    def __init__(self, filename, mode='wb', new_mode=None):
+    def __init__(self, filename, mode="wb", new_mode=None):
         global _hostname
 
         self._fd = None
@@ -53,15 +51,19 @@
         if _hostname is None:
             _hostname = osutils.get_host_name()
 
-        self.tmpfilename = '%s.%d.%s.%s.tmp' % (filename, _pid, _hostname,
-                                                osutils.rand_chars(10))
+        self.tmpfilename = "%s.%d.%s.%s.tmp" % (
+            filename,
+            _pid,
+            _hostname,
+            osutils.rand_chars(10),
+        )
 
         self.realfilename = filename
 
         flags = os.O_EXCL | os.O_CREAT | os.O_WRONLY | osutils.O_NOINHERIT
-        if mode == 'wb':
+        if mode == "wb":
             flags |= osutils.O_BINARY
-        elif mode != 'wt':
+        elif mode != "wt":
             raise ValueError(f"invalid AtomicFile mode {mode!r}")
 
         if new_mode is not None:
@@ -81,7 +83,7 @@
                 osutils.chmod_if_possible(self.tmpfilename, new_mode)
 
     def __repr__(self):
-        return f'{self.__class__.__name__}({self.realfilename!r})'
+        return f"{self.__class__.__name__}({self.realfilename!r})"
 
     def write(self, data):
         """Write some data to the file. Like file.write()."""
@@ -90,20 +92,19 @@
     def _close_tmpfile(self, func_name):
         """Close the local temp file in preparation for commit or abort."""
         if self._fd is None:
-            raise AtomicFileAlreadyClosed(path=self.realfilename,
-                                          function=func_name)
+            raise AtomicFileAlreadyClosed(path=self.realfilename, function=func_name)
         fd = self._fd
         self._fd = None
         os.close(fd)
 
     def commit(self):
         """Close the file and move to final name."""
-        self._close_tmpfile('commit')
+        self._close_tmpfile("commit")
         osutils.rename(self.tmpfilename, self.realfilename)
 
     def abort(self):
         """Discard temporary file without committing changes."""
-        self._close_tmpfile('abort')
+        self._close_tmpfile("abort")
         os.remove(self.tmpfilename)
 
     def close(self):

=== modified file 'breezy/bisect.py'
--- breezy/bisect.py	2023-05-12 08:24:43 +0000
+++ breezy/bisect.py	2023-11-07 18:55:36 +0000
@@ -37,15 +37,15 @@
         self._controldir = controldir
         self._branch = self._controldir.open_branch()
         if self._controldir.control_transport.has(filename):
-            self._revid = self._controldir.control_transport.get_bytes(
-                filename).strip()
+            self._revid = self._controldir.control_transport.get_bytes(filename).strip()
         else:
             self._revid = self._branch.last_revision()
 
     def _save(self):
         """Save the current revision."""
         self._controldir.control_transport.put_bytes(
-            self._filename, self._revid + b"\n")
+            self._filename, self._revid + b"\n"
+        )
 
     def get_current_revid(self):
         """Return the current revision id."""
@@ -79,8 +79,7 @@
             revid = self._branch.get_rev_id(revid)
         elif isinstance(revid, list):
             revid = revid[0].in_history(working.branch).rev_id
-        working.revert(None, working.branch.repository.revision_tree(revid),
-                       False)
+        working.revert(None, working.branch.repository.revision_tree(revid), False)
         self._revid = revid
         self._save()
 
@@ -134,14 +133,18 @@
         with repo.lock_read():
             graph = repo.get_graph()
             rev_sequence = graph.iter_lefthand_ancestry(
-                last_revid, (_mod_revision.NULL_REVISION,))
+                last_revid, (_mod_revision.NULL_REVISION,)
+            )
             high_revid = None
             low_revid = None
             between_revs = []
             for revision in rev_sequence:
                 between_revs.insert(0, revision)
-                matches = [x[1] for x in self._items
-                           if x[0] == revision and x[1] in ('yes', 'no')]
+                matches = [
+                    x[1]
+                    for x in self._items
+                    if x[0] == revision and x[1] in ("yes", "no")
+                ]
                 if not matches:
                     continue
                 if len(matches) > 1:
@@ -185,8 +188,9 @@
     def _set_status(self, revid, status):
         """Set the bisect status for the given revid."""
         if not self.is_done():
-            if status != "done" and revid in [x[0] for x in self._items
-                                              if x[1] in ['yes', 'no']]:
+            if status != "done" and revid in [
+                x[0] for x in self._items if x[1] in ["yes", "no"]
+            ]:
                 raise RuntimeError(f"attempting to add revid {revid} twice")
             self._items.append((revid, status))
 
@@ -201,16 +205,16 @@
             revlog = self._open_for_read()
             for line in revlog:
                 (revid, status) = line.split()
-                self._items.append((revid, status.decode('ascii')))
+                self._items.append((revid, status.decode("ascii")))
 
     def save(self):
         """Save the bisection log."""
-        contents = b''.join(
-            (b"%s %s\n" % (revid, status.encode('ascii')))
-            for (revid, status) in self._items)
+        contents = b"".join(
+            (b"%s %s\n" % (revid, status.encode("ascii")))
+            for (revid, status) in self._items
+        )
         if self._filename:
-            self._controldir.control_transport.put_bytes(
-                self._filename, contents)
+            self._controldir.control_transport.put_bytes(self._filename, contents)
         else:
             sys.stdout.write(contents)
 
@@ -242,9 +246,10 @@
         self._find_range_and_middle()
         # If we've found the "final" revision, check for a
         # merge point.
-        while ((self._middle_revid == self._high_revid or
-                self._middle_revid == self._low_revid) and
-                self.is_merge_point(self._middle_revid)):
+        while (
+            self._middle_revid == self._high_revid
+            or self._middle_revid == self._low_revid
+        ) and self.is_merge_point(self._middle_revid):
             for parent in self.get_parent_revids(self._middle_revid):
                 if parent == self._low_revid:
                     continue
@@ -252,8 +257,10 @@
                     self._find_range_and_middle(parent)
                     break
         self._switch_wc_to_revno(self._middle_revid, outf)
-        if self._middle_revid == self._high_revid or \
-           self._middle_revid == self._low_revid:
+        if (
+            self._middle_revid == self._high_revid
+            or self._middle_revid == self._low_revid
+        ):
             self.set_current("done")
 
 
@@ -307,10 +314,12 @@
            anything else for no
     """
 
-    takes_args = ['subcommand', 'args*']
-    takes_options = [Option('output', short_name='o',
-                            help='Write log to this file.', type=str),
-                     'revision', 'directory']
+    takes_args = ["subcommand", "args*"]
+    takes_options = [
+        Option("output", short_name="o", help="Write log to this file.", type=str),
+        "revision",
+        "directory",
+    ]
 
     def _check(self, controldir):
         """Check preconditions for most operations to work."""
@@ -336,22 +345,19 @@
         bisect_log.save()
         return False
 
-    def run(self, subcommand, args_list, directory='.', revision=None,
-            output=None):
+    def run(self, subcommand, args_list, directory=".", revision=None, output=None):
         """Handle the bisect command."""
         log_fn = None
-        if subcommand in ('yes', 'no', 'move') and revision:
+        if subcommand in ("yes", "no", "move") and revision:
             pass
-        elif subcommand in ('replay', ) and args_list and len(args_list) == 1:
+        elif subcommand in ("replay",) and args_list and len(args_list) == 1:
             log_fn = args_list[0]
-        elif subcommand in ('move', ) and not revision:
-            raise CommandError(
-                "The 'bisect move' command requires a revision.")
-        elif subcommand in ('run', ):
+        elif subcommand in ("move",) and not revision:
+            raise CommandError("The 'bisect move' command requires a revision.")
+        elif subcommand in ("run",):
             run_script = args_list[0]
         elif args_list or revision:
-            raise CommandError(
-                "Improper arguments to bisect " + subcommand)
+            raise CommandError("Improper arguments to bisect " + subcommand)
 
         controldir, _ = ControlDir.open_containing(directory)
 
@@ -373,8 +379,7 @@
         elif subcommand == "run":
             self.run_bisect(controldir, run_script)
         else:
-            raise CommandError(
-                "Unknown bisect command: " + subcommand)
+            raise CommandError("Unknown bisect command: " + subcommand)
 
     def reset(self, controldir):
         """Reset the bisect state to no state."""
@@ -428,6 +433,7 @@
 
     def run_bisect(self, controldir, script):
         import subprocess
+
         note("Starting bisect.")
         self.start(controldir)
         while True:
@@ -436,11 +442,11 @@
                 process.wait()
                 retcode = process.returncode
                 if retcode == 0:
-                    done = self._set_state(controldir, None, 'yes')
+                    done = self._set_state(controldir, None, "yes")
                 elif retcode == 125:
                     break
                 else:
-                    done = self._set_state(controldir, None, 'no')
+                    done = self._set_state(controldir, None, "no")
                 if done:
                     break
             except RuntimeError:

=== modified file 'breezy/bisect_multi.py'
--- breezy/bisect_multi.py	2020-02-18 01:57:45 +0000
+++ breezy/bisect_multi.py	2023-11-07 18:55:36 +0000
@@ -17,8 +17,8 @@
 """Bisection lookup multiple keys."""
 
 __all__ = [
-    'bisect_multi_bytes',
-    ]
+    "bisect_multi_bytes",
+]
 
 
 def bisect_multi_bytes(content_lookup, size, keys):

=== modified file 'breezy/branch.py'
--- breezy/branch.py	2023-11-06 11:30:11 +0000
+++ breezy/branch.py	2023-11-07 18:55:36 +0000
@@ -40,11 +40,11 @@
     from .tag import TagConflict, TagUpdates
 
 
-
 class UnstackableBranchFormat(errors.BzrError):
-
-    _fmt = ("The branch '%(url)s'(%(format)s) is not a stackable format. "
-            "You will need to upgrade the branch to permit branch stacking.")
+    _fmt = (
+        "The branch '%(url)s'(%(format)s) is not a stackable format. "
+        "You will need to upgrade the branch to permit branch stacking."
+    )
 
     def __init__(self, format, url):
         errors.BzrError.__init__(self)
@@ -53,7 +53,6 @@
 
 
 class BindingUnsupported(errors.UnsupportedOperation):
-
     _fmt = "Branch at %(url)s does not support binding."
 
     def __init__(self, branch):
@@ -99,7 +98,7 @@
         self._master_branch_cache = None
         self._merge_sorted_revisions_cache = None
         self._open_hook(possible_transports)
-        hooks = Branch.hooks['open']
+        hooks = Branch.hooks["open"]
         for hook in hooks:
             hook(self)
 
@@ -113,7 +112,7 @@
                 # This fallback is already configured.  This probably only
                 # happens because ControlDir.sprout is a horrible mess.  To
                 # avoid confusing _unstack we don't add this a second time.
-                mutter('duplicate activation of fallback %r on %r', url, self)
+                mutter("duplicate activation of fallback %r on %r", url, self)
                 return
         repo = self._get_fallback_repository(url, possible_transports)
         if repo.has_same_location(self.repository):
@@ -131,8 +130,10 @@
         raise NotImplementedError(self.break_lock)
 
     def _extend_partial_history(
-            self, stop_index: Optional[int] = None,
-            stop_revision: Optional[RevisionID] = None) -> None:
+        self,
+        stop_index: Optional[int] = None,
+        stop_revision: Optional[RevisionID] = None,
+    ) -> None:
         """Extend the partial history to include a given index.
 
         If a stop_index is supplied, stop when that index has been reached.
@@ -149,10 +150,12 @@
         if len(self._partial_revision_history_cache) == 0:
             self._partial_revision_history_cache = [self.last_revision()]
         repository._iter_for_revno(
-            self.repository, self._partial_revision_history_cache,
-            stop_index=stop_index, stop_revision=stop_revision)
-        if self._partial_revision_history_cache[-1] == \
-                _mod_revision.NULL_REVISION:
+            self.repository,
+            self._partial_revision_history_cache,
+            stop_index=stop_index,
+            stop_revision=stop_revision,
+        )
+        if self._partial_revision_history_cache[-1] == _mod_revision.NULL_REVISION:
             self._partial_revision_history_cache.pop()
 
     def _get_check_refs(self):
@@ -161,7 +164,7 @@
         See breezy.check.
         """
         revid = self.last_revision()
-        return [('revision-existence', revid), ('lefthand-distance', revid)]
+        return [("revision-existence", revid), ("lefthand-distance", revid)]
 
     @staticmethod
     def open(base, _unsupported=False, possible_transports=None):
@@ -171,22 +174,24 @@
         Branch.open(URL) -> a Branch instance.
         """
         control = ControlDir.open(
-            base, possible_transports=possible_transports,
-            _unsupported=_unsupported)
+            base, possible_transports=possible_transports, _unsupported=_unsupported
+        )
         return control.open_branch(
-            unsupported=_unsupported,
-            possible_transports=possible_transports)
+            unsupported=_unsupported, possible_transports=possible_transports
+        )
 
     @staticmethod
-    def open_from_transport(transport: Transport, name: Optional[str] = None,
-                            _unsupported: bool = False,
-                            possible_transports=None):
+    def open_from_transport(
+        transport: Transport,
+        name: Optional[str] = None,
+        _unsupported: bool = False,
+        possible_transports=None,
+    ):
         """Open the branch rooted at transport."""
-        control = ControlDir.open_from_transport(
-            transport, _unsupported)
+        control = ControlDir.open_from_transport(transport, _unsupported)
         return control.open_branch(
-            name=name, unsupported=_unsupported,
-            possible_transports=possible_transports)
+            name=name, unsupported=_unsupported, possible_transports=possible_transports
+        )
 
     @staticmethod
     def open_containing(url, possible_transports=None):
@@ -201,8 +206,7 @@
         raised.  If there is one, it is returned, along with the unused portion
         of url.
         """
-        control, relpath = ControlDir.open_containing(
-            url, possible_transports)
+        control, relpath = ControlDir.open_containing(url, possible_transports)
         branch = control.open_branch(possible_transports=possible_transports)
         return (branch, relpath)
 
@@ -275,21 +279,22 @@
             except errors.BzrError as e:
                 # Silently fall back to local implicit nick if the master is
                 # unavailable
-                mutter("Could not connect to bound branch, "
-                       "falling back to local nick.\n " + str(e))
+                mutter(
+                    "Could not connect to bound branch, "
+                    "falling back to local nick.\n " + str(e)
+                )
         return config.get_nickname()
 
     def _set_nick(self, nick):
-        self.get_config().set_user_option('nickname', nick, warn_masked=True)
+        self.get_config().set_user_option("nickname", nick, warn_masked=True)
 
     nick = property(_get_nick, _set_nick)
 
     def is_locked(self):
         raise NotImplementedError(self.is_locked)
 
-    def _lefthand_history(self, revision_id, last_rev=None,
-                          other_branch=None):
-        if debug.debug_flag_enabled('evil'):
+    def _lefthand_history(self, revision_id, last_rev=None, other_branch=None):
+        if debug.debug_flag_enabled("evil"):
             mutter_callsite(4, "_lefthand_history scales with history.")
         # stop_revision must be a descendant of last_revision
         graph = self.repository.get_graph()
@@ -305,8 +310,7 @@
         new_history = []
         check_not_reserved_id = _mod_revision.check_not_reserved_id
         # Do not include ghosts or graph origin in revision_history
-        while (current_rev_id in parents_map
-               and len(parents_map[current_rev_id]) > 0):
+        while current_rev_id in parents_map and len(parents_map[current_rev_id]) > 0:
             check_not_reserved_id(current_rev_id)
             new_history.append(current_rev_id)
             current_rev_id = parents_map[current_rev_id][0]
@@ -368,15 +372,19 @@
             try:
                 return self.get_rev_id(revno[0])
             except errors.RevisionNotPresent as exc:
-                raise errors.GhostRevisionsHaveNoRevno(revno[0], exc.revision_id) from exc
+                raise errors.GhostRevisionsHaveNoRevno(
+                    revno[0], exc.revision_id
+                ) from exc
         revision_id_to_revno = self.get_revision_id_to_revno_map()
-        revision_ids = [revision_id for revision_id, this_revno
-                        in revision_id_to_revno.items()
-                        if revno == this_revno]
+        revision_ids = [
+            revision_id
+            for revision_id, this_revno in revision_id_to_revno.items()
+            if revno == this_revno
+        ]
         if len(revision_ids) == 1:
             return revision_ids[0]
         else:
-            revno_str = '.'.join(map(str, revno))
+            revno_str = ".".join(map(str, revno))
             raise errors.NoSuchRevision(self, revno_str)
 
     def revision_id_to_dotted_revno(self, revision_id):
@@ -416,9 +424,8 @@
         Returns: A dictionary mapping revision_id => dotted revno.
             This dictionary should not be modified by the caller.
         """
-        if debug.debug_flag_enabled('evil'):
-            mutter_callsite(
-                3, "get_revision_id_to_revno_map scales with ancestry.")
+        if debug.debug_flag_enabled("evil"):
+            mutter_callsite(3, "get_revision_id_to_revno_map scales with ancestry.")
         with self.lock_read():
             if self._revision_id_to_revno_cache is not None:
                 mapping = self._revision_id_to_revno_cache
@@ -442,13 +449,18 @@
         Returns: A dictionary mapping revision_id => dotted revno.
         """
         revision_id_to_revno = {
-            rev_id: revno for rev_id, depth, revno, end_of_merge
-            in self.iter_merge_sorted_revisions()}
+            rev_id: revno
+            for rev_id, depth, revno, end_of_merge in self.iter_merge_sorted_revisions()
+        }
         return revision_id_to_revno
 
-    def iter_merge_sorted_revisions(self, start_revision_id=None,
-                                    stop_revision_id=None,
-                                    stop_rule='exclude', direction='reverse'):
+    def iter_merge_sorted_revisions(
+        self,
+        start_revision_id=None,
+        stop_revision_id=None,
+        stop_rule="exclude",
+        direction="reverse",
+    ):
         """Walk the revisions for a branch in merge sorted order.
 
         Merge sorted order is the output from a merge-aware,
@@ -498,26 +510,29 @@
             # start_revision_id.
             if self._merge_sorted_revisions_cache is None:
                 last_revision = self.last_revision()
-                known_graph = self.repository.get_known_graph_ancestry(
-                    [last_revision])
+                known_graph = self.repository.get_known_graph_ancestry([last_revision])
                 self._merge_sorted_revisions_cache = known_graph.merge_sort(
-                    last_revision)
+                    last_revision
+                )
             filtered = self._filter_merge_sorted_revisions(
-                self._merge_sorted_revisions_cache, start_revision_id,
-                stop_revision_id, stop_rule)
+                self._merge_sorted_revisions_cache,
+                start_revision_id,
+                stop_revision_id,
+                stop_rule,
+            )
             # Make sure we don't return revisions that are not part of the
             # start_revision_id ancestry.
             filtered = self._filter_start_non_ancestors(filtered)
-            if direction == 'reverse':
+            if direction == "reverse":
                 return filtered
-            if direction == 'forward':
+            if direction == "forward":
                 return reversed(list(filtered))
             else:
-                raise ValueError(f'invalid direction {direction!r}')
+                raise ValueError(f"invalid direction {direction!r}")
 
-    def _filter_merge_sorted_revisions(self, merge_sorted_revisions,
-                                       start_revision_id, stop_revision_id,
-                                       stop_rule):
+    def _filter_merge_sorted_revisions(
+        self, merge_sorted_revisions, start_revision_id, stop_revision_id, stop_rule
+    ):
         """Iterate over an inclusive range of sorted revisions."""
         rev_iter = iter(merge_sorted_revisions)
         if start_revision_id is not None:
@@ -535,35 +550,32 @@
             # Yield everything
             for node in rev_iter:
                 rev_id = node.key
-                yield (rev_id, node.merge_depth, node.revno,
-                       node.end_of_merge)
-        elif stop_rule == 'exclude':
-            for node in rev_iter:
-                rev_id = node.key
-                if rev_id == stop_revision_id:
-                    return
-                yield (rev_id, node.merge_depth, node.revno,
-                       node.end_of_merge)
-        elif stop_rule == 'include':
-            for node in rev_iter:
-                rev_id = node.key
-                yield (rev_id, node.merge_depth, node.revno,
-                       node.end_of_merge)
-                if rev_id == stop_revision_id:
-                    return
-        elif stop_rule == 'with-merges-without-common-ancestry':
+                yield (rev_id, node.merge_depth, node.revno, node.end_of_merge)
+        elif stop_rule == "exclude":
+            for node in rev_iter:
+                rev_id = node.key
+                if rev_id == stop_revision_id:
+                    return
+                yield (rev_id, node.merge_depth, node.revno, node.end_of_merge)
+        elif stop_rule == "include":
+            for node in rev_iter:
+                rev_id = node.key
+                yield (rev_id, node.merge_depth, node.revno, node.end_of_merge)
+                if rev_id == stop_revision_id:
+                    return
+        elif stop_rule == "with-merges-without-common-ancestry":
             # We want to exclude all revisions that are already part of the
             # stop_revision_id ancestry.
             graph = self.repository.get_graph()
-            ancestors = graph.find_unique_ancestors(start_revision_id,
-                                                    [stop_revision_id])
+            ancestors = graph.find_unique_ancestors(
+                start_revision_id, [stop_revision_id]
+            )
             for node in rev_iter:
                 rev_id = node.key
                 if rev_id not in ancestors:
                     continue
-                yield (rev_id, node.merge_depth, node.revno,
-                       node.end_of_merge)
-        elif stop_rule == 'with-merges':
+                yield (rev_id, node.merge_depth, node.revno, node.end_of_merge)
+        elif stop_rule == "with-merges":
             stop_rev = self.repository.get_revision(stop_revision_id)
             if stop_rev.parent_ids:
                 left_parent = stop_rev.parent_ids[0]
@@ -578,10 +590,8 @@
                 if rev_id == left_parent:
                     # reached the left parent after the stop_revision
                     return
-                if (not reached_stop_revision_id
-                        or rev_id in revision_id_whitelist):
-                    yield (rev_id, node.merge_depth, node.revno,
-                           node.end_of_merge)
+                if not reached_stop_revision_id or rev_id in revision_id_whitelist:
+                    yield (rev_id, node.merge_depth, node.revno, node.end_of_merge)
                     if reached_stop_revision_id or rev_id == stop_revision_id:
                         # only do the merged revs of rev_id from now on
                         rev = self.repository.get_revision(rev_id)
@@ -589,7 +599,7 @@
                             reached_stop_revision_id = True
                             revision_id_whitelist.extend(rev.parent_ids)
         else:
-            raise ValueError(f'invalid stop_rule {stop_rule!r}')
+            raise ValueError(f"invalid stop_rule {stop_rule!r}")
 
     def _filter_start_non_ancestors(self, rev_iter):
         # If we started from a dotted revno, we want to consider it as a tip
@@ -621,7 +631,7 @@
             # called in that case. -- vila 20100322
             return
 
-        for (rev_id, merge_depth, revno, end_of_merge) in rev_iter:
+        for rev_id, merge_depth, revno, end_of_merge in rev_iter:
             if not clean:
                 if rev_id in whitelist:
                     pmap = self.repository.get_parent_map([rev_id])
@@ -668,12 +678,12 @@
         """Whether it is only possible to append revisions to the history."""
         if not self._format.supports_set_append_revisions_only():
             return False
-        return self.get_config_stack().get('append_revisions_only')
+        return self.get_config_stack().get("append_revisions_only")
 
     def set_append_revisions_only(self, enabled: bool) -> None:
         if not self._format.supports_set_append_revisions_only():
             raise errors.UpgradeRequired(self.user_url)
-        self.get_config_stack().set('append_revisions_only', enabled)
+        self.get_config_stack().set("append_revisions_only", enabled)
 
     def fetch(self, from_branch, stop_revision=None, limit=None, lossy=False):
         """Copy revisions from from_branch into this branch.
@@ -688,7 +698,8 @@
         """
         with self.lock_write():
             return InterBranch.get(from_branch, self).fetch(
-                stop_revision, limit=limit, lossy=lossy)
+                stop_revision, limit=limit, lossy=lossy
+            )
 
     def get_bound_location(self) -> Optional[str]:
         """Return the URL of the branch we are bound to.
@@ -702,9 +713,17 @@
         """Return the URL of the branch we used to be bound to."""
         raise errors.UpgradeRequired(self.user_url)
 
-    def get_commit_builder(self, parents, config_stack=None, timestamp=None,
-                           timezone=None, committer=None, revprops=None,
-                           revision_id=None, lossy=False):
+    def get_commit_builder(
+        self,
+        parents,
+        config_stack=None,
+        timestamp=None,
+        timezone=None,
+        committer=None,
+        revprops=None,
+        revision_id=None,
+        lossy=False,
+    ):
         """Obtain a CommitBuilder for this branch.
 
         Args:
@@ -723,12 +742,20 @@
             config_stack = self.get_config_stack()
 
         return self.repository.get_commit_builder(
-            self, parents, config_stack, timestamp, timezone, committer,
-            revprops, revision_id, lossy)
+            self,
+            parents,
+            config_stack,
+            timestamp,
+            timezone,
+            committer,
+            revprops,
+            revision_id,
+            lossy,
+        )
 
     def get_master_branch(
-            self, possible_transports: Optional[List[Transport]] = None
-            ) -> Optional["Branch"]:
+        self, possible_transports: Optional[List[Transport]] = None
+    ) -> Optional["Branch"]:
         """Return the branch we are bound to.
 
         Returns: Either a Branch, or None
@@ -746,7 +773,8 @@
         raise NotImplementedError(self.get_stacked_on_url)
 
     def set_last_revision_info(
-            self, revno: Optional[int], revision_id: RevisionID) -> None:
+        self, revno: Optional[int], revision_id: RevisionID
+    ) -> None:
         """Set the last revision of this branch.
 
         The caller is responsible for checking that the revno is correct
@@ -759,9 +787,12 @@
         """
         raise NotImplementedError(self.set_last_revision_info)
 
-    def generate_revision_history(self, revision_id: RevisionID,
-                                  last_rev: Optional[RevisionID] = None,
-                                  other_branch: Optional["Branch"] = None) -> None:
+    def generate_revision_history(
+        self,
+        revision_id: RevisionID,
+        last_rev: Optional[RevisionID] = None,
+        other_branch: Optional["Branch"] = None,
+    ) -> None:
         """See Branch.generate_revision_history."""
         with self.lock_write():
             graph = self.repository.get_graph()
@@ -769,13 +800,12 @@
             known_revision_ids = [
                 (last_revid, last_revno),
                 (_mod_revision.NULL_REVISION, 0),
-                ]
+            ]
             if last_rev is not None:
                 if not graph.is_ancestor(last_rev, revision_id):
                     # our previous tip is not merged into stop_revision
                     raise errors.DivergedBranches(self, other_branch)
-            revno = graph.find_distance_to_null(
-                revision_id, known_revision_ids)
+            revno = graph.find_distance_to_null(revision_id, known_revision_ids)
             self.set_last_revision_info(revno, revision_id)
 
     def _set_parent_location(self, url: Optional[str]) -> None:
@@ -790,11 +820,11 @@
         if url is not None:
             if isinstance(url, str):
                 try:
-                    url.encode('ascii')
+                    url.encode("ascii")
                 except UnicodeEncodeError as exc:
                     raise urlutils.InvalidURL(
-                        url, "Urls must be 7-bit ascii, "
-                        "use breezy.urlutils.escape") from exc
+                        url, "Urls must be 7-bit ascii, " "use breezy.urlutils.escape"
+                    ) from exc
             url = urlutils.relative_url(self.base, url)
         with self.lock_write():
             self._set_parent_location(url)
@@ -861,7 +891,7 @@
         raise NotImplementedError(self._gen_revision_history)
 
     def _revision_history(self) -> List[RevisionID]:
-        if debug.debug_flag_enabled('evil'):
+        if debug.debug_flag_enabled("evil"):
             mutter_callsite(3, "revision_history scales with history.")
         if self._revision_history_cache is not None:
             history = self._revision_history_cache
@@ -893,15 +923,13 @@
         """
         with self.lock_read():
             if self._last_revision_info_cache is None:
-                self._last_revision_info_cache = (
-                    self._read_last_revision_info())
+                self._last_revision_info_cache = self._read_last_revision_info()
             return self._last_revision_info_cache
 
     def _read_last_revision_info(self):
         raise NotImplementedError(self._read_last_revision_info)
 
-    def import_last_revision_info_and_tags(self, source, revno, revid,
-                                           *, lossy=False):
+    def import_last_revision_info_and_tags(self, source, revno, revid, *, lossy=False):
         """Set the last revision info, importing from another repo if necessary.
 
         This is used by the bound branch code to upload a revision to
@@ -932,7 +960,9 @@
         except ValueError as exc:
             raise errors.NoSuchRevision(self, revision_id) from exc
 
-    def get_rev_id(self, revno: int, history: Optional[List[RevisionID]] = None) -> RevisionID:
+    def get_rev_id(
+        self, revno: int, history: Optional[List[RevisionID]] = None
+    ) -> RevisionID:
         """Find the revision id of the specified revno."""
         with self.lock_read():
             if revno == 0:
@@ -947,10 +977,15 @@
                 self._extend_partial_history(distance_from_last)
             return self._partial_revision_history_cache[distance_from_last]
 
-    def pull(self, source: "Branch", *, overwrite: bool = False,
-             stop_revision: Optional[RevisionID] = None,
-             possible_transports: Optional[List[Transport]] = None,
-             **kwargs) -> "PullResult":
+    def pull(
+        self,
+        source: "Branch",
+        *,
+        overwrite: bool = False,
+        stop_revision: Optional[RevisionID] = None,
+        possible_transports: Optional[List[Transport]] = None,
+        **kwargs,
+    ) -> "PullResult":
         """Mirror source into this branch.
 
         This branch is considered to be 'local', having low latency.
@@ -958,18 +993,28 @@
         Returns: PullResult instance
         """
         return InterBranch.get(source, self).pull(
-            overwrite=overwrite, stop_revision=stop_revision,
-            possible_transports=possible_transports, **kwargs)
+            overwrite=overwrite,
+            stop_revision=stop_revision,
+            possible_transports=possible_transports,
+            **kwargs,
+        )
 
-    def push(self, target: "Branch", *, overwrite: bool = False,
-             stop_revision: Optional[RevisionID] = None, lossy: bool = False,
-             **kwargs):
+    def push(
+        self,
+        target: "Branch",
+        *,
+        overwrite: bool = False,
+        stop_revision: Optional[RevisionID] = None,
+        lossy: bool = False,
+        **kwargs,
+    ):
         """Mirror this branch into target.
 
         This branch is considered to be 'local', having low latency.
         """
         return InterBranch.get(self, target).push(
-            overwrite, stop_revision, lossy, **kwargs)
+            overwrite, stop_revision, lossy, **kwargs
+        )
 
     def basis_tree(self):
         """Return `Tree` object for last revision."""
@@ -987,7 +1032,7 @@
             return parent
         # This is an old-format absolute path to a local branch
         # turn it into a url
-        if parent.startswith('/'):
+        if parent.startswith("/"):
             parent = urlutils.local_path_to_url(parent)
         try:
             return urlutils.join(self.base[:-1], parent)
@@ -997,12 +1042,11 @@
     def _get_parent_location(self):
         raise NotImplementedError(self._get_parent_location)
 
-    def _set_config_location(self, name, url, *, config=None,
-                             make_relative=False):
+    def _set_config_location(self, name, url, *, config=None, make_relative=False):
         if config is None:
             config = self.get_config_stack()
         if url is None:
-            url = ''
+            url = ""
         elif make_relative:
             url = urlutils.relative_url(self.base, url)
         config.set(name, url)
@@ -1011,13 +1055,13 @@
         if config is None:
             config = self.get_config_stack()
         location = config.get(name)
-        if location == '':
+        if location == "":
             location = None
         return cast(Optional[str], location)
 
     def get_child_submit_format(self) -> Optional[str]:
         """Return the preferred format of submissions to this branch."""
-        return cast(Optional[str], self.get_config_stack().get('child_submit_format'))
+        return cast(Optional[str], self.get_config_stack().get("child_submit_format"))
 
     def get_submit_branch(self) -> Optional[str]:
         """Return the submit location of the branch.
@@ -1026,7 +1070,7 @@
         pattern is that the user can override it by specifying a
         location.
         """
-        return cast(Optional[str], self.get_config_stack().get('submit_branch'))
+        return cast(Optional[str], self.get_config_stack().get("submit_branch"))
 
     def set_submit_branch(self, location: str) -> None:
         """Return the submit location of the branch.
@@ -1035,14 +1079,14 @@
         pattern is that the user can override it by specifying a
         location.
         """
-        self.get_config_stack().set('submit_branch', location)
+        self.get_config_stack().set("submit_branch", location)
 
     def get_public_branch(self) -> Optional[str]:
         """Return the public location of the branch.
 
         This is used by merge directives.
         """
-        return self._get_config_location('public_branch')
+        return self._get_config_location("public_branch")
 
     def set_public_branch(self, location: str) -> None:
         """Return the submit location of the branch.
@@ -1051,11 +1095,11 @@
         pattern is that the user can override it by specifying a
         location.
         """
-        self._set_config_location('public_branch', location)
+        self._set_config_location("public_branch", location)
 
     def get_push_location(self) -> Optional[str]:
         """Return None or the location to push this branch to."""
-        return cast(str, self.get_config_stack().get('push_location'))
+        return cast(str, self.get_config_stack().get("push_location"))
 
     def set_push_location(self, location: str) -> None:
         """Set a new push location for this branch."""
@@ -1063,23 +1107,21 @@
 
     def _run_post_change_branch_tip_hooks(self, old_revno, old_revid):
         """Run the post_change_branch_tip hooks."""
-        hooks = Branch.hooks['post_change_branch_tip']
+        hooks = Branch.hooks["post_change_branch_tip"]
         if not hooks:
             return
         new_revno, new_revid = self.last_revision_info()
-        params = ChangeBranchTipParams(
-            self, old_revno, new_revno, old_revid, new_revid)
+        params = ChangeBranchTipParams(self, old_revno, new_revno, old_revid, new_revid)
         for hook in hooks:
             hook(params)
 
     def _run_pre_change_branch_tip_hooks(self, new_revno, new_revid):
         """Run the pre_change_branch_tip hooks."""
-        hooks = Branch.hooks['pre_change_branch_tip']
+        hooks = Branch.hooks["pre_change_branch_tip"]
         if not hooks:
             return
         old_revno, old_revid = self.last_revision_info()
-        params = ChangeBranchTipParams(
-            self, old_revno, new_revno, old_revid, new_revid)
+        params = ChangeBranchTipParams(self, old_revno, new_revno, old_revid, new_revid)
         for hook in hooks:
             hook(params)
 
@@ -1106,9 +1148,15 @@
         if revno < 1 or revno > self.revno():
             raise errors.InvalidRevisionNumber(revno)
 
-    def clone(self, to_controldir: ControlDir, *,
-              revision_id: Optional[RevisionID] = None, name: Optional[str] = None,
-              repository_policy=None, tag_selector=None) -> "Branch":
+    def clone(
+        self,
+        to_controldir: ControlDir,
+        *,
+        revision_id: Optional[RevisionID] = None,
+        name: Optional[str] = None,
+        repository_policy=None,
+        tag_selector=None,
+    ) -> "Branch":
         """Clone this branch into to_controldir preserving all semantic values.
 
         Most API users will want 'create_clone_on_transport', which creates a
@@ -1122,12 +1170,21 @@
             if repository_policy is not None:
                 repository_policy.configure_branch(result)
             self.copy_content_into(
-                result, revision_id=revision_id, tag_selector=tag_selector)
+                result, revision_id=revision_id, tag_selector=tag_selector
+            )
         return result
 
-    def sprout(self, to_controldir, *, revision_id=None, repository_policy=None,
-               repository=None, lossy=False, tag_selector=None,
-               name=None):
+    def sprout(
+        self,
+        to_controldir,
+        *,
+        revision_id=None,
+        repository_policy=None,
+        repository=None,
+        lossy=False,
+        tag_selector=None,
+        name=None,
+    ):
         """Create a new line of development from the branch, into to_controldir.
 
         to_controldir controls the branch format.
@@ -1135,8 +1192,7 @@
         revision_id: if not None, the revision history in the new branch will
                      be truncated to end with revision_id.
         """
-        if (repository_policy is not None
-                and repository_policy.requires_stacking()):
+        if repository_policy is not None and repository_policy.requires_stacking():
             to_controldir._format.require_stacking(_skip_repo=True)
         result = to_controldir.create_branch(repository=repository, name=name)
         if lossy:
@@ -1145,7 +1201,8 @@
             if repository_policy is not None:
                 repository_policy.configure_branch(result)
             self.copy_content_into(
-                result, revision_id=revision_id, tag_selector=tag_selector)
+                result, revision_id=revision_id, tag_selector=tag_selector
+            )
             master_url = self.get_bound_location()
             if master_url is None:
                 result.set_parent(self.user_url)
@@ -1173,7 +1230,8 @@
             graph = self.repository.get_graph()
             try:
                 revno = graph.find_distance_to_null(
-                    revision_id, [(source_revision_id, source_revno)])
+                    revision_id, [(source_revision_id, source_revno)]
+                )
             except errors.GhostRevisionsHaveNoRevno:
                 # Default to 1, if we can't find anything else
                 revno = 1
@@ -1188,7 +1246,8 @@
             and should return a boolean to indicate whether a tag should be copied
         """
         return InterBranch.get(self, destination).copy_content_into(
-            revision_id=revision_id, tag_selector=tag_selector)
+            revision_id=revision_id, tag_selector=tag_selector
+        )
 
     def update_references(self, target):
         if not self._format.supports_reference_locations:
@@ -1212,10 +1271,13 @@
         with self.lock_read():
             result = BranchCheckResult(self)
             last_revno, last_revision_id = self.last_revision_info()
-            actual_revno = refs[('lefthand-distance', last_revision_id)]
+            actual_revno = refs[("lefthand-distance", last_revision_id)]
             if actual_revno != last_revno:
-                result.errors.append(errors.BzrCheckError(
-                    f'revno does not match len(mainline) {last_revno} != {actual_revno}'))
+                result.errors.append(
+                    errors.BzrCheckError(
+                        f"revno does not match len(mainline) {last_revno} != {actual_revno}"
+                    )
+                )
             # TODO: We should probably also check that self.revision_history
             # matches the repository for older branch formats.
             # If looking for the code that cross-checks repository parents
@@ -1231,10 +1293,17 @@
         format.set_branch_format(self._format)
         return format
 
-    def create_clone_on_transport(self, to_transport, *, revision_id=None,
-                                  stacked_on=None, create_prefix=False,
-                                  use_existing_dir=False, no_tree=None,
-                                  tag_selector=None):
+    def create_clone_on_transport(
+        self,
+        to_transport,
+        *,
+        revision_id=None,
+        stacked_on=None,
+        create_prefix=False,
+        use_existing_dir=False,
+        no_tree=None,
+        tag_selector=None,
+    ):
         """Create a clone of this branch and its bzrdir.
 
         Args:
@@ -1255,14 +1324,26 @@
         if revision_id is None:
             revision_id = self.last_revision()
         dir_to = self.controldir.clone_on_transport(
-            to_transport, revision_id=revision_id, stacked_on=stacked_on,
-            create_prefix=create_prefix, use_existing_dir=use_existing_dir,
-            no_tree=no_tree, tag_selector=tag_selector)
+            to_transport,
+            revision_id=revision_id,
+            stacked_on=stacked_on,
+            create_prefix=create_prefix,
+            use_existing_dir=use_existing_dir,
+            no_tree=no_tree,
+            tag_selector=tag_selector,
+        )
         return dir_to.open_branch()
 
-    def create_checkout(self, to_location, *, revision_id=None,
-                        lightweight=False, accelerator_tree=None,
-                        hardlink=False, recurse_nested=True):
+    def create_checkout(
+        self,
+        to_location,
+        *,
+        revision_id=None,
+        lightweight=False,
+        accelerator_tree=None,
+        hardlink=False,
+        recurse_nested=True,
+    ):
         """Create a checkout of a branch.
 
         Args:
@@ -1294,8 +1375,10 @@
                 pass
             else:
                 raise errors.AlreadyControlDirError(t.base) from exc
-            if (checkout.control_transport.base
-                    == self.controldir.control_transport.base):
+            if (
+                checkout.control_transport.base
+                == self.controldir.control_transport.base
+            ):
                 # When checking out to the same control directory,
                 # always create a lightweight checkout
                 lightweight = True
@@ -1311,21 +1394,24 @@
             # branch tip correctly, and seed it with history.
             checkout_branch.pull(self, stop_revision=revision_id)
             from_branch = None
-        tree = checkout.create_workingtree(revision_id,
-                                           from_branch=from_branch,
-                                           accelerator_tree=accelerator_tree,
-                                           hardlink=hardlink)
+        tree = checkout.create_workingtree(
+            revision_id,
+            from_branch=from_branch,
+            accelerator_tree=accelerator_tree,
+            hardlink=hardlink,
+        )
         basis_tree = tree.basis_tree()
         with basis_tree.lock_read():
             for path in basis_tree.iter_references():
                 reference_parent = tree.reference_parent(path)
                 if reference_parent is None:
-                    warning('Branch location for %s unknown.', path)
+                    warning("Branch location for %s unknown.", path)
                     continue
                 reference_parent.create_checkout(
                     tree.abspath(path),
                     revision_id=basis_tree.get_reference_revision(path),
-                    lightweight=lightweight)
+                    lightweight=lightweight,
+                )
         return tree
 
     def reconcile(self, thorough=True):
@@ -1345,14 +1431,15 @@
           revision_id: Revision id of the revision.
         Returns: A tag name or None if no tag name could be determined.
         """
-        for hook in Branch.hooks['automatic_tag_name']:
+        for hook in Branch.hooks["automatic_tag_name"]:
             ret = hook(self, revision_id)
             if ret is not None:
                 return ret
         return None
 
-    def _check_if_descendant_or_diverged(self, revision_a, revision_b, graph,
-                                         other_branch):
+    def _check_if_descendant_or_diverged(
+        self, revision_a, revision_b, graph, other_branch
+    ):
         """Ensure that revision_b is a descendant of revision_a.
 
         This is a helper function for update_revisions.
@@ -1361,11 +1448,11 @@
         Returns: True if revision_b is a descendant of revision_a.
         """
         relation = self._revision_relations(revision_a, revision_b, graph)
-        if relation == 'b_descends_from_a':
+        if relation == "b_descends_from_a":
             return True
-        elif relation == 'diverged':
+        elif relation == "diverged":
             raise errors.DivergedBranches(self, other_branch)
-        elif relation == 'a_descends_from_b':
+        elif relation == "a_descends_from_b":
             return False
         else:
             raise AssertionError(f"invalid relation: {relation!r}")
@@ -1377,12 +1464,12 @@
         """
         heads = graph.heads([revision_a, revision_b])
         if heads == {revision_b}:
-            return 'b_descends_from_a'
+            return "b_descends_from_a"
         elif heads == {revision_a, revision_b}:
             # These branches have diverged
-            return 'diverged'
+            return "diverged"
         elif heads == {revision_a}:
-            return 'a_descends_from_b'
+            return "a_descends_from_b"
         else:
             raise AssertionError(f"invalid heads: {heads!r}")
 
@@ -1399,7 +1486,7 @@
         # if_present_fetch are the tags.
         must_fetch = {self.last_revision()}
         if_present_fetch = set()
-        if self.get_config_stack().get('branch.fetch_tags'):
+        if self.get_config_stack().get("branch.fetch_tags"):
             try:
                 if_present_fetch = set(self.tags.get_reverse_tag_dict())
             except errors.TagsNotSupported:
@@ -1414,6 +1501,7 @@
         Returns: An in-memory MutableTree instance
         """
         from . import memorytree
+
         return memorytree.MemoryTree.create_on_branch(self)
 
 
@@ -1475,15 +1563,16 @@
         raise NotImplementedError(self.get_format_description)
 
     def _run_post_branch_init_hooks(self, controldir, name, branch):
-        hooks = Branch.hooks['post_branch_init']
+        hooks = Branch.hooks["post_branch_init"]
         if not hooks:
             return
         params = BranchInitHookParams(self, controldir, name, branch)
         for hook in hooks:
             hook(params)
 
-    def initialize(self, controldir, name=None, repository=None,
-                   append_revisions_only=None):
+    def initialize(
+        self, controldir, name=None, repository=None, append_revisions_only=None
+    ):
         """Create a branch of this format in controldir.
 
         Args:
@@ -1516,6 +1605,7 @@
         on a RemoteBranch.
         """
         from .tag import DisabledTags
+
         return DisabledTags(branch)
 
     def network_name(self):
@@ -1528,8 +1618,15 @@
         """
         raise NotImplementedError(self.network_name)
 
-    def open(self, controldir, name=None, _found=False, ignore_fallbacks=False,
-             found_repository=None, possible_transports=None):
+    def open(
+        self,
+        controldir,
+        name=None,
+        _found=False,
+        ignore_fallbacks=False,
+        found_repository=None,
+        possible_transports=None,
+    ):
         """Return the branch object for controldir.
 
         Args:
@@ -1595,21 +1692,27 @@
         """
         Hooks.__init__(self, "breezy.branch", "Branch.hooks")
         self.add_hook(
-            'open',
+            "open",
             "Called with the Branch object that has been opened after a "
-            "branch is opened.", (1, 8))
+            "branch is opened.",
+            (1, 8),
+        )
         self.add_hook(
-            'post_push',
+            "post_push",
             "Called after a push operation completes. post_push is called "
             "with a breezy.branch.BranchPushResult object and only runs in "
-            "the bzr client.", (0, 15))
+            "the bzr client.",
+            (0, 15),
+        )
         self.add_hook(
-            'post_pull',
+            "post_pull",
             "Called after a pull operation completes. post_pull is called "
             "with a breezy.branch.PullResult object and only runs in the "
-            "bzr client.", (0, 15))
+            "bzr client.",
+            (0, 15),
+        )
         self.add_hook(
-            'pre_commit',
+            "pre_commit",
             "Called after a commit is calculated but before it is "
             "completed. pre_commit is called with (local, master, old_revno, "
             "old_revid, future_revno, future_revid, tree_delta, future_tree"
@@ -1618,34 +1721,44 @@
             "basis revision. hooks MUST NOT modify this delta. "
             " future_tree is an in-memory tree obtained from "
             "CommitBuilder.revision_tree() and hooks MUST NOT modify this "
-            "tree.", (0, 91))
+            "tree.",
+            (0, 91),
+        )
         self.add_hook(
-            'post_commit',
+            "post_commit",
             "Called in the bzr client after a commit has completed. "
             "post_commit is called with (local, master, old_revno, old_revid, "
             "new_revno, new_revid). old_revid is NULL_REVISION for the first "
-            "commit to a branch.", (0, 15))
+            "commit to a branch.",
+            (0, 15),
+        )
         self.add_hook(
-            'post_uncommit',
+            "post_uncommit",
             "Called in the bzr client after an uncommit completes. "
             "post_uncommit is called with (local, master, old_revno, "
             "old_revid, new_revno, new_revid) where local is the local branch "
             "or None, master is the target branch, and an empty branch "
-            "receives new_revno of 0, new_revid of None.", (0, 15))
+            "receives new_revno of 0, new_revid of None.",
+            (0, 15),
+        )
         self.add_hook(
-            'pre_change_branch_tip',
+            "pre_change_branch_tip",
             "Called in bzr client and server before a change to the tip of a "
             "branch is made. pre_change_branch_tip is called with a "
             "breezy.branch.ChangeBranchTipParams. Note that push, pull, "
-            "commit, uncommit will all trigger this hook.", (1, 6))
+            "commit, uncommit will all trigger this hook.",
+            (1, 6),
+        )
         self.add_hook(
-            'post_change_branch_tip',
+            "post_change_branch_tip",
             "Called in bzr client and server after a change to the tip of a "
             "branch is made. post_change_branch_tip is called with a "
             "breezy.branch.ChangeBranchTipParams. Note that push, pull, "
-            "commit, uncommit will all trigger this hook.", (1, 4))
+            "commit, uncommit will all trigger this hook.",
+            (1, 4),
+        )
         self.add_hook(
-            'transform_fallback_location',
+            "transform_fallback_location",
             "Called when a stacked branch is activating its fallback "
             "locations. transform_fallback_location is called with (branch, "
             "url), and should return a new url. Returning the same url "
@@ -1656,26 +1769,33 @@
             "fallback locations have not been activated. When there are "
             "multiple hooks installed for transform_fallback_location, "
             "all are called with the url returned from the previous hook."
-            "The order is however undefined.", (1, 9))
+            "The order is however undefined.",
+            (1, 9),
+        )
         self.add_hook(
-            'automatic_tag_name',
+            "automatic_tag_name",
             "Called to determine an automatic tag name for a revision. "
             "automatic_tag_name is called with (branch, revision_id) and "
             "should return a tag name or None if no tag name could be "
             "determined. The first non-None tag name returned will be used.",
-            (2, 2))
+            (2, 2),
+        )
         self.add_hook(
-            'post_branch_init',
+            "post_branch_init",
             "Called after new branch initialization completes. "
             "post_branch_init is called with a "
             "breezy.branch.BranchInitHookParams. "
             "Note that init, branch and checkout (both heavyweight and "
-            "lightweight) will all trigger this hook.", (2, 2))
+            "lightweight) will all trigger this hook.",
+            (2, 2),
+        )
         self.add_hook(
-            'post_switch',
+            "post_switch",
             "Called after a checkout switches branch. "
             "post_switch is called with a "
-            "breezy.branch.SwitchHookParams.", (2, 2))
+            "breezy.branch.SwitchHookParams.",
+            (2, 2),
+        )
 
 
 # install the default hooks into the Branch class.
@@ -1718,8 +1838,13 @@
 
     def __repr__(self):
         return "<{} of {} from ({}, {}) to ({}, {})>".format(
-            self.__class__.__name__, self.branch,
-            self.old_revno, self.old_revid, self.new_revno, self.new_revid)
+            self.__class__.__name__,
+            self.branch,
+            self.old_revno,
+            self.old_revid,
+            self.new_revno,
+            self.new_revid,
+        )
 
 
 class BranchInitHookParams:
@@ -1795,8 +1920,8 @@
 
     def __repr__(self):
         return "<{} for {} to ({}, {})>".format(
-            self.__class__.__name__, self.control_dir, self.to_branch,
-            self.revision_id)
+            self.__class__.__name__, self.control_dir, self.to_branch, self.revision_id
+        )
 
 
 class BranchFormatRegistry(ControlComponentFormatRegistry):
@@ -1809,8 +1934,7 @@
 
     def get_default(self):
         """Return the current default format."""
-        if (self._default_format_key is not None
-                and self._default_format is None):
+        if self._default_format_key is not None and self._default_format is None:
             self._default_format = self.get(self._default_format_key)
         return self._default_format
 
@@ -1854,13 +1978,12 @@
 
 
 class _Result:
-
     def _show_tag_conficts(self, to_file):
-        if not getattr(self, 'tag_conflicts', None):
+        if not getattr(self, "tag_conflicts", None):
             return
-        to_file.write('Conflicting tags:\n')
+        to_file.write("Conflicting tags:\n")
         for name, _value1, _value2 in self.tag_conflicts:
-            to_file.write(f'    {name}\n')
+            to_file.write(f"    {name}\n")
 
 
 class PullResult(_Result):
@@ -1896,14 +2019,14 @@
         tag_updates = getattr(self, "tag_updates", None)
         if not is_quiet():
             if self.old_revid != self.new_revid:
-                to_file.write('Now on revision %d.\n' % self.new_revno)
+                to_file.write("Now on revision %d.\n" % self.new_revno)
             if tag_updates:
-                to_file.write(f'{len(tag_updates)} tag(s) updated.\n')
+                to_file.write(f"{len(tag_updates)} tag(s) updated.\n")
             if self.old_revid == self.new_revid and not tag_updates:
                 if not tag_conflicts:
-                    to_file.write('No revisions or tags to pull.\n')
+                    to_file.write("No revisions or tags to pull.\n")
                 else:
-                    to_file.write('No revisions to pull.\n')
+                    to_file.write("No revisions to pull.\n")
         self._show_tag_conficts(to_file)
 
 
@@ -1948,19 +2071,22 @@
         if not is_quiet():
             if self.old_revid != self.new_revid:
                 if self.new_revno is not None:
-                    note(gettext('Pushed up to revision %d.'),
-                         self.new_revno)
+                    note(gettext("Pushed up to revision %d."), self.new_revno)
                 else:
-                    note(gettext('Pushed up to revision id %s.'),
-                         self.new_revid.decode('utf-8'))
+                    note(
+                        gettext("Pushed up to revision id %s."),
+                        self.new_revid.decode("utf-8"),
+                    )
             if tag_updates:
-                note(ngettext('%d tag updated.', '%d tags updated.',
-                              len(tag_updates)) % len(tag_updates))
+                note(
+                    ngettext("%d tag updated.", "%d tags updated.", len(tag_updates))
+                    % len(tag_updates)
+                )
             if self.old_revid == self.new_revid and not tag_updates:
                 if not tag_conflicts:
-                    note(gettext('No new revisions or tags to push.'))
+                    note(gettext("No new revisions or tags to push."))
                 else:
-                    note(gettext('No new revisions to push.'))
+                    note(gettext("No new revisions to push."))
         self._show_tag_conficts(to_file)
 
 
@@ -1982,10 +2108,14 @@
             if any.
         """
         from .i18n import gettext
-        note(gettext('checked branch {0} format {1}').format(
-            self.branch.user_url, self.branch._format))
+
+        note(
+            gettext("checked branch {0} format {1}").format(
+                self.branch.user_url, self.branch._format
+            )
+        )
         for error in self.errors:
-            note(gettext('found error:%s'), error)
+            note(gettext("found error:%s"), error)
 
 
 class InterBranch(InterObject[Branch]):
@@ -2009,10 +2139,14 @@
         """
         raise NotImplementedError(klass._get_branch_formats_to_test)
 
-    def pull(self, overwrite: bool = False,
-             stop_revision: Optional[RevisionID] = None,
-             possible_transports: Optional[List[Transport]] = None,
-             local: bool = False, tag_selector=None) -> PullResult:
+    def pull(
+        self,
+        overwrite: bool = False,
+        stop_revision: Optional[RevisionID] = None,
+        possible_transports: Optional[List[Transport]] = None,
+        local: bool = False,
+        tag_selector=None,
+    ) -> PullResult:
         """Mirror source into target branch.
 
         The target branch is considered to be 'local', having low latency.
@@ -2021,9 +2155,14 @@
         """
         raise NotImplementedError(self.pull)
 
-    def push(self, overwrite: bool = False, stop_revision: Optional[RevisionID] = None,
-             lossy: bool = False, _override_hook_source_branch: Optional[Branch] = None,
-             tag_selector=None):
+    def push(
+        self,
+        overwrite: bool = False,
+        stop_revision: Optional[RevisionID] = None,
+        lossy: bool = False,
+        _override_hook_source_branch: Optional[Branch] = None,
+        tag_selector=None,
+    ):
         """Mirror the source branch into the target branch.
 
         The source branch is considered to be 'local', having low latency.
@@ -2042,9 +2181,12 @@
         """
         raise NotImplementedError(self.copy_content_into)
 
-    def fetch(self, stop_revision: Optional[RevisionID] = None,
-              limit: Optional[int] = None,
-              lossy: bool = False) -> repository.FetchResult:
+    def fetch(
+        self,
+        stop_revision: Optional[RevisionID] = None,
+        limit: Optional[int] = None,
+        lossy: bool = False,
+    ) -> repository.FetchResult:
         """Fetch revisions.
 
         Args:
@@ -2088,6 +2230,7 @@
     @classmethod
     def unwrap_format(klass, format):
         from .bzr.remote import RemoteBranchFormat
+
         if isinstance(format, RemoteBranchFormat):
             format._ensure_real()
             return format._custom_format
@@ -2105,7 +2248,7 @@
             try:
                 parent = self.source.get_parent()
             except errors.InaccessibleParent as e:
-                mutter('parent was not accessible to copy: %s', str(e))
+                mutter("parent was not accessible to copy: %s", str(e))
             else:
                 if parent:
                     self.target.set_parent(parent)
@@ -2116,23 +2259,21 @@
         if self.target.base == self.source.base:
             return (0, [])
         from .bzr.fetch import FetchSpecFactory, TargetRepoKinds
+
         with self.source.lock_read(), self.target.lock_write():
             fetch_spec_factory = FetchSpecFactory()
             fetch_spec_factory.source_branch = self.source
             fetch_spec_factory.source_branch_stop_revision_id = stop_revision
             fetch_spec_factory.source_repo = self.source.repository
             fetch_spec_factory.target_repo = self.target.repository
-            fetch_spec_factory.target_repo_kind = (
-                TargetRepoKinds.PREEXISTING)
+            fetch_spec_factory.target_repo_kind = TargetRepoKinds.PREEXISTING
             fetch_spec_factory.limit = limit
             fetch_spec = fetch_spec_factory.make_fetch_spec()
             return self.target.repository.fetch(
-                self.source.repository,
-                lossy=lossy,
-                fetch_spec=fetch_spec)
+                self.source.repository, lossy=lossy, fetch_spec=fetch_spec
+            )
 
-    def _update_revisions(self, stop_revision=None, overwrite=False,
-                          graph=None):
+    def _update_revisions(self, stop_revision=None, overwrite=False, graph=None):
         with self.source.lock_read(), self.target.lock_write():
             other_revno, other_last_revision = self.source.last_revision_info()
             stop_revno = None  # unknown
@@ -2156,24 +2297,34 @@
                 if graph is None:
                     graph = self.target.repository.get_graph()
                 if self.target._check_if_descendant_or_diverged(
-                        stop_revision, last_rev, graph, self.source):
+                    stop_revision, last_rev, graph, self.source
+                ):
                     # stop_revision is a descendant of last_rev, but we aren't
                     # overwriting, so we're done.
                     return
             if stop_revno is None:
                 if graph is None:
                     graph = self.target.repository.get_graph()
-                this_revno, this_last_revision = \
-                    self.target.last_revision_info()
+                this_revno, this_last_revision = self.target.last_revision_info()
                 stop_revno = graph.find_distance_to_null(
-                    stop_revision, [(other_last_revision, other_revno),
-                                    (this_last_revision, this_revno)])
+                    stop_revision,
+                    [
+                        (other_last_revision, other_revno),
+                        (this_last_revision, this_revno),
+                    ],
+                )
             self.target.set_last_revision_info(stop_revno, stop_revision)
 
-    def pull(self, overwrite=False, stop_revision=None,
-             possible_transports=None, run_hooks=True,
-             _override_hook_target=None, local=False,
-             tag_selector=None):
+    def pull(
+        self,
+        overwrite=False,
+        stop_revision=None,
+        possible_transports=None,
+        run_hooks=True,
+        _override_hook_target=None,
+        local=False,
+        tag_selector=None,
+    ):
         """Pull from source into self, updating my master if any.
 
         Args:
@@ -2194,29 +2345,40 @@
                 normalized = urlutils.normalize_url(bound_location)
                 try:
                     relpath = self.source.user_transport.relpath(normalized)
-                    source_is_master = (relpath == '')
+                    source_is_master = relpath == ""
                 except (errors.PathNotChild, urlutils.InvalidURL):
                     source_is_master = False
             if not local and bound_location and not source_is_master:
                 # not pulling from master, so we need to update master.
-                master_branch = self.target.get_master_branch(
-                    possible_transports)
+                master_branch = self.target.get_master_branch(possible_transports)
                 exit_stack.enter_context(master_branch.lock_write())
             if master_branch:
                 # pull from source into master.
                 master_branch.pull(
-                    self.source, overwrite=overwrite, stop_revision=stop_revision,
+                    self.source,
+                    overwrite=overwrite,
+                    stop_revision=stop_revision,
                     run_hooks=False,
-                    tag_selector=tag_selector)
+                    tag_selector=tag_selector,
+                )
             return self._pull(
-                overwrite, stop_revision, _hook_master=master_branch,
+                overwrite,
+                stop_revision,
+                _hook_master=master_branch,
                 run_hooks=run_hooks,
                 _override_hook_target=_override_hook_target,
                 merge_tags_to_master=not source_is_master,
-                tag_selector=tag_selector)
+                tag_selector=tag_selector,
+            )
 
-    def push(self, overwrite=False, stop_revision=None, lossy=False,
-             _override_hook_source_branch=None, tag_selector=None):
+    def push(
+        self,
+        overwrite=False,
+        stop_revision=None,
+        lossy=False,
+        _override_hook_source_branch=None,
+        tag_selector=None,
+    ):
         """See InterBranch.push.
 
         This is the basic concrete implementation of push()
@@ -2235,7 +2397,7 @@
         def _run_hooks():
             if _override_hook_source_branch:
                 result.source_branch = _override_hook_source_branch
-            for hook in Branch.hooks['post_push']:
+            for hook in Branch.hooks["post_push"]:
                 hook(result)
 
         with self.source.lock_read(), self.target.lock_write():
@@ -2250,12 +2412,14 @@
                     # push into the master from the source branch.
                     master_inter = InterBranch.get(self.source, master_branch)
                     master_inter._basic_push(
-                        overwrite, stop_revision, tag_selector=tag_selector)
+                        overwrite, stop_revision, tag_selector=tag_selector
+                    )
                     # and push into the target branch from the source. Note
                     # that we push from the source branch again, because it's
                     # considered the highest bandwidth repository.
                     result = self._basic_push(
-                        overwrite, stop_revision, tag_selector=tag_selector)
+                        overwrite, stop_revision, tag_selector=tag_selector
+                    )
                     result.master_branch = master_branch
                     result.local_branch = self.target
                     _run_hooks()
@@ -2263,7 +2427,8 @@
                 master_branch = None
                 # no master branch
                 result = self._basic_push(
-                    overwrite, stop_revision, tag_selector=tag_selector)
+                    overwrite, stop_revision, tag_selector=tag_selector
+                )
                 # TODO: Why set master_branch and local_branch if there's no
                 # binding?  Maybe cleaner to just leave them unset? -- mbp
                 # 20070504
@@ -2287,19 +2452,28 @@
             # the target.
             graph = self.source.repository.get_graph(self.target.repository)
             self._update_revisions(
-                stop_revision, overwrite=("history" in overwrite), graph=graph)
+                stop_revision, overwrite=("history" in overwrite), graph=graph
+            )
         if self.source._push_should_merge_tags():
-            result.tag_updates, result.tag_conflicts = (
-                self.source.tags.merge_to(
-                    self.target.tags, "tags" in overwrite, selector=tag_selector))
+            result.tag_updates, result.tag_conflicts = self.source.tags.merge_to(
+                self.target.tags, "tags" in overwrite, selector=tag_selector
+            )
         self.update_references()
         result.new_revno, result.new_revid = self.target.last_revision_info()
         return result
 
-    def _pull(self, overwrite=False, stop_revision=None,
-              possible_transports=None, _hook_master=None, run_hooks=True,
-              _override_hook_target=None, local=False,
-              merge_tags_to_master=True, tag_selector=None):
+    def _pull(
+        self,
+        overwrite=False,
+        stop_revision=None,
+        possible_transports=None,
+        _hook_master=None,
+        run_hooks=True,
+        _override_hook_target=None,
+        local=False,
+        merge_tags_to_master=True,
+        tag_selector=None,
+    ):
         """See Branch.pull.
 
         This function is the core worker, used by GenericInterBranch.pull to
@@ -2333,22 +2507,22 @@
             # TODO: Branch formats should have a flag that indicates
             # that revno's are expensive, and pull() should honor that flag.
             # -- JRV20090506
-            result.old_revno, result.old_revid = \
-                self.target.last_revision_info()
+            result.old_revno, result.old_revid = self.target.last_revision_info()
             overwrite = _fix_overwrite_type(overwrite)
             self._update_revisions(
-                stop_revision, overwrite=("history" in overwrite), graph=graph)
+                stop_revision, overwrite=("history" in overwrite), graph=graph
+            )
             # TODO: The old revid should be specified when merging tags,
             # so a tags implementation that versions tags can only
             # pull in the most recent changes. -- JRV20090506
-            result.tag_updates, result.tag_conflicts = (
-                self.source.tags.merge_to(
-                    self.target.tags, "tags" in overwrite,
-                    ignore_master=not merge_tags_to_master,
-                    selector=tag_selector))
+            result.tag_updates, result.tag_conflicts = self.source.tags.merge_to(
+                self.target.tags,
+                "tags" in overwrite,
+                ignore_master=not merge_tags_to_master,
+                selector=tag_selector,
+            )
             self.update_references()
-            result.new_revno, result.new_revid = (
-                self.target.last_revision_info())
+            result.new_revno, result.new_revid = self.target.last_revision_info()
             if _hook_master:
                 result.master_branch = _hook_master
                 result.local_branch = result.target_branch
@@ -2356,12 +2530,12 @@
                 result.master_branch = result.target_branch
                 result.local_branch = None
             if run_hooks:
-                for hook in Branch.hooks['post_pull']:
+                for hook in Branch.hooks["post_pull"]:
                     hook(result)
             return result
 
     def update_references(self):
-        if not getattr(self.source._format, 'supports_reference_locations', False):
+        if not getattr(self.source._format, "supports_reference_locations", False):
             return
         reference_dict = self.source._get_all_reference_info()
         if len(reference_dict) == 0:
@@ -2371,13 +2545,13 @@
         target_reference_dict = self.target._get_all_reference_info()
         for tree_path, (branch_location, file_id) in reference_dict.items():
             try:
-                branch_location = urlutils.rebase_url(branch_location,
-                                                      old_base, new_base)
+                branch_location = urlutils.rebase_url(
+                    branch_location, old_base, new_base
+                )
             except urlutils.InvalidRebaseURLs:
                 # Fall back to absolute URL
                 branch_location = urlutils.join(old_base, branch_location)
-            target_reference_dict.setdefault(
-                tree_path, (branch_location, file_id))
+            target_reference_dict.setdefault(tree_path, (branch_location, file_id))
         self.target._set_all_reference_info(target_reference_dict)
 
 

=== modified file 'breezy/branchbuilder.py'
--- breezy/branchbuilder.py	2023-05-03 17:01:16 +0000
+++ breezy/branchbuilder.py	2023-11-07 18:55:36 +0000
@@ -66,25 +66,27 @@
         """
         if branch is not None:
             if format is not None:
-                raise AssertionError(
-                    "branch and format kwargs are mutually exclusive")
+                raise AssertionError("branch and format kwargs are mutually exclusive")
             if transport is not None:
                 raise AssertionError(
-                    "branch and transport kwargs are mutually exclusive")
+                    "branch and transport kwargs are mutually exclusive"
+                )
             self._branch = branch
         else:
-            if not transport.has('.'):
-                transport.mkdir('.')
+            if not transport.has("."):
+                transport.mkdir(".")
             if format is None:
-                format = 'default'
+                format = "default"
             if isinstance(format, str):
                 format = controldir.format_registry.make_controldir(format)
             self._branch = controldir.ControlDir.create_branch_convenience(
-                transport.base, format=format, force_new_tree=False)
+                transport.base, format=format, force_new_tree=False
+            )
         self._tree = None
 
-    def build_commit(self, parent_ids=None, allow_leftmost_as_ghost=False,
-                     **commit_kwargs):
+    def build_commit(
+        self, parent_ids=None, allow_leftmost_as_ghost=False, **commit_kwargs
+    ):
         """Build a commit on the branch.
 
         This makes a commit with no real file content for when you only want
@@ -100,25 +102,26 @@
                 base_id = parent_ids[0]
             if base_id != self._branch.last_revision():
                 self._move_branch_pointer(
-                    base_id, allow_leftmost_as_ghost=allow_leftmost_as_ghost)
+                    base_id, allow_leftmost_as_ghost=allow_leftmost_as_ghost
+                )
         tree = self._branch.create_memorytree()
         with tree.lock_write():
             if parent_ids is not None:
                 tree.set_parent_ids(
-                    parent_ids,
-                    allow_leftmost_as_ghost=allow_leftmost_as_ghost)
-            tree.add('')
+                    parent_ids, allow_leftmost_as_ghost=allow_leftmost_as_ghost
+                )
+            tree.add("")
             return self._do_commit(tree, **commit_kwargs)
 
     def _do_commit(self, tree, message=None, message_callback=None, **kwargs):
         reporter = commit.NullCommitReporter()
         if message is None and message_callback is None:
-            message = 'commit %d' % (self._branch.revno() + 1,)
-        return tree.commit(message, message_callback=message_callback,
-                           reporter=reporter, **kwargs)
+            message = "commit %d" % (self._branch.revno() + 1,)
+        return tree.commit(
+            message, message_callback=message_callback, reporter=reporter, **kwargs
+        )
 
-    def _move_branch_pointer(self, new_revision_id,
-                             allow_leftmost_as_ghost=False):
+    def _move_branch_pointer(self, new_revision_id, allow_leftmost_as_ghost=False):
         """Point self._branch to a different revision id."""
         with self._branch.lock_write():
             # We don't seem to have a simple set_last_revision(), so we
@@ -127,7 +130,8 @@
             try:
                 g = self._branch.repository.get_graph()
                 new_revno = g.find_distance_to_null(
-                    new_revision_id, [(cur_revision_id, cur_revno)])
+                    new_revision_id, [(cur_revision_id, cur_revno)]
+                )
                 self._branch.set_last_revision_info(new_revno, new_revision_id)
             except errors.GhostRevisionsHaveNoRevno:
                 if not allow_leftmost_as_ghost:
@@ -153,8 +157,9 @@
         Make sure to call 'finish_series' when you are done.
         """
         if self._tree is not None:
-            raise AssertionError('You cannot start a new series while a'
-                                 ' series is already going.')
+            raise AssertionError(
+                "You cannot start a new series while a" " series is already going."
+            )
         self._tree = self._branch.create_memorytree()
         self._tree.lock_write()
 
@@ -163,9 +168,18 @@
         self._tree.unlock()
         self._tree = None
 
-    def build_snapshot(self, parent_ids, actions, message=None, timestamp=None,
-                       allow_leftmost_as_ghost=False, committer=None,
-                       timezone=None, message_callback=None, revision_id=None):
+    def build_snapshot(
+        self,
+        parent_ids,
+        actions,
+        message=None,
+        timestamp=None,
+        allow_leftmost_as_ghost=False,
+        committer=None,
+        timezone=None,
+        message_callback=None,
+        revision_id=None,
+    ):
         """Build a commit, shaped in a specific way.
 
         Most of the actions are self-explanatory.  'flush' is special action to
@@ -201,7 +215,8 @@
                 base_id = parent_ids[0]
             if base_id != self._branch.last_revision():
                 self._move_branch_pointer(
-                    base_id, allow_leftmost_as_ghost=allow_leftmost_as_ghost)
+                    base_id, allow_leftmost_as_ghost=allow_leftmost_as_ghost
+                )
 
         if self._tree is not None:
             tree = self._tree
@@ -210,17 +225,17 @@
         with tree.lock_write():
             if parent_ids is not None:
                 tree.set_parent_ids(
-                    parent_ids,
-                    allow_leftmost_as_ghost=allow_leftmost_as_ghost)
+                    parent_ids, allow_leftmost_as_ghost=allow_leftmost_as_ghost
+                )
             # Unfortunately, MemoryTree.add(directory) just creates an
             # inventory entry. And the only public function to create a
             # directory is MemoryTree.mkdir() which creates the directory, but
             # also always adds it. So we have to use a multi-pass setup.
             pending = _PendingActions()
             for action, info in actions:
-                if action == 'add':
+                if action == "add":
                     path, file_id, kind, content = info
-                    if kind == 'directory':
+                    if kind == "directory":
                         pending.to_add_directories.append((path, file_id))
                     else:
                         pending.to_add_files.append(path)
@@ -228,38 +243,42 @@
                         pending.to_add_kinds.append(kind)
                         if content is not None:
                             pending.new_contents[path] = content
-                elif action == 'modify':
+                elif action == "modify":
                     path, content = info
                     pending.new_contents[path] = content
-                elif action == 'unversion':
+                elif action == "unversion":
                     pending.to_unversion_paths.add(info)
-                elif action == 'rename':
+                elif action == "rename":
                     from_relpath, to_relpath = info
                     pending.to_rename.append((from_relpath, to_relpath))
-                elif action == 'flush':
+                elif action == "flush":
                     self._flush_pending(tree, pending)
                     pending = _PendingActions()
                 else:
                     raise ValueError(f'Unknown build action: "{action}"')
             self._flush_pending(tree, pending)
             return self._do_commit(
-                tree, message=message, rev_id=revision_id,
-                timestamp=timestamp, timezone=timezone, committer=committer,
-                message_callback=message_callback)
+                tree,
+                message=message,
+                rev_id=revision_id,
+                timestamp=timestamp,
+                timezone=timezone,
+                committer=committer,
+                message_callback=message_callback,
+            )
 
     def _flush_pending(self, tree, pending):
         """Flush the pending actions in 'pending', i.e. apply them to tree."""
         for path, file_id in pending.to_add_directories:
-            if path == '':
-                if tree.has_filename(path) \
-                        and path in pending.to_unversion_paths:
+            if path == "":
+                if tree.has_filename(path) and path in pending.to_unversion_paths:
                     # We're overwriting this path, no need to unversion
                     pending.to_unversion_paths.discard(path)
                 # Special case, because the path already exists
                 if file_id is not None:
-                    tree.add([path], ['directory'], ids=[file_id])
+                    tree.add([path], ["directory"], ids=[file_id])
                 else:
-                    tree.add([path], ['directory'])
+                    tree.add([path], ["directory"])
             else:
                 if file_id is not None:
                     tree.mkdir(path, file_id)
@@ -270,8 +289,9 @@
         if pending.to_unversion_paths:
             tree.unversion(pending.to_unversion_paths)
         if tree.supports_file_ids:
-            tree.add(pending.to_add_files,
-                     pending.to_add_kinds, pending.to_add_file_ids)
+            tree.add(
+                pending.to_add_files, pending.to_add_kinds, pending.to_add_file_ids
+            )
         else:
             tree.add(pending.to_add_files, pending.to_add_kinds)
         for path, content in pending.new_contents.items():

=== modified file 'breezy/breakin.py'
--- breezy/breakin.py	2023-11-01 20:32:05 +0000
+++ breezy/breakin.py	2023-11-07 18:55:36 +0000
@@ -25,9 +25,12 @@
 def _debug(signal_number, interrupted_frame):
     import pdb
     import sys
-    sys.stderr.write(f"** {_breakin_signal_name} received, entering debugger\n"
-                     "** Type 'c' to continue or 'q' to stop the process\n"
-                     f"** Or {_breakin_signal_name} again to quit (and possibly dump core)\n")
+
+    sys.stderr.write(
+        f"** {_breakin_signal_name} received, entering debugger\n"
+        "** Type 'c' to continue or 'q' to stop the process\n"
+        f"** Or {_breakin_signal_name} again to quit (and possibly dump core)\n"
+    )
     # It seems that on Windows, when sys.stderr is to a PIPE, then we need to
     # flush. Not sure why it is buffered, but that seems to be the case.
     sys.stderr.flush()
@@ -51,14 +54,14 @@
     #       and other platforms defined SIGQUIT. There doesn't seem to be a
     #       platform that defines both.
     #       -- jam 2009-07-30
-    sigquit = getattr(signal, 'SIGQUIT', None)
-    sigbreak = getattr(signal, 'SIGBREAK', None)
+    sigquit = getattr(signal, "SIGQUIT", None)
+    sigbreak = getattr(signal, "SIGBREAK", None)
     if sigquit is not None:
         _breakin_signal_number = sigquit
-        _breakin_signal_name = 'SIGQUIT'
+        _breakin_signal_name = "SIGQUIT"
     elif sigbreak is not None:
         _breakin_signal_number = sigbreak
-        _breakin_signal_name = 'SIGBREAK'
+        _breakin_signal_name = "SIGBREAK"
 
     return _breakin_signal_number
 
@@ -70,7 +73,7 @@
     hooked into SIGBREAK (C-Pause).
     """
     # when sigquit (C-\) or sigbreak (C-Pause) is received go into pdb
-    if os.environ.get('BRZ_SIGQUIT_PDB', '1') == '0':
+    if os.environ.get("BRZ_SIGQUIT_PDB", "1") == "0":
         # User explicitly requested we don't support this
         return
     sig = determine_signal()

=== modified file 'breezy/bugtracker.py'
--- breezy/bugtracker.py	2023-06-07 20:37:36 +0000
+++ breezy/bugtracker.py	2023-11-07 18:55:36 +0000
@@ -32,11 +32,11 @@
 """
 
 
-
 class MalformedBugIdentifier(errors.BzrError):
-
-    _fmt = ('Did not understand bug identifier %(bug_id)s: %(reason)s. '
-            'See "brz help bugs" for more information on this feature.')
+    _fmt = (
+        "Did not understand bug identifier %(bug_id)s: %(reason)s. "
+        'See "brz help bugs" for more information on this feature.'
+    )
 
     def __init__(self, bug_id, reason):
         self.bug_id = bug_id
@@ -44,9 +44,9 @@
 
 
 class InvalidBugTrackerURL(errors.BzrError):
-
-    _fmt = ("The URL for bug tracker \"%(abbreviation)s\" doesn't "
-            "contain {id}: %(url)s")
+    _fmt = (
+        'The URL for bug tracker "%(abbreviation)s" doesn\'t ' "contain {id}: %(url)s"
+    )
 
     def __init__(self, abbreviation, url):
         self.abbreviation = abbreviation
@@ -54,9 +54,7 @@
 
 
 class UnknownBugTrackerAbbreviation(errors.BzrError):
-
-    _fmt = ("Cannot find registered bug tracker called %(abbreviation)s "
-            "on %(branch)s")
+    _fmt = "Cannot find registered bug tracker called %(abbreviation)s " "on %(branch)s"
 
     def __init__(self, abbreviation, branch):
         self.abbreviation = abbreviation
@@ -64,15 +62,13 @@
 
 
 class InvalidLineInBugsProperty(errors.BzrError):
-
-    _fmt = ("Invalid line in bugs property: '%(line)s'")
+    _fmt = "Invalid line in bugs property: '%(line)s'"
 
     def __init__(self, line):
         self.line = line
 
 
 class InvalidBugUrl(errors.BzrError):
-
     _fmt = "Invalid bug URL: %(url)s"
 
     def __init__(self, url):
@@ -80,8 +76,7 @@
 
 
 class InvalidBugStatus(errors.BzrError):
-
-    _fmt = ("Invalid bug status: '%(status)s'")
+    _fmt = "Invalid bug status: '%(status)s'"
 
     def __init__(self, status):
         self.status = status
@@ -109,8 +104,7 @@
             tracker = tracker_type.get(abbreviated_bugtracker_name, branch)
             if tracker is not None:
                 return tracker
-        raise UnknownBugTrackerAbbreviation(
-            abbreviated_bugtracker_name, branch)
+        raise UnknownBugTrackerAbbreviation(abbreviated_bugtracker_name, branch)
 
     def help_topic(self, topic):
         return _bugs_help
@@ -191,7 +185,7 @@
 
     def check_bug_id(self, bug_id):
         try:
-            (project, bug_id) = bug_id.rsplit('/', 1)
+            (project, bug_id) = bug_id.rsplit("/", 1)
         except ValueError as exc:
             raise MalformedBugIdentifier(bug_id, "Expected format: project/id") from exc
         try:
@@ -200,32 +194,35 @@
             raise MalformedBugIdentifier(bug_id, "Bug id must be an integer") from exc
 
     def _get_bug_url(self, bug_id):
-        (project, bug_id) = bug_id.rsplit('/', 1)
+        (project, bug_id) = bug_id.rsplit("/", 1)
         """Return the URL for bug_id."""
-        if '{id}' not in self._base_url:
-            raise InvalidBugTrackerURL(self.abbreviation, self._base_url)
-        if '{project}' not in self._base_url:
-            raise InvalidBugTrackerURL(self.abbreviation, self._base_url)
-        return self._base_url.replace(
-            '{project}', project).replace('{id}', str(bug_id))
-
-
-tracker_registry.register(
-    'launchpad', UniqueIntegerBugTracker('lp', 'https://launchpad.net/bugs/'))
-
-
-tracker_registry.register(
-    'debian', UniqueIntegerBugTracker('deb', 'http://bugs.debian.org/'))
-
-
-tracker_registry.register(
-    'gnome', UniqueIntegerBugTracker(
-        'gnome', 'http://bugzilla.gnome.org/show_bug.cgi?id='))
-
-
-tracker_registry.register(
-    'github', ProjectIntegerBugTracker(
-        'github', 'https://github.com/{project}/issues/{id}'))
+        if "{id}" not in self._base_url:
+            raise InvalidBugTrackerURL(self.abbreviation, self._base_url)
+        if "{project}" not in self._base_url:
+            raise InvalidBugTrackerURL(self.abbreviation, self._base_url)
+        return self._base_url.replace("{project}", project).replace("{id}", str(bug_id))
+
+
+tracker_registry.register(
+    "launchpad", UniqueIntegerBugTracker("lp", "https://launchpad.net/bugs/")
+)
+
+
+tracker_registry.register(
+    "debian", UniqueIntegerBugTracker("deb", "http://bugs.debian.org/")
+)
+
+
+tracker_registry.register(
+    "gnome",
+    UniqueIntegerBugTracker("gnome", "http://bugzilla.gnome.org/show_bug.cgi?id="),
+)
+
+
+tracker_registry.register(
+    "github",
+    ProjectIntegerBugTracker("github", "https://github.com/{project}/issues/{id}"),
+)
 
 
 class URLParametrizedBugTracker(BugTracker):
@@ -240,7 +237,8 @@
     def get(self, abbreviation, branch):
         config = branch.get_config()
         url = config.get_user_option(
-            f"{self.type_name}_{abbreviation}_url", expand=False)
+            f"{self.type_name}_{abbreviation}_url", expand=False
+        )
         if url is None:
             return None
         self._base_url = url
@@ -255,8 +253,7 @@
         return urlutils.join(self._base_url, self._bug_area) + str(bug_id)
 
 
-class URLParametrizedIntegerBugTracker(IntegerBugTracker,
-                                       URLParametrizedBugTracker):
+class URLParametrizedIntegerBugTracker(IntegerBugTracker, URLParametrizedBugTracker):
     """A type of bug tracker that  only allows integer bug IDs.
 
     This can be found on a variety of different sites, and thus needs to have
@@ -269,19 +266,18 @@
     """
 
 
-tracker_registry.register(
-    'trac', URLParametrizedIntegerBugTracker('trac', 'ticket/'))
+tracker_registry.register("trac", URLParametrizedIntegerBugTracker("trac", "ticket/"))
 
 tracker_registry.register(
-    'bugzilla',
-    URLParametrizedIntegerBugTracker('bugzilla', 'show_bug.cgi?id='))
+    "bugzilla", URLParametrizedIntegerBugTracker("bugzilla", "show_bug.cgi?id=")
+)
 
 
 class GenericBugTracker(URLParametrizedBugTracker):
     """Generic bug tracker specified by an URL template."""
 
     def __init__(self):
-        super().__init__('bugtracker', None)
+        super().__init__("bugtracker", None)
 
     def get(self, abbreviation, branch):
         self._abbreviation = abbreviation
@@ -289,16 +285,16 @@
 
     def _get_bug_url(self, bug_id):
         """Given a validated bug_id, return the bug's web page's URL."""
-        if '{id}' not in self._base_url:
+        if "{id}" not in self._base_url:
             raise InvalidBugTrackerURL(self._abbreviation, self._base_url)
-        return self._base_url.replace('{id}', str(bug_id))
-
-
-tracker_registry.register('generic', GenericBugTracker())
-
-
-FIXED = 'fixed'
-RELATED = 'related'
+        return self._base_url.replace("{id}", str(bug_id))
+
+
+tracker_registry.register("generic", GenericBugTracker())
+
+
+FIXED = "fixed"
+RELATED = "related"
 
 ALLOWED_BUG_STATUSES = {FIXED, RELATED}
 
@@ -312,11 +308,11 @@
         as part of a commit.
     """
     lines = []
-    for (url, tag) in bug_urls:
-        if ' ' in url:
+    for url, tag in bug_urls:
+        if " " in url:
             raise InvalidBugUrl(url)
-        lines.append(f'{url} {tag}')
-    return '\n'.join(lines)
+        lines.append(f"{url} {tag}")
+    return "\n".join(lines)
 
 
 def decode_bug_urls(bug_lines):

=== modified file 'breezy/builtins.py'
--- breezy/builtins.py	2023-11-06 11:30:11 +0000
+++ breezy/builtins.py	2023-11-07 18:55:36 +0000
@@ -24,7 +24,9 @@
 
 from . import controldir, errors, lazy_import, osutils, transport
 
-lazy_import.lazy_import(globals(), """
+lazy_import.lazy_import(
+    globals(),
+    """
 import time
 
 import breezy
@@ -46,7 +48,8 @@
     )
 from breezy.branch import Branch
 from breezy.i18n import gettext, ngettext
-""")
+""",
+)
 
 from .commands import Command, builtin_command_registry, display_command
 from .option import ListOption, Option, RegistryOption, _parse_revision_str, custom_help
@@ -62,8 +65,7 @@
         return control_dir.root_transport.base
     if target is not None:
         return target
-    this_branch = control_dir.open_branch(
-        possible_transports=possible_transports)
+    this_branch = control_dir.open_branch(possible_transports=possible_transports)
     # This may be a heavy checkout, where we want the master branch
     master_location = this_branch.get_bound_location()
     if master_location is not None:
@@ -81,11 +83,13 @@
     """
     # This path is meant to be relative to the existing branch
     this_url = _get_branch_location(
-        control_dir, possible_transports=possible_transports)
+        control_dir, possible_transports=possible_transports
+    )
     # Perhaps the target control dir supports colocated branches?
     try:
         root = controldir.ControlDir.open(
-            this_url, possible_transports=possible_transports)
+            this_url, possible_transports=possible_transports
+        )
     except errors.NotBranchError:
         return (False, this_url)
     else:
@@ -95,9 +99,10 @@
             return (False, this_url)
         else:
             return (
-                root._format.colocated_branches and
-                control_dir.control_url == root.control_url,
-                this_url)
+                root._format.colocated_branches
+                and control_dir.control_url == root.control_url,
+                this_url,
+            )
 
 
 def lookup_new_sibling_branch(control_dir, location, possible_transports=None):
@@ -108,15 +113,17 @@
     :return: Full location to the new branch
     """
     from .directory_service import directories
+
     location = directories.dereference(location)
-    if '/' not in location and '\\' not in location:
+    if "/" not in location and "\\" not in location:
         (colocated, this_url) = _is_colocated(control_dir, possible_transports)
 
         if colocated:
             return urlutils.join_segment_parameters(
-                this_url, {"branch": urlutils.escape(location)})
+                this_url, {"branch": urlutils.escape(location)}
+            )
         else:
-            return urlutils.join(this_url, '..', urlutils.escape(location))
+            return urlutils.join(this_url, "..", urlutils.escape(location))
     return location
 
 
@@ -131,12 +138,11 @@
     try:
         # Perhaps it's a colocated branch?
         return control_dir.open_branch(
-            location, possible_transports=possible_transports)
+            location, possible_transports=possible_transports
+        )
     except (errors.NotBranchError, controldir.NoColocatedBranchSupport):
         this_url = _get_branch_location(control_dir)
-        return Branch.open(
-            urlutils.join(
-                this_url, '..', urlutils.escape(location)))
+        return Branch.open(urlutils.join(this_url, "..", urlutils.escape(location)))
 
 
 def open_nearby_branch(near=None, location=None, possible_transports=None):
@@ -150,14 +156,11 @@
         if location is None:
             location = "."
         try:
-            return Branch.open(
-                location, possible_transports=possible_transports)
+            return Branch.open(location, possible_transports=possible_transports)
         except errors.NotBranchError:
             near = "."
-    cdir = controldir.ControlDir.open(
-        near, possible_transports=possible_transports)
-    return open_sibling_branch(
-        cdir, location, possible_transports=possible_transports)
+    cdir = controldir.ControlDir.open(near, possible_transports=possible_transports)
+    return open_sibling_branch(cdir, location, possible_transports=possible_transports)
 
 
 def iter_sibling_branches(control_dir, possible_transports=None):
@@ -172,8 +175,7 @@
         reference = None
     if reference is not None:
         try:
-            ref_branch = Branch.open(
-                reference, possible_transports=possible_transports)
+            ref_branch = Branch.open(reference, possible_transports=possible_transports)
         except errors.NotBranchError:
             ref_branch = None
     else:
@@ -186,8 +188,7 @@
     else:
         repo = ref_branch.controldir.find_repository()
         for branch in repo.find_branches(using=True):
-            name = urlutils.relative_url(
-                repo.user_url, branch.user_url).rstrip("/")
+            name = urlutils.relative_url(repo.user_url, branch.user_url).rstrip("/")
             yield name, branch
 
 
@@ -215,14 +216,13 @@
         file_list = file_list[:]
         file_list[0] = tree.abspath(relpath)
     else:
-        tree = WorkingTree.open_containing('.')[0]
+        tree = WorkingTree.open_containing(".")[0]
         if tree.supports_views():
             view_files = tree.views.lookup_view()
             if view_files:
                 file_list = view_files
                 view_str = views.view_display_str(view_files)
-                note(gettext("Ignoring files outside view. View is %s"),
-                     view_str)
+                note(gettext("Ignoring files outside view. View is %s"), view_str)
     return tree, file_list
 
 
@@ -230,9 +230,10 @@
     if revisions is None:
         return None
     if len(revisions) != 1:
-        raise errors.CommandError(gettext(
-            'brz %s --revision takes exactly one revision identifier') % (
-                command_name,))
+        raise errors.CommandError(
+            gettext("brz %s --revision takes exactly one revision identifier")
+            % (command_name,)
+        )
     return revisions[0]
 
 
@@ -262,6 +263,7 @@
 def _get_view_info_for_change_reporter(tree):
     """Get the view information from a tree for change reporting."""
     from . import views
+
     view_info = None
     try:
         current_view = tree.views.get_view_info()[0]
@@ -287,6 +289,7 @@
 # Argument class, representing a file in a branch, where the first occurrence
 # opens the branch?)
 
+
 class cmd_status(Command):
     __doc__ = """Display status summary.
 
@@ -346,48 +349,67 @@
 
     # TODO: --no-recurse/-N, --recurse options
 
-    takes_args = ['file*']
-    takes_options = ['show-ids', 'revision', 'change', 'verbose',
-                     Option('short', help='Use short status indicators.',
-                            short_name='S'),
-                     Option('versioned', help='Only show versioned files.',
-                            short_name='V'),
-                     Option('no-pending', help='Don\'t show pending merges.'),
-                     Option('no-classify',
-                            help='Do not mark object type using indicator.'),
-                     ]
-    aliases = ['st', 'stat']
+    takes_args = ["file*"]
+    takes_options = [
+        "show-ids",
+        "revision",
+        "change",
+        "verbose",
+        Option("short", help="Use short status indicators.", short_name="S"),
+        Option("versioned", help="Only show versioned files.", short_name="V"),
+        Option("no-pending", help="Don't show pending merges."),
+        Option("no-classify", help="Do not mark object type using indicator."),
+    ]
+    aliases = ["st", "stat"]
 
-    encoding_type = 'replace'
-    _see_also = ['diff', 'revert', 'status-flags']
+    encoding_type = "replace"
+    _see_also = ["diff", "revert", "status-flags"]
 
     @display_command
-    def run(self, show_ids=False, file_list=None, revision=None, short=False,
-            versioned=False, no_pending=False, verbose=False,
-            no_classify=False):
+    def run(
+        self,
+        show_ids=False,
+        file_list=None,
+        revision=None,
+        short=False,
+        versioned=False,
+        no_pending=False,
+        verbose=False,
+        no_classify=False,
+    ):
         from .status import show_tree_status
         from .workingtree import WorkingTree
 
         if revision and len(revision) > 2:
             raise errors.CommandError(
-                gettext('brz status --revision takes exactly'
-                        ' one or two revision specifiers'))
+                gettext(
+                    "brz status --revision takes exactly"
+                    " one or two revision specifiers"
+                )
+            )
 
         tree, relfile_list = WorkingTree.open_containing_paths(file_list)
         # Avoid asking for specific files when that is not needed.
-        if relfile_list == ['']:
+        if relfile_list == [""]:
             relfile_list = None
             # Don't disable pending merges for full trees other than '.'.
-            if file_list == ['.']:
+            if file_list == ["."]:
                 no_pending = True
         # A specific path within a tree was given.
         elif relfile_list is not None:
             no_pending = True
-        show_tree_status(tree, show_ids=show_ids,
-                         specific_files=relfile_list, revision=revision,
-                         to_file=self.outf, short=short, versioned=versioned,
-                         show_pending=(not no_pending), verbose=verbose,
-                         classify=not no_classify)
+        show_tree_status(
+            tree,
+            show_ids=show_ids,
+            specific_files=relfile_list,
+            revision=revision,
+            to_file=self.outf,
+            short=short,
+            versioned=versioned,
+            show_pending=(not no_pending),
+            verbose=verbose,
+            classify=not no_classify,
+        )
 
 
 class cmd_cat_revision(Command):
@@ -398,52 +420,58 @@
     """
 
     hidden = True
-    takes_args = ['revision_id?']
-    takes_options = ['directory', 'revision']
+    takes_args = ["revision_id?"]
+    takes_options = ["directory", "revision"]
     # cat-revision is more for frontends so should be exact
-    encoding = 'strict'
+    encoding = "strict"
 
     def print_revision(self, revisions, revid):
-        stream = revisions.get_record_stream([(revid,)], 'unordered', True)
+        stream = revisions.get_record_stream([(revid,)], "unordered", True)
         record = next(stream)
-        if record.storage_kind == 'absent':
+        if record.storage_kind == "absent":
             raise errors.NoSuchRevision(revisions, revid)
-        revtext = record.get_bytes_as('fulltext')
-        self.outf.write(revtext.decode('utf-8'))
+        revtext = record.get_bytes_as("fulltext")
+        self.outf.write(revtext.decode("utf-8"))
 
     @display_command
-    def run(self, revision_id=None, revision=None, directory='.'):
+    def run(self, revision_id=None, revision=None, directory="."):
         if revision_id is not None and revision is not None:
-            raise errors.CommandError(gettext('You can only supply one of'
-                                              ' revision_id or --revision'))
+            raise errors.CommandError(
+                gettext("You can only supply one of" " revision_id or --revision")
+            )
         if revision_id is None and revision is None:
             raise errors.CommandError(
-                gettext('You must supply either --revision or a revision_id'))
+                gettext("You must supply either --revision or a revision_id")
+            )
 
         b = controldir.ControlDir.open_containing_tree_or_branch(directory)[1]
 
         revisions = getattr(b.repository, "revisions", None)
         if revisions is None:
             raise errors.CommandError(
-                gettext('Repository %r does not support '
-                        'access to raw revision texts') % b.repository)
+                gettext(
+                    "Repository %r does not support " "access to raw revision texts"
+                )
+                % b.repository
+            )
 
         with b.repository.lock_read():
             # TODO: jam 20060112 should cat-revision always output utf-8?
             if revision_id is not None:
-                revision_id = revision_id.encode('utf-8')
+                revision_id = revision_id.encode("utf-8")
                 try:
                     self.print_revision(revisions, revision_id)
                 except errors.NoSuchRevision as exc:
                     msg = gettext(
-                        "The repository {0} contains no revision {1}.").format(
-                            b.repository.base, revision_id.decode('utf-8'))
+                        "The repository {0} contains no revision {1}."
+                    ).format(b.repository.base, revision_id.decode("utf-8"))
                     raise errors.CommandError(msg) from exc
             elif revision is not None:
                 for rev in revision:
                     if rev is None:
                         raise errors.CommandError(
-                            gettext('You cannot specify a NULL revision.'))
+                            gettext("You cannot specify a NULL revision.")
+                        )
                     rev_id = rev.as_revision_id(b)
                     self.print_revision(revisions, rev_id)
 
@@ -456,17 +484,19 @@
 
     To re-create the working tree, use "brz checkout".
     """
-    _see_also = ['checkout', 'working-trees']
-    takes_args = ['location*']
+    _see_also = ["checkout", "working-trees"]
+    takes_args = ["location*"]
     takes_options = [
-        Option('force',
-               help='Remove the working tree even if it has '
-                    'uncommitted or shelved changes.'),
-        ]
+        Option(
+            "force",
+            help="Remove the working tree even if it has "
+            "uncommitted or shelved changes.",
+        ),
+    ]
 
     def run(self, location_list, force=False):
         if not location_list:
-            location_list = ['.']
+            location_list = ["."]
 
         for location in location_list:
             d = controldir.ControlDir.open(location)
@@ -474,22 +504,24 @@
             try:
                 working = d.open_workingtree()
             except errors.NoWorkingTree as exc:
-                raise errors.CommandError(
-                    gettext("No working tree to remove")) from exc
+                raise errors.CommandError(gettext("No working tree to remove")) from exc
             except errors.NotLocalUrl as exc:
                 raise errors.CommandError(
-                    gettext("You cannot remove the working tree"
-                            " of a remote path")) from exc
+                    gettext("You cannot remove the working tree" " of a remote path")
+                ) from exc
             if not force:
-                if (working.has_changes()):
+                if working.has_changes():
                     raise errors.UncommittedChanges(working)
                 if working.get_shelf_manager().last_shelf() is not None:
                     raise errors.ShelvedChanges(working)
 
             if working.user_url != working.branch.user_url:
                 raise errors.CommandError(
-                    gettext("You cannot remove the working tree"
-                            " from a lightweight checkout"))
+                    gettext(
+                        "You cannot remove the working tree"
+                        " from a lightweight checkout"
+                    )
+                )
 
             d.destroy_workingtree()
 
@@ -511,15 +543,17 @@
     """
 
     takes_options = [
-        'revision', 'directory',
-        Option('force',
-               help='Reset the tree even if it doesn\'t appear to be'
-                    ' corrupted.'),
+        "revision",
+        "directory",
+        Option(
+            "force", help="Reset the tree even if it doesn't appear to be" " corrupted."
+        ),
     ]
     hidden = True
 
-    def run(self, revision=None, directory='.', force=False):
+    def run(self, revision=None, directory=".", force=False):
         from .workingtree import WorkingTree
+
         tree, _ = WorkingTree.open_containing(directory)
         self.enter_context(tree.lock_tree_write())
         if not force:
@@ -529,10 +563,13 @@
                 pass  # There seems to be a real error here, so we'll reset
             else:
                 # Refuse
-                raise errors.CommandError(gettext(
-                    'The tree does not appear to be corrupt. You probably'
-                    ' want "brz revert" instead. Use "--force" if you are'
-                    ' sure you want to reset the working tree.'))
+                raise errors.CommandError(
+                    gettext(
+                        "The tree does not appear to be corrupt. You probably"
+                        ' want "brz revert" instead. Use "--force" if you are'
+                        " sure you want to reset the working tree."
+                    )
+                )
         if revision is None:
             revision_ids = None
         else:
@@ -541,12 +578,15 @@
             tree.reset_state(revision_ids)
         except errors.BzrError as exc:
             if revision_ids is None:
-                extra = gettext(', the header appears corrupt, try passing '
-                                '-r -1 to set the state to the last commit')
+                extra = gettext(
+                    ", the header appears corrupt, try passing "
+                    "-r -1 to set the state to the last commit"
+                )
             else:
-                extra = ''
+                extra = ""
             raise errors.CommandError(
-                gettext('failed to reset the tree state{0}').format(extra)) from exc
+                gettext("failed to reset the tree state{0}").format(extra)
+            ) from exc
 
 
 class cmd_revno(Command):
@@ -555,19 +595,21 @@
     This is equal to the number of revisions on this branch.
     """
 
-    _see_also = ['info']
-    takes_args = ['location?']
+    _see_also = ["info"]
+    takes_args = ["location?"]
     takes_options = [
-        Option('tree', help='Show revno of working tree.'),
-        'revision',
-        ]
+        Option("tree", help="Show revno of working tree."),
+        "revision",
+    ]
 
     @display_command
-    def run(self, tree=False, location='.', revision=None):
+    def run(self, tree=False, location=".", revision=None):
         from .workingtree import WorkingTree
+
         if revision is not None and tree:
             raise errors.CommandError(
-                gettext("--tree and --revision can not be used together"))
+                gettext("--tree and --revision can not be used together")
+            )
 
         if tree:
             try:
@@ -582,36 +624,41 @@
             self.enter_context(b.lock_read())
             if revision:
                 if len(revision) != 1:
-                    raise errors.CommandError(gettext(
-                        "Revision numbers only make sense for single "
-                        "revisions, not ranges"))
+                    raise errors.CommandError(
+                        gettext(
+                            "Revision numbers only make sense for single "
+                            "revisions, not ranges"
+                        )
+                    )
                 revid = revision[0].as_revision_id(b)
             else:
                 revid = b.last_revision()
         try:
             revno_t = b.revision_id_to_dotted_revno(revid)
         except (errors.NoSuchRevision, errors.GhostRevisionsHaveNoRevno):
-            revno_t = ('???',)
+            revno_t = ("???",)
         revno = ".".join(str(n) for n in revno_t)
         self.cleanup_now()
-        self.outf.write(revno + '\n')
+        self.outf.write(revno + "\n")
 
 
 class cmd_revision_info(Command):
     __doc__ = """Show revision number and revision id for a given revision identifier.
     """
     hidden = True
-    takes_args = ['revision_info*']
+    takes_args = ["revision_info*"]
     takes_options = [
-        'revision',
-        custom_help('directory', help='Branch to examine, '
-                    'rather than the one containing the working directory.'),
-        Option('tree', help='Show revno of working tree.'),
-        ]
+        "revision",
+        custom_help(
+            "directory",
+            help="Branch to examine, "
+            "rather than the one containing the working directory.",
+        ),
+        Option("tree", help="Show revno of working tree."),
+    ]
 
     @display_command
-    def run(self, revision=None, directory='.', tree=False,
-            revision_info_list=None):
+    def run(self, revision=None, directory=".", tree=False, revision_info_list=None):
         from .workingtree import WorkingTree
 
         try:
@@ -643,16 +690,15 @@
         for revision_id in revision_ids:
             try:
                 dotted_revno = b.revision_id_to_dotted_revno(revision_id)
-                revno = '.'.join(str(i) for i in dotted_revno)
+                revno = ".".join(str(i) for i in dotted_revno)
             except errors.NoSuchRevision:
-                revno = '???'
+                revno = "???"
             maxlen = max(maxlen, len(revno))
             revinfos.append((revno, revision_id))
 
         self.cleanup_now()
         for revno, revid in revinfos:
-            self.outf.write(
-                '%*s %s\n' % (maxlen, revno, revid.decode('utf-8')))
+            self.outf.write("%*s %s\n" % (maxlen, revno, revid.decode("utf-8")))
 
 
 class cmd_add(Command):
@@ -699,64 +745,75 @@
     add.maximum_file_size will be skipped. Named items are never skipped due
     to file size.
     """
-    takes_args = ['file*']
+    takes_args = ["file*"]
     takes_options = [
-        Option('no-recurse',
-               help="Don't recursively add the contents of directories.",
-               short_name='N'),
-        Option('dry-run',
-               help="Show what would be done, but don't actually do "
-                    "anything."),
-        'verbose',
-        Option('file-ids-from',
-               type=str,
-               help='Lookup file ids from this tree.'),
-        ]
-    encoding_type = 'replace'
-    _see_also = ['remove', 'ignore']
+        Option(
+            "no-recurse",
+            help="Don't recursively add the contents of directories.",
+            short_name="N",
+        ),
+        Option(
+            "dry-run",
+            help="Show what would be done, but don't actually do " "anything.",
+        ),
+        "verbose",
+        Option("file-ids-from", type=str, help="Lookup file ids from this tree."),
+    ]
+    encoding_type = "replace"
+    _see_also = ["remove", "ignore"]
 
-    def run(self, file_list, no_recurse=False, dry_run=False, verbose=False,
-            file_ids_from=None):
+    def run(
+        self,
+        file_list,
+        no_recurse=False,
+        dry_run=False,
+        verbose=False,
+        file_ids_from=None,
+    ):
         import breezy.add
 
         from .workingtree import WorkingTree
+
         tree, file_list = tree_files_for_add(file_list)
 
         if file_ids_from is not None and not tree.supports_setting_file_ids():
             warning(
-                gettext('Ignoring --file-ids-from, since the tree does not '
-                        'support setting file ids.'))
+                gettext(
+                    "Ignoring --file-ids-from, since the tree does not "
+                    "support setting file ids."
+                )
+            )
             file_ids_from = None
 
         base_tree = None
         if file_ids_from is not None:
             try:
-                base_tree, base_path = WorkingTree.open_containing(
-                    file_ids_from)
+                base_tree, base_path = WorkingTree.open_containing(file_ids_from)
             except errors.NoWorkingTree:
-                base_branch, base_path = Branch.open_containing(
-                    file_ids_from)
+                base_branch, base_path = Branch.open_containing(file_ids_from)
                 base_tree = base_branch.basis_tree()
 
             action = breezy.add.AddFromBaseAction(
-                base_tree, base_path, to_file=self.outf,
-                should_print=(not is_quiet()))
+                base_tree, base_path, to_file=self.outf, should_print=(not is_quiet())
+            )
         else:
             action = breezy.add.AddWithSkipLargeAction(
-                to_file=self.outf, should_print=(not is_quiet()))
+                to_file=self.outf, should_print=(not is_quiet())
+            )
 
         if base_tree:
             self.enter_context(base_tree.lock_read())
         added, ignored = tree.smart_add(
-            file_list, not no_recurse, action=action, save=not dry_run)
+            file_list, not no_recurse, action=action, save=not dry_run
+        )
         self.cleanup_now()
         if len(ignored) > 0:
             if verbose:
                 for glob in sorted(ignored):
                     for path in ignored[glob]:
                         self.outf.write(
-                            gettext("ignored {0} matching \"{1}\"\n").format(
-                                path, glob))
+                            gettext('ignored {0} matching "{1}"\n').format(path, glob)
+                        )
 
 
 class cmd_mkdir(Command):
@@ -765,15 +822,15 @@
     This is equivalent to creating the directory and then adding it.
     """
 
-    takes_args = ['dir+']
+    takes_args = ["dir+"]
     takes_options = [
         Option(
-            'parents',
-            help='No error if existing, make parent directories as needed.',
-            short_name='p'
-            )
-        ]
-    encoding_type = 'replace'
+            "parents",
+            help="No error if existing, make parent directories as needed.",
+            short_name="p",
+        )
+    ]
+    encoding_type = "replace"
 
     @classmethod
     def add_file_with_parents(cls, wt, relpath):
@@ -788,6 +845,7 @@
 
     def run(self, dir_list, parents=False):
         from .workingtree import WorkingTree
+
         if parents:
             add_file = self.add_file_with_parents
         else:
@@ -803,13 +861,13 @@
                 os.mkdir(dir)
             add_file(wt, relpath)
             if not is_quiet():
-                self.outf.write(gettext('added %s\n') % dir)
+                self.outf.write(gettext("added %s\n") % dir)
 
 
 class cmd_relpath(Command):
     __doc__ = """Show path of a file relative to root"""
 
-    takes_args = ['filename']
+    takes_args = ["filename"]
     hidden = True
 
     @display_command
@@ -820,7 +878,7 @@
         #       sys.stdout encoding cannot represent it?
         tree, relpath = WorkingTree.open_containing(filename)
         self.outf.write(relpath)
-        self.outf.write('\n')
+        self.outf.write("\n")
 
 
 class cmd_inventory(Command):
@@ -834,28 +892,36 @@
     """
 
     hidden = True
-    _see_also = ['ls']
+    _see_also = ["ls"]
     takes_options = [
-        'revision',
-        'show-ids',
-        Option('include-root',
-               help='Include the entry for the root of the tree, if any.'),
-        Option('kind',
-               help='List entries of a particular kind: file, directory, '
-                    'symlink.',
-               type=str),
-        ]
-    takes_args = ['file*']
+        "revision",
+        "show-ids",
+        Option(
+            "include-root", help="Include the entry for the root of the tree, if any."
+        ),
+        Option(
+            "kind",
+            help="List entries of a particular kind: file, directory, " "symlink.",
+            type=str,
+        ),
+    ]
+    takes_args = ["file*"]
 
     @display_command
-    def run(self, revision=None, show_ids=False, kind=None, include_root=False,
-            file_list=None):
+    def run(
+        self,
+        revision=None,
+        show_ids=False,
+        kind=None,
+        include_root=False,
+        file_list=None,
+    ):
         from .workingtree import WorkingTree
-        if kind and kind not in ['file', 'directory', 'symlink']:
-            raise errors.CommandError(
-                gettext('invalid kind %r specified') % (kind,))
-
-        revision = _get_one_revision('inventory', revision)
+
+        if kind and kind not in ["file", "directory", "symlink"]:
+            raise errors.CommandError(gettext("invalid kind %r specified") % (kind,))
+
+        revision = _get_one_revision("inventory", revision)
         work_tree, file_list = WorkingTree.open_containing_paths(file_list)
         self.enter_context(work_tree.lock_read())
         if revision is not None:
@@ -870,7 +936,8 @@
         self.enter_context(tree.lock_read())
         if file_list is not None:
             paths = tree.find_related_paths_across_trees(
-                file_list, extra_trees, require_versioned=True)
+                file_list, extra_trees, require_versioned=True
+            )
             # find_ids_across_trees may include some paths that don't
             # exist in 'tree'.
             entries = tree.iter_entries_by_dir(specific_files=paths)
@@ -883,11 +950,10 @@
             if path == "" and not include_root:
                 continue
             if show_ids:
-                self.outf.write('%-50s %s\n' % (
-                    path, entry.file_id.decode('utf-8')))
+                self.outf.write("%-50s %s\n" % (path, entry.file_id.decode("utf-8")))
             else:
                 self.outf.write(path)
-                self.outf.write('\n')
+                self.outf.write("\n")
 
 
 class cmd_cp(Command):
@@ -906,22 +972,23 @@
     at the moment.
     """
 
-    takes_args = ['names*']
-    aliases = ['copy']
-    encoding_type = 'replace'
+    takes_args = ["names*"]
+    aliases = ["copy"]
+    encoding_type = "replace"
 
     def run(self, names_list):
         from .workingtree import WorkingTree
+
         if names_list is None:
             names_list = []
         if len(names_list) < 2:
             raise errors.CommandError(gettext("missing file argument"))
         tree, rel_names = WorkingTree.open_containing_paths(
-            names_list, canonicalize=False)
+            names_list, canonicalize=False
+        )
         for file_name in rel_names[0:-1]:
-            if file_name == '':
-                raise errors.CommandError(
-                    gettext("can not copy root of branch"))
+            if file_name == "":
+                raise errors.CommandError(gettext("can not copy root of branch"))
         self.enter_context(tree.lock_tree_write())
         into_existing = osutils.isdir(names_list[-1])
         if not into_existing:
@@ -929,41 +996,51 @@
                 (src, dst) = rel_names
             except IndexError as exc:
                 raise errors.CommandError(
-                    gettext('to copy multiple files the'
-                            ' destination must be a versioned'
-                            ' directory')) from exc
+                    gettext(
+                        "to copy multiple files the"
+                        " destination must be a versioned"
+                        " directory"
+                    )
+                ) from exc
             pairs = [(src, dst)]
         else:
             pairs = [
                 (n, osutils.joinpath([rel_names[-1], osutils.basename(n)]))
-                for n in rel_names[:-1]]
+                for n in rel_names[:-1]
+            ]
 
         for src, dst in pairs:
             try:
                 src_kind = tree.stored_kind(src)
             except transport.NoSuchFile as exc:
                 raise errors.CommandError(
-                    gettext('Could not copy %s => %s: %s is not versioned.')
-                    % (src, dst, src)) from exc
+                    gettext("Could not copy %s => %s: %s is not versioned.")
+                    % (src, dst, src)
+                ) from exc
             if src_kind is None:
                 raise errors.CommandError(
-                    gettext('Could not copy %s => %s . %s is not versioned\\.') % (src, dst, src))
-            if src_kind == 'directory':
+                    gettext("Could not copy %s => %s . %s is not versioned\\.")
+                    % (src, dst, src)
+                )
+            if src_kind == "directory":
                 raise errors.CommandError(
-                    gettext('Could not copy %s => %s . %s is a directory.') % (
-                        src, dst, src))
+                    gettext("Could not copy %s => %s . %s is a directory.")
+                    % (src, dst, src)
+                )
             dst_parent = osutils.split(dst)[0]
-            if dst_parent != '':
+            if dst_parent != "":
                 try:
                     dst_parent_kind = tree.stored_kind(dst_parent)
                 except transport.NoSuchFile as exc:
                     raise errors.CommandError(
-                        gettext('Could not copy %s => %s: %s is not versioned.')
-                        % (src, dst, dst_parent)) from exc
-                if dst_parent_kind != 'directory':
+                        gettext("Could not copy %s => %s: %s is not versioned.")
+                        % (src, dst, dst_parent)
+                    ) from exc
+                if dst_parent_kind != "directory":
                     raise errors.CommandError(
-                        gettext('Could not copy to %s: %s is not a directory.')
-                        % (dst_parent, dst_parent))
+                        gettext("Could not copy to %s: %s is not a directory.")
+                        % (dst_parent, dst_parent)
+                    )
 
             tree.copy_one(src, dst)
 
@@ -989,49 +1066,56 @@
     Files cannot be moved between branches.
     """
 
-    takes_args = ['names*']
-    takes_options = [Option("after", help="Move only the brz identifier"
-                            " of the file, because the file has already been moved."),
-                     Option('auto', help='Automatically guess renames.'),
-                     Option(
-                         'dry-run', help='Avoid making changes when guessing renames.'),
-                     ]
-    aliases = ['move', 'rename']
-    encoding_type = 'replace'
+    takes_args = ["names*"]
+    takes_options = [
+        Option(
+            "after",
+            help="Move only the brz identifier"
+            " of the file, because the file has already been moved.",
+        ),
+        Option("auto", help="Automatically guess renames."),
+        Option("dry-run", help="Avoid making changes when guessing renames."),
+    ]
+    aliases = ["move", "rename"]
+    encoding_type = "replace"
 
     def run(self, names_list, after=False, auto=False, dry_run=False):
         from .workingtree import WorkingTree
+
         if auto:
             return self.run_auto(names_list, after, dry_run)
         elif dry_run:
-            raise errors.CommandError(gettext('--dry-run requires --auto.'))
+            raise errors.CommandError(gettext("--dry-run requires --auto."))
         if names_list is None:
             names_list = []
         if len(names_list) < 2:
             raise errors.CommandError(gettext("missing file argument"))
         tree, rel_names = WorkingTree.open_containing_paths(
-            names_list, canonicalize=False)
+            names_list, canonicalize=False
+        )
         for file_name in rel_names[0:-1]:
-            if file_name == '':
-                raise errors.CommandError(
-                    gettext("can not move root of branch"))
+            if file_name == "":
+                raise errors.CommandError(gettext("can not move root of branch"))
         self.enter_context(tree.lock_tree_write())
         self._run(tree, names_list, rel_names, after)
 
     def run_auto(self, names_list, after, dry_run):
         from .rename_map import RenameMap
         from .workingtree import WorkingTree
+
         if names_list is not None and len(names_list) > 1:
             raise errors.CommandError(
-                gettext('Only one path may be specified to --auto.'))
+                gettext("Only one path may be specified to --auto.")
+            )
         if after:
             raise errors.CommandError(
-                gettext('--after cannot be specified with --auto.'))
+                gettext("--after cannot be specified with --auto.")
+            )
         work_tree, file_list = WorkingTree.open_containing_paths(
-            names_list, default_directory='.')
+            names_list, default_directory="."
+        )
         self.enter_context(work_tree.lock_tree_write())
-        RenameMap.guess_renames(
-            work_tree.basis_tree(), work_tree, dry_run)
+        RenameMap.guess_renames(work_tree.basis_tree(), work_tree, dry_run)
 
     def _run(self, tree, names_list, rel_names, after):
         into_existing = osutils.isdir(names_list[-1])
@@ -1041,15 +1125,16 @@
             # b. move directory after the fact (if the source used to be
             #    a directory, but now doesn't exist in the working tree
             #    and the target is an existing directory, just rename it)
-            if (not tree.case_sensitive
-                    and rel_names[0].lower() == rel_names[1].lower()):
+            if not tree.case_sensitive and rel_names[0].lower() == rel_names[1].lower():
                 into_existing = False
             else:
                 # 'fix' the case of a potential 'from'
                 from_path = tree.get_canonical_path(rel_names[0])
-                if (not osutils.lexists(names_list[0]) and
-                    tree.is_versioned(from_path) and
-                        tree.stored_kind(from_path) == "directory"):
+                if (
+                    not osutils.lexists(names_list[0])
+                    and tree.is_versioned(from_path)
+                    and tree.stored_kind(from_path) == "directory"
+                ):
                     into_existing = False
         # move/rename
         if into_existing:
@@ -1062,9 +1147,13 @@
                     self.outf.write(f"{src} => {dest}\n")
         else:
             if len(names_list) != 2:
-                raise errors.CommandError(gettext('to mv multiple files the'
-                                                  ' destination must be a versioned'
-                                                  ' directory'))
+                raise errors.CommandError(
+                    gettext(
+                        "to mv multiple files the"
+                        " destination must be a versioned"
+                        " directory"
+                    )
+                )
 
             # for cicp file-systems: the src references an existing inventory
             # item:
@@ -1091,16 +1180,15 @@
                 if after:
                     # If 'after' is specified, the tail must refer to a file on disk.
                     if dest_parent:
-                        dest_parent_fq = osutils.pathjoin(
-                            tree.basedir, dest_parent)
+                        dest_parent_fq = osutils.pathjoin(tree.basedir, dest_parent)
                     else:
                         # pathjoin with an empty tail adds a slash, which breaks
                         # relpath :(
                         dest_parent_fq = tree.basedir
 
                     dest_tail = osutils.canonical_relpath(
-                        dest_parent_fq,
-                        osutils.pathjoin(dest_parent_fq, spec_tail))
+                        dest_parent_fq, osutils.pathjoin(dest_parent_fq, spec_tail)
+                    )
                 else:
                     # not 'after', so case as specified is used
                     dest_tail = spec_tail
@@ -1144,30 +1232,41 @@
     with brz send.
     """
 
-    _see_also = ['push', 'update', 'status-flags', 'send']
-    takes_options = ['remember', 'overwrite', 'revision',
-                     custom_help('verbose',
-                                 help='Show logs of pulled revisions.'),
-                     custom_help('directory',
-                                 help='Branch to pull into, '
-                                 'rather than the one containing the working directory.'),
-                     Option('local',
-                            help="Perform a local pull in a bound "
-                            "branch.  Local pulls are not applied to "
-                            "the master branch."
-                            ),
-                     Option('show-base',
-                            help="Show base revision text in conflicts."),
-                     Option('overwrite-tags',
-                            help="Overwrite tags only."),
-                     ]
-    takes_args = ['location?']
-    encoding_type = 'replace'
+    _see_also = ["push", "update", "status-flags", "send"]
+    takes_options = [
+        "remember",
+        "overwrite",
+        "revision",
+        custom_help("verbose", help="Show logs of pulled revisions."),
+        custom_help(
+            "directory",
+            help="Branch to pull into, "
+            "rather than the one containing the working directory.",
+        ),
+        Option(
+            "local",
+            help="Perform a local pull in a bound "
+            "branch.  Local pulls are not applied to "
+            "the master branch.",
+        ),
+        Option("show-base", help="Show base revision text in conflicts."),
+        Option("overwrite-tags", help="Overwrite tags only."),
+    ]
+    takes_args = ["location?"]
+    encoding_type = "replace"
 
-    def run(self, location=None, remember=None, overwrite=False,
-            revision=None, verbose=False,
-            directory=None, local=False,
-            show_base=False, overwrite_tags=False):
+    def run(
+        self,
+        location=None,
+        remember=None,
+        overwrite=False,
+        revision=None,
+        verbose=False,
+        directory=None,
+        local=False,
+        show_base=False,
+        overwrite_tags=False,
+    ):
         from . import mergeable as _mod_mergeable
         from .workingtree import WorkingTree
 
@@ -1181,7 +1280,7 @@
         revision_id = None
         mergeable = None
         if directory is None:
-            directory = '.'
+            directory = "."
         try:
             tree_to = WorkingTree.open_containing(directory)[0]
             branch_to = tree_to.branch
@@ -1200,39 +1299,43 @@
         if location is not None:
             try:
                 mergeable = _mod_mergeable.read_mergeable_from_url(
-                    location, possible_transports=possible_transports)
+                    location, possible_transports=possible_transports
+                )
             except errors.NotABundle:
                 mergeable = None
 
         stored_loc = branch_to.get_parent()
         if location is None:
             if stored_loc is None:
-                raise errors.CommandError(gettext("No pull location known or"
-                                                  " specified."))
+                raise errors.CommandError(
+                    gettext("No pull location known or" " specified.")
+                )
             else:
-                display_url = urlutils.unescape_for_display(stored_loc,
-                                                            self.outf.encoding)
+                display_url = urlutils.unescape_for_display(
+                    stored_loc, self.outf.encoding
+                )
                 if not is_quiet():
                     self.outf.write(
-                        gettext("Using saved parent location: %s\n") % display_url)
+                        gettext("Using saved parent location: %s\n") % display_url
+                    )
                 location = stored_loc
 
-        revision = _get_one_revision('pull', revision)
+        revision = _get_one_revision("pull", revision)
         if mergeable is not None:
             if revision is not None:
-                raise errors.CommandError(gettext(
-                    'Cannot use -r with merge directives or bundles'))
+                raise errors.CommandError(
+                    gettext("Cannot use -r with merge directives or bundles")
+                )
             mergeable.install_revisions(branch_to.repository)
-            base_revision_id, revision_id, verified = \
-                mergeable.get_merge_request(branch_to.repository)
+            base_revision_id, revision_id, verified = mergeable.get_merge_request(
+                branch_to.repository
+            )
             branch_from = branch_to
         else:
-            branch_from = Branch.open(location,
-                                      possible_transports=possible_transports)
+            branch_from = Branch.open(location, possible_transports=possible_transports)
             self.enter_context(branch_from.lock_read())
             # Remembers if asked explicitly or no previous location is set
-            if (remember
-                    or (remember is None and branch_to.get_parent() is None)):
+            if remember or (remember is None and branch_to.get_parent() is None):
                 # FIXME: This shouldn't be done before the pull
                 # succeeds... -- vila 2012-01-02
                 branch_to.set_parent(branch_from.base)
@@ -1243,23 +1346,27 @@
         if tree_to is not None:
             view_info = _get_view_info_for_change_reporter(tree_to)
             change_reporter = delta._ChangeReporter(
-                unversioned_filter=tree_to.is_ignored,
-                view_info=view_info)
+                unversioned_filter=tree_to.is_ignored, view_info=view_info
+            )
             result = tree_to.pull(
-                branch_from, overwrite=overwrite, stop_revision=revision_id,
+                branch_from,
+                overwrite=overwrite,
+                stop_revision=revision_id,
                 change_reporter=change_reporter,
-                local=local, show_base=show_base)
+                local=local,
+                show_base=show_base,
+            )
         else:
             result = branch_to.pull(
-                branch_from, overwrite=overwrite, stop_revision=revision_id,
-                local=local)
+                branch_from, overwrite=overwrite, stop_revision=revision_id, local=local
+            )
 
         result.report(self.outf)
         if verbose and result.old_revid != result.new_revid:
             log.show_branch_change(
-                branch_to, self.outf, result.old_revno,
-                result.old_revid)
-        if getattr(result, 'tag_conflicts', None):
+                branch_to, self.outf, result.old_revno, result.old_revid
+            )
+        if getattr(result, "tag_conflicts", None):
             return 1
         else:
             return 0
@@ -1295,46 +1402,78 @@