Merge lp:~jelmer/brz-loom/flake8 into lp:brz-loom

[Jelmer Vernooij]

Fix flake8 issues.

Fix flake8 issues.

[Jelmer Vernooij (jelmer)]

review: Approve

=== modified file 'TODO'
--- TODO	2010-07-02 06:15:32 +0000
+++ TODO	2022-08-19 17:04:03 +0000
@@ -85,7 +85,7 @@
 - bug: up-thread incorrectly sets pending merge when the thread is already merged.
 - UI question - show a marker on all 'applied' threads. i.e. a 'empire state besides the threads list'.
 - revert-loom thread did not reset branch status correctly in the tree.
-- bug: up-thread with an out of date tree fails with BzrCommandError not bound.
+- bug: up-thread with an out of date tree fails with CommandError not bound.
 - bzr loomify && bzr revert-loom should preserve revision history.
 - nice errors for loom branch commands on non-loom branches.
 - better offset management for adjust_current_index.

=== modified file '__init__.py'
--- __init__.py	2019-08-22 19:36:40 +0000
+++ __init__.py	2022-08-19 17:04:03 +0000
@@ -1,19 +1,19 @@
 # Loom, a plugin for bzr to assist in developing focused patches.
 # Copyright (C) 2006 Canonical Limited.
-# 
+#
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 2 as published
 # by the Free Software Foundation.
-# 
+#
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
-# 
+#
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
-# 
+#
 
 from __future__ import absolute_import
 
@@ -37,7 +37,7 @@
  * show-loom: Shows the threads in the loom. It currently does not show the
    # of commits in each thread, but it is planned to do that in the future.
 
- * down-thread: Move the branch down a thread. After doing this commits and 
+ * down-thread: Move the branch down a thread. After doing this commits and
    merges in this branch will affect the newly selected thread.
 
  * up-thread: Move the branch up a thread. This will merge in all the changes
@@ -47,11 +47,11 @@
  * combine-thread: Combine the current thread with the thread below it. If
    It is the last thread, this will currently refuse to operate, but in the
    future will just turn the loom into a normal branch again. Use this command
-   to remove a thread which has been merged into upstream. 
-
-
-Loom also adds new revision specifiers 'thread:' and 'below:'. You can use these
-to diff against threads in the current Loom. For instance, 'bzr diff -r
+   to remove a thread which has been merged into upstream.
+
+
+Loom also adds new revision specifiers 'thread:' and 'below:'. You can use
+these to diff against threads in the current Loom. For instance, 'bzr diff -r
 thread:' will show you the different between the thread below yours, and your
 thread. See ``bzr help revisionspec`` for the detailed help on these two
 revision specifiers.
@@ -69,6 +69,8 @@
 from breezy import branch as _mod_branch
 import breezy.builtins
 import breezy.commands
+from breezy.hooks import install_lazy_named_hook
+from breezy.revisionspec import revspec_registry
 
 from breezy.plugins.loom import (
     commands,
@@ -85,21 +87,22 @@
     'revert_loom',
     'show_loom',
     'up_thread',
-    ]:
-    breezy.commands.plugin_cmds.register_lazy('cmd_' + command, [],
+]:
+    breezy.commands.plugin_cmds.register_lazy(
+        'cmd_' + command, [],
         'breezy.plugins.loom.commands')
 
 # XXX: bzr fix needed: for switch, we have to register directly, not
 # lazily, because register_lazy does not stack in the same way register_command
 # does.
 if not hasattr(breezy.builtins, "cmd_switch"):
-    # provide a switch command (allows 
+    # provide a switch command (allows
     breezy.commands.register_command(getattr(commands, 'cmd_switch'))
 else:
     commands.cmd_switch._original_command = breezy.commands.register_command(
         getattr(commands, 'cmd_switch'), True)
 
-from breezy.hooks import install_lazy_named_hook
+
 def show_loom_summary(params):
     branch = getattr(params.new_tree, "branch", None)
     if branch is None:
@@ -111,22 +114,17 @@
         return
     params.to_file.write('Current thread: %s\n' % branch.nick)
 
-install_lazy_named_hook('breezy.status', 'hooks', 'post_status',
+
+install_lazy_named_hook(
+    'breezy.status', 'hooks', 'post_status',
     show_loom_summary, 'loom status')
 
-try:
-    from breezy.registry import register_lazy
-except ImportError: # bzr < 2.6
-    from breezy.revisionspec import revspec_registry
-    revspec_registry.register_lazy('thread:', 'breezy.plugins.loom.revspec',
-                                   'RevisionSpecThread')
-    revspec_registry.register_lazy('below:', 'breezy.plugins.loom.revspec',
-                                   'RevisionSpecBelow')
-else:
-    register_lazy("breezy.revisionspec", "revspec_registry", 'thread:',
-            'breezy.plugins.loom.revspec', 'RevisionSpecThread')
-    register_lazy("breezy.revisionspec", "revspec_registry", 'below:',
-            'breezy.plugins.loom.revspec', 'RevisionSpecBelow')
+
+revspec_registry.register_lazy('thread:', 'breezy.plugins.loom.revspec',
+                               'RevisionSpecThread')
+revspec_registry.register_lazy('below:', 'breezy.plugins.loom.revspec',
+                               'RevisionSpecBelow')
+
 
 _LOOM_FORMATS = {
     b"Bazaar-NG Loom branch format 1\n": "BzrBranchLoomFormat1",
@@ -137,8 +135,8 @@
 
 def register_formats():
     for format_string, kls in _LOOM_FORMATS.items():
-        _mod_branch.format_registry.register_lazy(format_string,
-                "breezy.plugins.loom.branch", kls)
+        _mod_branch.format_registry.register_lazy(
+            format_string, "breezy.plugins.loom.branch", kls)
 
 
 def require_loom_branch(branch):
@@ -151,15 +149,17 @@
 class NotALoom(breezy.errors.BzrError):
 
     _fmt = ("The branch %(branch)s is not a loom. "
-        "You can use 'bzr loomify' to make it into a loom.")
+            "You can use 'bzr loomify' to make it into a loom.")
 
     def __init__(self, branch):
         breezy.errors.BzrError.__init__(self)
         self.branch = branch
 
-#register loom formats
+
+# register loom formats
 register_formats()
 
+
 def test_suite():
     import breezy.plugins.loom.tests
     return breezy.plugins.loom.tests.test_suite()

=== modified file 'branch.py'
--- branch.py	2020-05-30 17:25:46 +0000
+++ branch.py	2022-08-19 17:04:03 +0000
@@ -1,26 +1,26 @@
 # Loom, a plugin for bzr to assist in developing focused patches.
 # Copyright (C) 2006 - 2008 Canonical Limited.
-# 
+#
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 2 as published
 # by the Free Software Foundation.
-# 
+#
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
-# 
+#
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
-# 
+#
 
 """The Loom Branch format.
 
 A Loom branch extends the behaviour of various methods to manage and propogate
-the Loom specific data. In the future it would be nice to have this data 
+the Loom specific data. In the future it would be nice to have this data
 registered with a normal bzr branch. That said, the branch format should still
-be specific to loom, to ensure people have the loom plugin when working on a 
+be specific to loom, to ensure people have the loom plugin when working on a
 loom branch.
 """
 
@@ -33,7 +33,6 @@
     commit as _mod_commit,
     controldir,
     errors,
-    symbol_versioning,
     trace,
     ui,
     urlutils,
@@ -56,12 +55,12 @@
     )
 
 
+from breezy.bzr.fullhistory import BzrBranch5, BzrBranchFormat5
+
+
 EMPTY_REVISION = b'empty:'
 
 
-from breezy.bzr.fullhistory import BzrBranch5, BzrBranchFormat5
-
-
 def create_thread(loom, thread_name):
     """Create a thread in the branch loom called thread."""
     require_loom_branch(loom)
@@ -102,7 +101,6 @@
         format.take_over(branch)
 
 
-
 class LoomThreadError(errors.BzrError):
     """Base class for Loom-Thread errors."""
 
@@ -114,7 +112,8 @@
 
 class UnrecordedRevision(errors.BzrError):
 
-    _fmt = """The revision %(revision_id)s is not recorded in the loom %(branch)s."""
+    _fmt = """The revision %(revision_id)s is not recorded in the loom \
+%(branch)s."""
 
     def __init__(self, branch, revision_id):
         errors.BzrError.__init__(self)
@@ -167,7 +166,7 @@
         self._inventory.add(loom_meta_ie)
         self._loom_stream = loom_stream
         self._loom_sha1 = loom_sha1
-    
+
     def get_file(self, path, file_id=None):
         """Get the content of file_id from this tree.
 
@@ -179,7 +178,7 @@
         return (self.get_file(path, file_id), None)
 
     def get_file_sha1(self, path, file_id=None, stat_value=None):
-        """Get the sha1 for a file. 
+        """Get the sha1 for a file.
 
         This tree only has one file, so it MUST be present!
         """
@@ -189,7 +188,7 @@
 
     def is_executable(self, path, file_id=None):
         """get the executable status for file_id.
-        
+
         Nothing in a LoomMetaTree is executable.
         """
         return False
@@ -218,7 +217,7 @@
                 self.generate_revision_history(breezy.revision.NULL_REVISION)
                 return
             # TODO, calculate the offset of removed threads.
-            # i.e. if there are ten threads removed, and current_index is 5, 
+            # i.e. if there are ten threads removed, and current_index is 5,
             # if 4 of the ten removed were 2,3,4,5, then the new index should
             # be 2.
             if len(threads) <= current_index:
@@ -251,10 +250,10 @@
         # Looms are not currently bindable.
         raise errors.UpgradeRequired(self.base)
 
-    def clone(self, to_controldir, revision_id=None, repository_policy=None, name=None,
-              tag_selector=None):
+    def clone(self, to_controldir, revision_id=None, repository_policy=None,
+              name=None, tag_selector=None):
         """Clone the branch into to_controldir.
-        
+
         This differs from the base clone by cloning the loom, setting the
         current nick to the top of the loom, not honouring any branch format
         selection on the target controldir, and ensuring that the format of
@@ -262,8 +261,9 @@
         """
         # If the target is a stackable repository, force-upgrade the
         # output loom format
-        if (isinstance(to_controldir, bzrdir.BzrDirMeta1) and
-            to_controldir._format.repository_format.supports_external_lookups):
+        if (isinstance(to_controldir, bzrdir.BzrDirMeta1)
+                and (to_controldir._format.repository_format.
+                     supports_external_lookups)):
             format = BzrBranchLoomFormat7()
         else:
             format = self._format
@@ -277,7 +277,7 @@
 
     def _get_checkout_format(self, lightweight=False):
         """Checking out a Loom gets a regular branch for now.
-        
+
         This is a short term measure to get to an all-tests passing status.
         """
         format = self.repository.controldir.checkout_metadir()
@@ -291,7 +291,7 @@
         reader = loom_io.LoomStateReader(current_content)
         state = loom_state.LoomState(reader)
         return state
-    
+
     def get_old_bound_location(self):
         """Return the URL of the branch we used to be bound to."""
         # No binding for looms yet.
@@ -303,10 +303,6 @@
         :param rev_id: A specific loom revision to retrieve.
         :return: a list of threads. e.g. [('threadname', 'last_revision')]
         """
-        if rev_id is None:
-            symbol_versioning.warn('NULL_REVISION should be used for the null'
-                ' revision instead of None, as of bzr 0.90.',
-                DeprecationWarning, stacklevel=2)
         if is_null(rev_id):
             return []
         content = self._loom_content(rev_id)
@@ -324,7 +320,8 @@
             user_location = urlutils.unescape_for_display(
                 thread_transport.base, 'utf-8')
             try:
-                control_dir = controldir.ControlDir.open(thread_transport.base,
+                control_dir = controldir.ControlDir.open(
+                    thread_transport.base,
                     possible_transports=[thread_transport])
                 tree, branch = control_dir._get_tree_branch()
             except errors.NotBranchError:
@@ -336,8 +333,8 @@
                     thread_transport.base)
             else:
                 if thread_revision == branch.last_revision():
-                    trace.note('Skipping up-to-date branch at %s'
-                                      % user_location)
+                    trace.note('Skipping up-to-date branch at %s',
+                               user_location)
                     continue
                 else:
                     trace.note('Updating branch at %s' % user_location)
@@ -413,7 +410,7 @@
         if not len(threads):
             # No threads at all - probably a default initialised loom in the
             # test suite.
-            return  self._set_nick(nick)
+            return self._set_nick(nick)
         current_index = state.thread_index(self.nick)
         threads[current_index] = (nick,) + threads[current_index][1:]
         state.set_threads(threads)
@@ -436,13 +433,14 @@
         return must_fetch, should_fetch
 
     def push(self, target, overwrite=False, stop_revision=None, lossy=False,
-        _override_hook_source_branch=None):
+             _override_hook_source_branch=None):
         # Not ideal, but see the issues raised on [e-mail]
         # about the push api needing work.
         with self.lock_read():
             if not isinstance(target, LoomSupport):
-                return super(LoomSupport, self).push(target, overwrite,
-                    stop_revision, lossy=lossy, _override_hook_source_branch=None)
+                return super(LoomSupport, self).push(
+                    target, overwrite, stop_revision, lossy=lossy,
+                    _override_hook_source_branch=None)
             if lossy:
                 raise errors.LossyPushToSameVCS(self, target)
             return _Pusher(self, target).transfer(overwrite, stop_revision,
@@ -475,16 +473,18 @@
             except IndexError:
                 basis_revid = breezy.revision.NULL_REVISION
             for unused in builder.record_iter_changes(
-                loom_tree, basis_revid,
-                loom_tree.iter_changes(self.repository.revision_tree(basis_revid))):
+                    loom_tree, basis_revid,
+                    loom_tree.iter_changes(
+                        self.repository.revision_tree(basis_revid))):
                 pass
             builder.finish_inventory()
             rev_id = builder.commit(commit_message)
             state.set_parents([rev_id])
-            state.set_threads((thread + ([thread[1]],) for thread in new_threads))
+            state.set_threads(
+                (thread + ([thread[1]],) for thread in new_threads))
             self._set_last_loom(state)
             return rev_id
-    
+
     def record_thread(self, thread_name, revision_id):
         """Record an updated version of an existing thread.
 
@@ -534,19 +534,19 @@
             # reset the parents list to just the basis.
             if basis_rev_id is not None:
                 state.set_parents([basis_rev_id])
-            self._adjust_nick_after_changing_threads(state.get_threads(), position)
+            self._adjust_nick_after_changing_threads(
+                state.get_threads(), position)
             self._set_last_loom(state)
 
     def revert_thread(self, thread):
         """Revert a single thread.
-        
+
         :param thread: the thread to restore to its state in
-            the basis. If it was not present in the basis it 
+            the basis. If it was not present in the basis it
             will be removed from the current loom.
         """
         with self.lock_write():
             state = self.get_loom_state()
-            parents = state.get_parents()
             threads = state.get_threads()
             position = state.thread_index(thread)
             basis_threads = self.get_threads(state.get_basis_revision_id())
@@ -574,8 +574,8 @@
         If at the end of the lock, the current revision in the branch is not
         recorded correctly in the loom, an automatic record is attempted.
         """
-        if (self.control_files._lock_count==1 and
-            self.control_files._lock_mode=='w'):
+        if (self.control_files._lock_count == 1
+                and self.control_files._lock_mode == 'w'):
             # about to release the lock
             state = self.get_loom_state()
             threads = state.get_threads()
@@ -645,10 +645,10 @@
         if new_rev == EMPTY_REVISION:
             new_rev = breezy.revision.NULL_REVISION
         fetch_spec = self.build_fetch_spec(stop_revision)
-        self.target.repository.fetch(self.source.repository,
-            fetch_spec=fetch_spec)
-        self.target.generate_revision_history(new_rev, self.target.last_revision(),
-            self.source)
+        self.target.repository.fetch(
+            self.source.repository, fetch_spec=fetch_spec)
+        self.target.generate_revision_history(
+                new_rev, self.target.last_revision(), self.source)
         tag_ret = self.source.tags.merge_to(self.target.tags)
         if isinstance(tag_ret, tuple):
             result.tag_updates, result.tag_conflicts = tag_ret
@@ -668,7 +668,8 @@
         return factory.make_fetch_spec()
 
     def transfer(self, overwrite, stop_revision, run_hooks=True,
-        possible_transports=None, _override_hook_target=None, local=False):
+                 possible_transports=None, _override_hook_target=None,
+                 local=False):
         """Implementation of push and pull"""
         if local:
             raise errors.LocalRequiresBoundBranch()
@@ -690,22 +691,20 @@
                     # is the loom compatible?
                     if len(my_state.get_parents()) > 0:
                         graph = self.source.repository.get_graph()
-                        if not graph.is_ancestor(my_state.get_parents()[0],
-                                source_loom_rev):
+                        if not graph.is_ancestor(
+                                my_state.get_parents()[0], source_loom_rev):
                             raise errors.DivergedBranches(
                                 self.target, self.source)
                 # fetch the loom content
-                self.target.repository.fetch(self.source.repository,
-                    revision_id=source_loom_rev)
+                self.target.repository.fetch(
+                    self.source.repository, revision_id=source_loom_rev)
                 # get the threads for the new basis
                 threads = self.target.get_threads(
                     source_state.get_basis_revision_id())
-                # stopping at from our repository.
-                revisions = [rev for name,rev in threads]
                 # fetch content for all threads and tags.
                 fetch_spec = self.build_fetch_spec(stop_revision)
-                self.target.repository.fetch(self.source.repository,
-                    fetch_spec=fetch_spec)
+                self.target.repository.fetch(
+                    self.source.repository, fetch_spec=fetch_spec)
                 # set our work threads to match (this is where we lose data if
                 # there are local mods)
                 my_state.set_threads(
@@ -747,7 +746,7 @@
 
 class LoomBranch(LoomSupport, BzrBranch5):
     """The Loom branch.
-    
+
     A mixin is used as the easiest migration path to support branch6. A
     delegated object may well be cleaner.
     """
@@ -778,7 +777,8 @@
     def initialize(self, a_controldir, name=None, repository=None,
                    append_revisions_only=None):
         """Create a branch of this format in a_controldir."""
-        super(LoomFormatMixin, self).initialize(a_controldir, name=name,
+        super(LoomFormatMixin, self).initialize(
+                a_controldir, name=name,
                 repository=repository,
                 append_revisions_only=append_revisions_only)
 
@@ -800,8 +800,9 @@
             control_files.unlock()
         return self.open(a_controldir, _found=True, name=name)
 
-    def open(self, a_controldir, name=None, _found=False, ignore_fallbacks=False,
-            found_repository=None, possible_transports=None):
+    def open(self, a_controldir, name=None, _found=False,
+             ignore_fallbacks=False,
+             found_repository=None, possible_transports=None):
         """Return the branch object for a_controldir
 
         _found is a private parameter, do not use it. It is used to indicate
@@ -812,19 +813,21 @@
         if name is None:
             name = a_controldir._get_selected_branch()
         if not _found:
-            format = breezy.branch.BranchFormat.find_format(a_controldir, name=name)
+            format = breezy.branch.BranchFormat.find_format(
+                a_controldir, name=name)
             assert format.__class__ == self.__class__
         transport = a_controldir.get_branch_transport(None, name=name)
         control_files = breezy.lockable_files.LockableFiles(
             transport, 'lock', breezy.lockdir.LockDir)
         if found_repository is None:
             found_repository = a_controldir.find_repository()
-        return self._branch_class()(_format=self,
-                          _control_files=control_files,
-                          a_controldir=a_controldir,
-                          _repository=found_repository,
-                          ignore_fallbacks=ignore_fallbacks,
-                          name=name)
+        return self._branch_class()(
+            _format=self,
+            _control_files=control_files,
+            a_controldir=a_controldir,
+            _repository=found_repository,
+            ignore_fallbacks=ignore_fallbacks,
+            name=name)
 
     def take_over(self, branch):
         """Take an existing breezy branch over into Loom format.
@@ -844,7 +847,6 @@
         branch._transport.put_file('last-loom', state_stream)
 
 
-
 class BzrBranchLoomFormat1(LoomFormatMixin, BzrBranchFormat5):
     """Loom's first format.
 
@@ -870,7 +872,7 @@
     def get_format_description(self):
         """See BranchFormat.get_format_description()."""
         return "Loom branch format 1"
-        
+
     def __str__(self):
         return "Bazaar-NG Loom format 1"
 
@@ -987,7 +989,8 @@
                 loom_tip = parents[0]
             else:
                 loom_tip = None
-            threads = self.get_threads(self.source, state.get_basis_revision_id())
+            threads = self.get_threads(
+                self.source, state.get_basis_revision_id())
             if revision_id not in (None, NULL_REVISION):
                 if threads:
                     # revision_id should be in the loom, or its an error
@@ -1006,13 +1009,13 @@
                 nested = ui.ui_factory.nested_progress_bar()
                 try:
                     if parents:
-                        self.target.repository.fetch(self.source.repository,
-                            revision_id=parents[0])
+                        self.target.repository.fetch(
+                            self.source.repository, revision_id=parents[0])
                     if threads:
                         for thread, rev_id in reversed(threads):
                             # fetch the loom content for this revision
-                            self.target.repository.fetch(self.source.repository,
-                                revision_id=rev_id)
+                            self.target.repository.fetch(
+                                self.source.repository, revision_id=rev_id)
                 finally:
                     nested.finished()
             state = loom_state.LoomState()
@@ -1048,8 +1051,8 @@
                     self.target.tags, seletor=tag_selector)
 
     def pull(self, overwrite=False, stop_revision=None,
-             run_hooks=True, possible_transports=None, _override_hook_target=None,
-             local=False, tag_selector=None):
+             run_hooks=True, possible_transports=None,
+             _override_hook_target=None, local=False, tag_selector=None):
         """Perform a pull, reading from self.source and writing to self.target.
 
         If the source branch is a non-loom branch, the pull is done against the
@@ -1058,10 +1061,11 @@
         """
         with self.lock_write():
             # Special code only needed when both source and targets are looms:
-            if (self.__class__.branch_is_loom(self.target) and
-                self.__class__.branch_is_loom(self.source)):
-                return _Puller(self.source, self.target).transfer(overwrite, stop_revision,
-                    run_hooks, possible_transports, _override_hook_target, local)
+            if (self.__class__.branch_is_loom(self.target)
+                    and self.__class__.branch_is_loom(self.source)):
+                return _Puller(self.source, self.target).transfer(
+                    overwrite, stop_revision, run_hooks, possible_transports,
+                    _override_hook_target, local)
             return super(InterLoomBranch, self).pull(
                 overwrite=overwrite, stop_revision=stop_revision,
                 possible_transports=possible_transports,

=== modified file 'commands.py'
--- commands.py	2019-08-22 19:36:40 +0000
+++ commands.py	2022-08-19 17:04:03 +0000
@@ -1,38 +1,30 @@
 # Loom, a plugin for bzr to assist in developing focused patches.
 # Copyright (C) 2006, 2008 Canonical Limited.
-# 
+#
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 2 as published
 # by the Free Software Foundation.
-# 
+#
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
-# 
+#
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
-# 
+#
 
 """Loom commands."""
 
-from __future__ import absolute_import
-
 from breezy import controldir, directory_service, workingtree
 import breezy.commands
 import breezy.branch
 from breezy import errors
-from breezy.lazy_import import lazy_import
 from breezy.option import Option
 import breezy.trace
 import breezy.transport
 
-lazy_import(globals(), """
-from breezy.plugins.loom import branch
-from breezy.plugins.loom.tree import LoomTreeDecorator
-""")
-
 
 class cmd_loomify(breezy.commands.Command):
     """Add a loom to this branch.
@@ -51,19 +43,17 @@
                             help='The name to use for the base thread.')]
 
     def run(self, location='.', base=None):
+        from breezy.plugins.loom.branch import loomify
         (target, path) = breezy.branch.Branch.open_containing(location)
-        target.lock_write()
-        try:
+        with target.lock_write():
             if base is not None:
                 target.nick = base
             elif not target.get_config().has_explicit_nickname():
-                raise errors.BzrCommandError(
+                raise errors.CommandError(
                     'You must specify --base or have a branch nickname set to'
                     ' loomify a branch')
-            branch.loomify(target)
+            loomify(target)
             loom = target.controldir.open_branch()
-        finally:
-            target.unlock()
         # requires a new lock as its a new instance, XXX: teach bzrdir about
         # format changes ?
         loom.new_thread(loom.nick)
@@ -71,10 +61,10 @@
 
 class cmd_combine_thread(breezy.commands.Command):
     __doc__ = """Combine the current thread with the thread below it.
-    
+
     This will currently refuse to operate on the last thread, but in the future
     will just turn the loom into a normal branch again.
-    
+
     Use combine-thread to remove a thread which has been merged into upstream.
 
     In precise terms this will:
@@ -84,51 +74,59 @@
 
     takes_options = [
         Option('force', help='Combine even if work in the thread is not '
-            'integrated up or down the loom.'),
+               'integrated up or down the loom.'),
         ]
 
     def run(self, force=False):
+        from breezy.plugins.loom.branch import (
+            require_loom_branch,
+            CannotCombineOnLastThread,
+            )
+        from breezy.plugins.loom.tree import LoomTreeDecorator
         (tree, path) = workingtree.WorkingTree.open_containing('.')
-        branch.require_loom_branch(tree.branch)
-        self.add_cleanup(tree.lock_write().unlock)
-        current_thread = tree.branch.nick
-        state = tree.branch.get_loom_state()
-        if not force:
-            # Check for unmerged work.
-            # XXX: Layering issue whom should be caring for the check, not the
-            # command thats for sure.
-            threads = state.get_threads()
-            current_index = state.thread_index(current_thread)
-            rev_below = None
-            rev_current = threads[current_index][1]
-            rev_above = None
-            if current_index:
-                # There is a thread below
-                rev_below = threads[current_index - 1][1]
-            if current_index < len(threads) - 1:
-                rev_above = threads[current_index + 1][1]
-            graph = tree.branch.repository.get_graph()
-            candidates = [rev for rev in
-                (rev_below, rev_current, rev_above) if rev]
-            heads = graph.heads(candidates)
-            # If current is not a head, its trivially merged, or
-            # if current is == rev_below, its also merged, or
-            # if there is only one thread its merged (well its not unmerged).
-            if (rev_current == rev_below or rev_current not in heads or
-                (rev_below is None and rev_above is None)):
-                merged = True
-            else:
-                merged = False
-            if not merged:
-                raise errors.BzrCommandError("Thread '%s' has unmerged work"
-                    ". Use --force to combine anyway." % current_thread)
-        new_thread = state.get_new_thread_after_deleting(current_thread)
-        if new_thread is None:
-            raise branch.CannotCombineOnLastThread
-        breezy.trace.note("Combining thread '%s' into '%s'",
-            current_thread, new_thread)
-        LoomTreeDecorator(tree).down_thread(new_thread)
-        tree.branch.remove_thread(current_thread)
+        require_loom_branch(tree.branch)
+        with tree.lock_write():
+            current_thread = tree.branch.nick
+            state = tree.branch.get_loom_state()
+            if not force:
+                # Check for unmerged work.
+                # XXX: Layering issue whom should be caring for the check, not
+                # the command thats for sure.
+                threads = state.get_threads()
+                current_index = state.thread_index(current_thread)
+                rev_below = None
+                rev_current = threads[current_index][1]
+                rev_above = None
+                if current_index:
+                    # There is a thread below
+                    rev_below = threads[current_index - 1][1]
+                if current_index < len(threads) - 1:
+                    rev_above = threads[current_index + 1][1]
+                graph = tree.branch.repository.get_graph()
+                candidates = [
+                    rev for rev in (rev_below, rev_current, rev_above) if rev]
+                heads = graph.heads(candidates)
+                # If current is not a head, its trivially merged, or
+                # if current is == rev_below, its also merged, or
+                # if there is only one thread its merged (well its not
+                # unmerged).
+                if (rev_current == rev_below or rev_current not in heads
+                        or (rev_below is None and rev_above is None)):
+                    merged = True
+                else:
+                    merged = False
+                if not merged:
+                    raise errors.CommandError(
+                        "Thread '%s' has unmerged work"
+                        ". Use --force to combine anyway." % current_thread)
+            new_thread = state.get_new_thread_after_deleting(current_thread)
+            if new_thread is None:
+                raise CannotCombineOnLastThread()
+            breezy.trace.note(
+                "Combining thread '%s' into '%s'",
+                current_thread, new_thread)
+            LoomTreeDecorator(tree).down_thread(new_thread)
+            tree.branch.remove_thread(current_thread)
 
 
 class cmd_create_thread(breezy.commands.Command):
@@ -146,8 +144,9 @@
     takes_args = ['thread']
 
     def run(self, thread):
+        from breezy.plugins.loom.branch import create_thread
         (loom, path) = breezy.branch.Branch.open_containing('.')
-        branch.create_thread(loom, thread)
+        create_thread(loom, thread)
 
 
 class cmd_show_loom(breezy.commands.Command):
@@ -161,10 +160,10 @@
     takes_args = ['location?']
 
     def run(self, location='.'):
+        from breezy.plugins.loom.branch import require_loom_branch
         (loom, path) = breezy.branch.Branch.open_containing(location)
-        branch.require_loom_branch(loom)
-        loom.lock_read()
-        try:
+        require_loom_branch(loom)
+        with loom.lock_read():
             threads = loom.get_loom_state().get_threads()
             nick = loom.nick
             for thread, revid, parents in reversed(threads):
@@ -173,20 +172,18 @@
                 else:
                     symbol = '  '
                 self.outf.write(symbol + thread + '\n')
-        finally:
-            loom.unlock()
 
 
 class cmd_switch(breezy.builtins.cmd_switch):
     """Set the branch of a checkout and update.
- 
+
     For looms, this is equivalent to 'down-thread' when to_location is the name
     of a thread in the loom.
     For lightweight checkouts, this changes the branch being referenced.
     For heavyweight checkouts, this checks that there are no local commits
     versus the current bound branch, then it makes the local branch a mirror
     of the new location and binds to it.
-    
+
     In both cases, the working tree is updated and uncommitted changes
     are merged. The user can commit or revert these as they desire.
 
@@ -211,6 +208,12 @@
 
     def run(self, to_location=None, force=False, create_branch=False,
             revision=None, directory=None):
+        from breezy.plugins.loom.branch import (
+            create_thread,
+            NoSuchThread,
+            NotALoom,
+            )
+        from breezy.plugins.loom.tree import LoomTreeDecorator
         # The top of this is cribbed from bzr; because bzr isn't factored out
         # enough.
         if directory is None:
@@ -218,7 +221,7 @@
         control_dir, path = controldir.ControlDir.open_containing(directory)
         if to_location is None:
             if revision is None:
-                raise errors.BzrCommandError(
+                raise errors.CommandError(
                     'You must supply either a revision or a location')
             to_location = '.'
         try:
@@ -227,7 +230,7 @@
             from_branch = None
         if create_branch:
             if from_branch is None:
-                raise errors.BzrCommandError(
+                raise errors.CommandError(
                     'cannot create branch without source branch')
             to_location = directory_service.directories.dereference(
                 to_location)
@@ -237,10 +240,10 @@
             tree = LoomTreeDecorator(tree)
             try:
                 if create_branch:
-                    return branch.create_thread(tree.branch, to_location)
+                    return create_thread(tree.branch, to_location)
                 thread_name = self._get_thread_name(tree.branch, to_location)
                 return tree.down_thread(thread_name)
-            except (AttributeError, branch.NoSuchThread, branch.NotALoom):
+            except (AttributeError, NoSuchThread, NotALoom):
                 # When there is no thread its probably an external branch
                 # that we have been given.
                 raise errors.MustUseDecorated
@@ -250,7 +253,7 @@
 
     def run_argv_aliases(self, argv, alias_argv=None):
         """Parse command line and run.
-        
+
         If the command requests it, run the decorated version.
         """
         try:
@@ -262,20 +265,22 @@
 
 
 class cmd_record(breezy.commands.Command):
-    """Record the current last-revision of this tree into the current thread."""
+    """Record the current last-revision of this tree into the current thread.
+    """
 
     takes_args = ['message']
 
     def run(self, message):
+        from breezy.plugins.loom.branch import require_loom_branch
         (abranch, path) = breezy.branch.Branch.open_containing('.')
-        branch.require_loom_branch(abranch)
+        require_loom_branch(abranch)
         abranch.record_loom(message)
         breezy.trace.note("Loom recorded.")
 
 
 class cmd_revert_loom(breezy.commands.Command):
     """Revert part or all of a loom.
-    
+
     This will update the current loom to be the same as the basis when --all
     is supplied. If no parameters or options are supplied then nothing will
     happen. If a thread is named, then only that thread is reverted to its
@@ -283,16 +288,17 @@
     """
 
     takes_args = ['thread?']
-    takes_options = [Option('all',
-                        help='Revert all threads.'),
+    takes_options = [Option('all', help='Revert all threads.'),
                      ]
 
     def run(self, thread=None, all=None):
         if thread is None and all is None:
             breezy.trace.note('Please see revert-loom -h.')
             return
+        from breezy.plugins.loom.branch import require_loom_branch
+        from breezy.plugins.loom.tree import LoomTreeDecorator
         (tree, path) = workingtree.WorkingTree.open_containing('.')
-        branch.require_loom_branch(tree.branch)
+        require_loom_branch(tree.branch)
         tree = LoomTreeDecorator(tree)
         if all:
             tree.revert_loom()
@@ -317,22 +323,18 @@
     _see_also = ['switch', 'up-thread']
 
     def run(self, thread=None):
+        from breezy.plugins.loom.branch import require_loom_branch
+        from breezy.plugins.loom.tree import LoomTreeDecorator
         (wt, path) = workingtree.WorkingTree.open_containing('.')
-        branch.require_loom_branch(wt.branch)
+        require_loom_branch(wt.branch)
         tree = LoomTreeDecorator(wt)
-        tree.lock_write()
-        try:
+        with tree.lock_write():
             basis = wt.basis_tree()
-            basis.lock_read()
-            try:
+            with basis.lock_read():
                 for change in wt.iter_changes(basis):
-                    raise errors.BzrCommandError(
+                    raise errors.CommandError(
                         'Working tree has uncommitted changes.')
-            finally:
-                basis.unlock()
             return tree.down_thread(thread)
-        finally:
-            tree.unlock()
 
 
 class cmd_up_thread(breezy.commands.Command):
@@ -346,20 +348,23 @@
 
     takes_args = ['thread?']
 
-    takes_options = ['merge-type', Option('auto',
-        help='Deprecated - now the default.'),
-        Option('manual', help='Perform commit manually.'),
+    takes_options = ['merge-type', Option(
+                'auto',
+                help='Deprecated - now the default.'),
+            Option('manual', help='Perform commit manually.'),
         ]
 
     _see_also = ['down-thread', 'switch']
 
     def run(self, merge_type=None, manual=False, thread=None, auto=None):
+        from breezy.plugins.loom.branch import require_loom_branch
+        from breezy.plugins.loom.tree import LoomTreeDecorator
         (tree, path) = workingtree.WorkingTree.open_containing('.')
-        branch.require_loom_branch(tree.branch)
+        require_loom_branch(tree.branch)
         tree = LoomTreeDecorator(tree)
         if manual:
             if thread is not None:
-                raise errors.BzrCommandError('Specifying a thread does not'
+                raise errors.CommandError('Specifying a thread does not'
                                              ' work with --manual.')
             return tree.up_thread(merge_type)
         else:
@@ -385,8 +390,8 @@
         if location is None:
             location = loom.get_config().get_user_option('export_loom_root')
         if location is None:
-            raise errors.BzrCommandError('No export root known or specified.')
-        root_transport = breezy.transport.get_transport(location,
-            possible_transports=[loom.controldir.root_transport])
+            raise errors.CommandError('No export root known or specified.')
+        root_transport = breezy.transport.get_transport(
+            location, possible_transports=[loom.controldir.root_transport])
         root_transport.ensure_base()
         loom.export_threads(root_transport)

=== modified file 'loom_io.py'
--- loom_io.py	2019-08-22 19:36:40 +0000
+++ loom_io.py	2022-08-19 17:04:03 +0000
@@ -1,19 +1,19 @@
 # Loom, a plugin for bzr to assist in developing focused patches.
 # Copyright (C) 2006 Canonical Limited.
-# 
+#
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 2 as published
 # by the Free Software Foundation.
-# 
+#
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
-# 
+#
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
-# 
+#
 
 
 """Routines for reading and writing Looms in streams."""
@@ -86,7 +86,7 @@
     def __init__(self, stream):
         """Initialise a LoomStateReader with a serialised loom-state stream.
 
-        :param stream: The stream that contains a loom-state object. This 
+        :param stream: The stream that contains a loom-state object. This
             should allow relative seeking.
         """
         self._stream = stream
@@ -107,12 +107,13 @@
             # for the reader that is looked up on this format string.
             # either way, its in the future.
             assert self._content[0] == _CURRENT_LOOM_FORMAT_STRING, \
-                    "%r != %r" % (self._content[0], _CURRENT_LOOM_FORMAT_STRING)
+                "%r != %r" % (self._content[0], _CURRENT_LOOM_FORMAT_STRING)
 
     def read_parents(self):
         """Read the parents field from the stream.
-        
-        :return: a list of parent revision ids.
+
+        Returns:
+          a list of parent revision ids.
         """
         self._read()
         return self._content[1].split()
@@ -120,15 +121,16 @@
     def read_thread_details(self):
         """Read the details for the threads.
 
-        :return: a list of thread details. Each thread detail is a 3-tuple
+        Returns:
+            a list of thread details. Each thread detail is a 3-tuple
             containing the thread name, the current thread revision, and a
             list of parent thread revisions, in the same order and length
-            as the list returned by read_parents. In the parent thread 
-            revision list, None means 'no present in the parent', and 
+            as the list returned by read_parents. In the parent thread
+            revision list, None means 'no present in the parent', and
             'null:' means 'present but had no commits'.
         """
         result = []
-        parent_count = len(self.read_parents())
+        len(self.read_parents())
         # skip the format and parent lines, and the trailing \n line.
         for line in self._content[2:-1]:
             conflict_status, line = line.split(b' ', 1)

=== modified file 'loom_state.py'
--- loom_state.py	2018-05-20 13:59:05 +0000
+++ loom_state.py	2022-08-19 17:04:03 +0000
@@ -1,19 +1,19 @@
 # Loom, a plugin for bzr to assist in developing focused patches.
 # Copyright (C) 2006, 2008 Canonical Limited.
-# 
+#
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 2 as published
 # by the Free Software Foundation.
-# 
+#
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
-# 
+#
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
-# 
+#
 
 
 """The current-loom state object."""
@@ -25,7 +25,7 @@
 
 class LoomState(object):
     """The LoomState represents the content of the current-loom branch file.
-    
+
     It is planned to not need access to repository data - it will be driven
     by the LoomBranch and have data fed into it.
     """
@@ -53,7 +53,7 @@
             return NULL_REVISION
         else:
             return self._parents[0]
- 
+
     def get_parents(self):
         """Get the list of loom revisions that are parents to this state."""
         return self._parents
@@ -63,9 +63,9 @@
         return list(self._threads)
 
     def get_threads_dict(self):
-        """Get the threads as a dict. 
+        """Get the threads as a dict.
 
-        This loses ordering, but is useful for quickly locating the details on 
+        This loses ordering, but is useful for quickly locating the details on
         a given thread.
         """
         return dict((thread[0], thread[1:]) for thread in self._threads)
@@ -100,8 +100,9 @@
     def set_threads(self, threads):
         """Set the current threads to threads.
 
-        :param threads: A list of (name, revid) pairs that make up the threads.
-            If the list is altered after calling set_threads, there is no 
+        Args:
+          threads: A list of (name, revid) pairs that make up the threads.
+            If the list is altered after calling set_threads, there is no
             effect on the LoomState.
         """
         self._threads = list(threads)

=== modified file 'releaser.conf'
--- releaser.conf	2022-08-19 16:24:40 +0000
+++ releaser.conf	2022-08-19 17:04:03 +0000
@@ -2,7 +2,7 @@
 news_file: "NEWS"
 timeout_days: 5
 tag_name: "brz-loom-$VERSION"
-verify_command: "flake8 && make check"
+verify_command: "flake8 && BRZ_PLUGINS_AT=loom@`pwd` brz selftest -s bp.loom"
 update_version {
   path: "setup.py"
   new_line: "          version=\"$VERSION\","

=== modified file 'revspec.py'
--- revspec.py	2018-05-20 13:59:05 +0000
+++ revspec.py	2022-08-19 17:04:03 +0000
@@ -1,19 +1,19 @@
 # Loom, a plugin for bzr to assist in developing focused patches.
 # Copyright (C) 2006, 2008 Canonical Limited.
-# 
+#
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 2 as published
 # by the Free Software Foundation.
-# 
+#
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
-# 
+#
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
-# 
+#
 
 """Loom specific revision-specifiers."""
 
@@ -28,17 +28,14 @@
     """A revision spec that needs a loom."""
 
     def _match_on(self, branch, revs):
-         return RevisionInfo(branch, None, self._as_revision_id(branch))
+        return RevisionInfo(branch, None, self._as_revision_id(branch))
 
     def _as_revision_id(self, branch):
         require_loom_branch(branch)
-        branch.lock_read()
-        try:
+        with branch.lock_read():
             state = branch.get_loom_state()
             threads = state.get_threads()
             return self._as_thread_revision_id(branch, state, threads)
-        finally:
-            branch.unlock()
 
 
 class RevisionSpecBelow(LoomRevisionSpec):
@@ -46,7 +43,7 @@
 
     help_txt = """Selects the tip of the thread below a thread from a loom.
 
-    Selects the tip of the thread below a thread in a loom.  
+    Selects the tip of the thread below a thread in a loom.
 
     Examples::
 
@@ -77,7 +74,7 @@
 
     help_txt = """Selects the tip of a thread from a loom.
 
-    Selects the tip of a thread in a loom.  
+    Selects the tip of a thread in a loom.
 
     Examples::
 
@@ -100,6 +97,3 @@
             if index < 0:
                 raise NoLowerThread()
         return threads[index][1]
-
-
-

=== modified file 'setup.py'
--- setup.py	2022-08-08 12:17:24 +0000
+++ setup.py	2022-08-19 17:04:03 +0000
@@ -20,7 +20,6 @@
     "Bazaar-NG Loom branch format 6\n": "Loom branch format 6",
     }
 
-from version import *
 
 if __name__ == '__main__':
     setup(name="brz-loom",

=== modified file 'tests/__init__.py'
--- tests/__init__.py	2018-05-20 13:59:05 +0000
+++ tests/__init__.py	2022-08-19 17:04:03 +0000
@@ -1,19 +1,19 @@
 # Loom, a plugin for bzr to assist in developing focused patches.
 # Copyright (C) 2006 Canonical Limited.
-# 
+#
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 2 as published
 # by the Free Software Foundation.
-# 
+#
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
-# 
+#
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
-# 
+#
 
 
 """Tests for the loom plugin."""
@@ -21,7 +21,7 @@
 
 import breezy.plugins.loom.branch
 from breezy.tests import TestCaseWithTransport
-from breezy.tests.TestUtil import TestLoader, TestSuite
+from breezy.tests.TestUtil import TestLoader
 from breezy.workingtree import WorkingTree
 
 
@@ -47,4 +47,3 @@
         tree = WorkingTree.open(path)
         breezy.plugins.loom.branch.loomify(tree.branch)
         return tree.controldir.open_workingtree()
-

=== modified file 'tests/blackbox.py'
--- tests/blackbox.py	2019-08-22 19:36:40 +0000
+++ tests/blackbox.py	2022-08-19 17:04:03 +0000
@@ -1,19 +1,19 @@
 # Loom, a plugin for bzr to assist in developing focused patches.
 # Copyright (C) 2006, 2008 Canonical Limited.
-# 
+#
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 2 as published
 # by the Free Software Foundation.
-# 
+#
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
-# 
+#
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
-# 
+#
 
 
 """UI tests for loom."""
@@ -42,8 +42,8 @@
 
     def get_vendor_loom(self, path='.'):
         """Make a loom with a vendor thread.
-        
-        This returns a loom with a vendor thread, which has the current 
+
+        This returns a loom with a vendor thread, which has the current
         commit recorded in it, but nothing in the basis loom - its
         empty.
         """
@@ -54,7 +54,8 @@
         return tree.controldir.open_workingtree()
 
     def assert_exception_raised_on_non_loom_branch(self, args):
-        """Helper to check UserError gets raised when commands are run in a non-loomed branch."""
+        """Helper to check UserError gets raised when commands are run in a
+        non-loomed branch."""
         tree = self.make_branch_and_tree('.')
         tree.branch.nick = 'somenick'
         out, err = self.run_bzr(args, retcode=3)
@@ -65,7 +66,7 @@
 class TestLoomify(TestCaseWithLoom):
 
     def test_loomify_new_branch(self):
-        b = self.make_branch('.')
+        self.make_branch('.')
         out, err = self.run_bzr(['loomify'], retcode=3)
         self.assertEqual('', out)
         self.assertEqual(
@@ -135,8 +136,10 @@
         self.assertEqual('feature-foo', tree.branch.nick)
 
     def test_create_thread_on_non_loomed_branch(self):
-        """We should raise a user-friendly exception if the branch isn't loomed yet."""
-        self.assert_exception_raised_on_non_loom_branch(['create-thread', 'some-thread'])
+        """We should raise a user-friendly exception if the branch isn't loomed
+        yet."""
+        self.assert_exception_raised_on_non_loom_branch(
+            ['create-thread', 'some-thread'])
 
 
 class TestShow(TestsWithLooms):
@@ -156,7 +159,7 @@
 
     def test_show_loom_with_location(self):
         """Should be able to provide an explicit location to show."""
-        tree = self.get_vendor_loom('subtree')
+        self.get_vendor_loom('subtree')
         self.assertShowLoom(['vendor'], 'vendor', 'subtree')
 
     def assertShowLoom(self, threads, selected_thread, location=None):
@@ -178,7 +181,8 @@
         self.assertEqual('', err)
 
     def test_show_loom_on_non_loomed_branch(self):
-        """We should raise a user-friendly exception if the branch isn't loomed yet."""
+        """We should raise a user-friendly exception if the branch isn't loomed
+        yet."""
         self.assert_exception_raised_on_non_loom_branch(['show-loom'])
 
 
@@ -188,14 +192,11 @@
         super(TestStatus, self).setUp()
         # The test suite resets after each run, so manually register
         # the loom status hook.
-        try:
-            from breezy.hooks import install_lazy_named_hook
-        except ImportError:
-            pass
-        else:
-            from breezy.plugins.loom import show_loom_summary
-            install_lazy_named_hook('breezy.status', 'hooks', 'post_status',
-                show_loom_summary, 'loom status')
+        from breezy.hooks import install_lazy_named_hook
+        from breezy.plugins.loom import show_loom_summary
+        install_lazy_named_hook(
+            'breezy.status', 'hooks', 'post_status',
+            show_loom_summary, 'loom status')
 
     def test_status_shows_current_thread(self):
         # 'bzr status' shows the current thread.
@@ -219,7 +220,7 @@
     def test_status_on_non_loom_doesnt_error(self):
         # 'bzr status' on a non-loom doesn't error, despite the decoration
         # we've added.
-        tree = self.make_branch_and_tree('.')
+        self.make_branch_and_tree('.')
         out, err = self.run_bzr(['status'], retcode=0)
         self.assertEqual('', out)
         self.assertEqual('', err)
@@ -295,7 +296,7 @@
 
     def test_record_no_change(self):
         """If there are no changes record should error."""
-        tree = self.get_tree_with_loom()
+        self.get_tree_with_loom()
         out, err = self.run_bzr(['record', 'Try to commit.'], retcode=3)
         self.assertEqual('', out)
         self.assertEqual(
@@ -311,18 +312,21 @@
         self.assertEqual('', out)
 
     def test_record_on_non_loomed_branch(self):
-        """We should raise a user-friendly exception if the branch isn't loomed yet."""
-        self.assert_exception_raised_on_non_loom_branch(['record', 'some message'])
+        """We should raise a user-friendly exception if the branch isn't loomed
+        yet."""
+        self.assert_exception_raised_on_non_loom_branch(
+            ['record', 'some message'])
 
 
 class TestDown(TestsWithLooms):
 
     def test_down_thread_from_bottom(self):
-        tree = self.get_vendor_loom()
+        self.get_vendor_loom()
         out, err = self.run_bzr(['down-thread'], retcode=3)
         self.assertEqual('', out)
-        self.assertEqual('brz: ERROR: Cannot move down from the lowest thread.\n', err)
-        
+        self.assertEqual(
+            'brz: ERROR: Cannot move down from the lowest thread.\n', err)
+
     def test_down_thread_same_revision(self):
         """moving down when the revision is unchanged should work."""
         tree = self.get_vendor_loom()
@@ -334,7 +338,7 @@
         self.assertEqual("Moved to thread 'vendor'.\n", err)
         self.assertEqual('vendor', tree.branch.nick)
         self.assertEqual(rev, tree.last_revision())
-        
+
     def test_down_thread_removes_changes_between_threads(self):
         tree = self.get_vendor_loom()
         tree.branch.new_thread('patch')
@@ -357,12 +361,14 @@
         self.assertFalse(tree.has_filename('afile'))
 
     def test_down_thread_switches_history_ok(self):
-        """Do a down thread when the lower patch is not in the r-h of the old."""
+        """Do a down thread when the lower patch is not in the r-h of the
+        old."""
         tree = self.get_vendor_loom()
         tree.branch.new_thread('patch')
         tree.branch._set_nick('vendor')
         # do a null change in vendor - a new release.
-        vendor_release = tree.commit('new vendor release.', allow_pointless=True)
+        vendor_release = tree.commit(
+            'new vendor release.', allow_pointless=True)
         # pop up, then down
         self.run_bzr(['up-thread'])
         self.run_bzr(['revert'])
@@ -406,7 +412,8 @@
         self.assertEqual(None, tree.path2id('patch2'))
 
     def test_down_thread_on_non_loomed_branch(self):
-        """We should raise a user-friendly exception if the branch isn't loomed yet."""
+        """We should raise a user-friendly exception if the branch isn't loomed
+        yet."""
         self.assert_exception_raised_on_non_loom_branch(['down-thread'])
 
     def test_down_thread_with_changes(self):
@@ -424,7 +431,7 @@
 class TestUp(TestsWithLooms):
 
     def test_up_thread_from_top(self):
-        tree = self.get_vendor_loom()
+        self.get_vendor_loom()
         out, err = self.run_bzr(['up-thread'], retcode=3)
         self.assertEqual('', out)
         self.assertEqual(
@@ -493,7 +500,8 @@
         out, err = self.run_bzr(['up-thread'], retcode=1)
         self.assertEqual('', out)
         self.assertEqual(
-            'Conflict adding file afile.  Moved existing file to afile.moved.\n'
+            'Conflict adding file afile.  '
+            'Moved existing file to afile.moved.\n'
             '1 conflicts encountered.\n'
             "Moved to thread 'patch'.\n", err)
         self.assertEqual('patch', tree.branch.nick)
@@ -507,11 +515,12 @@
         self.assertEqual([patch_rev, vendor_release], tree.get_parent_ids())
 
     def test_up_thread_on_non_loomed_branch(self):
-        """We should raise a user-friendly exception if the branch isn't loomed yet."""
+        """We should raise a user-friendly exception if the branch isn't loomed
+        yet."""
         self.assert_exception_raised_on_non_loom_branch(['up-thread'])
 
     def test_up_thread_accepts_merge_type(self):
-        tree = self.get_vendor_loom()
+        self.get_vendor_loom()
         self.run_bzr(['create-thread', 'top'])
         self.run_bzr(['down-thread'])
         self.run_bzr(['up-thread', '--lca'])
@@ -526,11 +535,11 @@
 
     def test_up_with_clean_merge_leaving_thread_empty(self):
         """This tests what happens when a thread becomes empty.
-        
+
         A thread becomes empty when all its changes are included in
         a lower thread, and so its diff to the thread below contains
         nothing.
-        
+
         The user should be warned when this happens.
         """
         tree = self.get_vendor_loom()
@@ -549,10 +558,11 @@
             f.write(b'new contents of afile\n')
         vendor_release = tree.commit('make the same change to afile')
         # check that the trees no longer differ after the up merge,
-        # and that we are 
+        # and that we are
         out, err = self.run_bzr(['up-thread', '--manual'])
         self.assertEqual('', out)
-        self.assertStartsWith(err,
+        self.assertStartsWith(
+            err,
             "All changes applied successfully.\n"
             "Moved to thread 'patch'.\n"
             'This thread is now empty, you may wish to run "bzr '
@@ -645,14 +655,14 @@
 
     def test_revert_loom(self):
         """bzr revert-loom should give help."""
-        tree = self.get_vendor_loom()
+        self.get_vendor_loom()
         out, err = self.run_bzr(['revert-loom'])
         self.assertEqual('', out)
         self.assertEqual('Please see revert-loom -h.\n', err)
 
     def test_revert_loom_missing_thread(self):
         """bzr revert-loom missing-thread should give an error."""
-        tree = self.get_vendor_loom()
+        self.get_vendor_loom()
         out, err = self.run_bzr(['revert-loom', 'unknown-thread'], retcode=3)
         self.assertEqual('', out)
         self.assertEqual("brz: ERROR: No such thread 'unknown-thread'.\n", err)
@@ -672,11 +682,12 @@
         self.assertNotEqual(last_rev, tree.last_revision())
         self.assertEqual(NULL_REVISION, tree.last_revision())
         self.assertEqual([], tree.branch.get_loom_state().get_threads())
-        
+
     def test_revert_thread(self):
-        """bzr revert-loom threadname should restore the state of that thread."""
-        # we want a loom with > 1 threads, with a change made to a thread we are
-        # not in, so we can revert that by name,
+        """bzr revert-loom threadname should restore the state of that
+        thread."""
+        # we want a loom with > 1 threads, with a change made to a thread we
+        # are not in, so we can revert that by name,
         tree = self.get_vendor_loom()
         tree.branch.new_thread('after-vendor')
         tree.branch._set_nick('after-vendor')
@@ -691,11 +702,14 @@
         self.assertEqual('', out)
         self.assertEqual("thread 'after-vendor' reverted.\n", err)
         self.assertEqual(last_rev, tree.last_revision())
-        self.assertEqual(old_threads, tree.branch.get_loom_state().get_threads())
+        self.assertEqual(
+            old_threads, tree.branch.get_loom_state().get_threads())
 
     def test_revert_loom_on_non_loomed_branch(self):
-        """We should raise a user-friendly exception if the branch isn't loomed yet."""
-        self.assert_exception_raised_on_non_loom_branch(['revert-loom', 'foobar'])
+        """We should raise a user-friendly exception if the branch isn't loomed
+        yet."""
+        self.assert_exception_raised_on_non_loom_branch(
+            ['revert-loom', 'foobar'])
 
 
 class TestCombineThread(TestsWithLooms):
@@ -703,10 +717,11 @@
 
     def test_combine_last_thread(self):
         """Doing combine thread on the last thread is an error for now."""
-        tree = self.get_vendor_loom()
+        self.get_vendor_loom()
         out, err = self.run_bzr(['combine-thread'], retcode=3)
         self.assertEqual('', out)
-        self.assertEqual('brz: ERROR: Cannot combine threads on the bottom thread.\n', err)
+        self.assertEqual(
+            'brz: ERROR: Cannot combine threads on the bottom thread.\n', err)
 
     def get_two_thread_loom(self):
         tree = self.get_vendor_loom()
@@ -763,8 +778,10 @@
         unique_revid = tree.last_revision()
         out, err = self.run_bzr(['combine-thread'], retcode=3)
         self.assertEqual('', out)
-        self.assertEqual("brz: ERROR: "
-"Thread 'unique-thread' has unmerged work. Use --force to combine anyway.\n",
+        self.assertEqual(
+            "brz: ERROR: "
+            "Thread 'unique-thread' has unmerged work. "
+            "Use --force to combine anyway.\n",
             err)
         self.assertEqual(unique_revid, tree.last_revision())
         self.assertEqual('unique-thread', tree.branch.nick)
@@ -772,9 +789,9 @@
     def test_combine_last_two_threads(self):
         """Doing a combine on two threads gives you just the bottom one."""
         tree, loom_tree = self.get_two_thread_loom()
-        # now we have a change between the threads, so merge this into the lower
-        # thread to simulate real-world - different rev ids, and the lower
-        # thread has merged the upper.
+        # now we have a change between the threads, so merge this into the
+        # lower thread to simulate real-world - different rev ids, and the
+        # lower thread has merged the upper.
         # ugh, should make merge easier to use.
         self.run_bzr(['merge', '-r', 'thread:above-vendor', '.'])
         vendor_revid = tree.commit('merge in the above-vendor work.')
@@ -798,7 +815,8 @@
         self.assertEqual(b'above-vendor-1', tree.last_revision())
 
     def test_combine_thread_on_non_loomed_branch(self):
-        """We should raise a user-friendly exception if the branch isn't loomed yet."""
+        """We should raise a user-friendly exception if the branch isn't loomed
+        yet."""
         self.assert_exception_raised_on_non_loom_branch(['combine-thread'])
 
 
@@ -807,10 +825,10 @@
 
     def test_export_loom_no_args(self):
         """Test exporting with no arguments"""
-        tree = self.get_vendor_loom()
+        self.get_vendor_loom()
         err = self.run_bzr(['export-loom'], retcode=3)[1]
-        self.assertContainsRe(err,
-            'brz: ERROR: No export root known or specified.')
+        self.assertContainsRe(
+            err, 'brz: ERROR: No export root known or specified.')
 
     def test_export_loom_config(self):
         tree = self.get_vendor_loom()
@@ -820,6 +838,6 @@
 
     def test_export_loom_path(self):
         """Test exporting with specified path"""
-        tree = self.get_vendor_loom()
+        self.get_vendor_loom()
         self.run_bzr(['export-loom', 'export-path'])
-        branch = breezy.branch.Branch.open('export-path/vendor')
+        breezy.branch.Branch.open('export-path/vendor')

=== modified file 'tests/test_branch.py'
--- tests/test_branch.py	2019-08-22 19:36:40 +0000
+++ tests/test_branch.py	2022-08-19 17:04:03 +0000
@@ -1,19 +1,19 @@
 # Loom, a plugin for bzr to assist in developing focused patches.
 # Copyright (C) 2006 Canonical Limited.
-# 
+#
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 2 as published
 # by the Free Software Foundation.
-# 
+#
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
-# 
+#
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
-# 
+#
 
 
 """Tests of the loom Branch related routines."""
@@ -49,11 +49,10 @@
         bzrdir = self.make_controldir('.')
         bzrdir.create_repository()
         format = breezy.plugins.loom.branch.BzrBranchLoomFormat1()
-        branch = format.initialize(bzrdir)
+        format.initialize(bzrdir)
         self.assertFileEqual('Loom current 1\n\n', '.bzr/branch/last-loom')
 
 
-
 class StubFormat(object):
 
     def network_name(self):
@@ -145,21 +144,24 @@
     def test_loomify_branch_format_5(self):
         branch = self.make_branch('.', format='dirstate')
         loomify(branch)
-        self.assertConvertedBranchFormat(branch,
+        self.assertConvertedBranchFormat(
+            branch,
             breezy.plugins.loom.branch.LoomBranch,
             breezy.plugins.loom.branch.BzrBranchLoomFormat1)
 
     def test_loomify_branch_format_6(self):
         branch = self.make_branch('.', format='dirstate-tags')
         loomify(branch)
-        self.assertConvertedBranchFormat(branch,
+        self.assertConvertedBranchFormat(
+            branch,
             breezy.plugins.loom.branch.LoomBranch6,
             breezy.plugins.loom.branch.BzrBranchLoomFormat6)
 
     def test_loomify_branch_format_7(self):
         branch = self.make_branch('.', format='1.6')
         loomify(branch)
-        self.assertConvertedBranchFormat(branch,
+        self.assertConvertedBranchFormat(
+            branch,
             breezy.plugins.loom.branch.LoomBranch7,
             breezy.plugins.loom.branch.BzrBranchLoomFormat7)
 
@@ -189,7 +191,8 @@
     def test_new_thread_no_duplicate_names(self):
         branch = self.make_loom('.')
         branch.new_thread('foo')
-        self.assertRaises(breezy.plugins.loom.branch.DuplicateThreadName, 
+        self.assertRaises(
+            breezy.plugins.loom.branch.DuplicateThreadName,
             branch.new_thread, 'foo')
         self.assertEqual(
             [('foo', EMPTY_REVISION, [])],
@@ -198,7 +201,7 @@
     def get_tree_with_one_commit(self, path='.'):
         """Get a tree with a commit in loom format."""
         tree = self.get_tree_with_loom(path=path)
-        rev_id = tree.commit('first post')
+        tree.commit('first post')
         return tree
 
     def test_new_thread_with_commits(self):
@@ -249,12 +252,12 @@
             tree.commit('change something', allow_pointless=True)
             self.assertEqual(
                 [('baseline', first_rev, []),
-                 ('tail', first_rev, [])], 
+                 ('tail', first_rev, [])],
                 tree.branch.get_loom_state().get_threads())
             tree.branch.record_thread('baseline', tree.last_revision())
             self.assertEqual(
-                [('baseline', tree.last_revision(), []), 
-                 ('tail', first_rev, [])], 
+                [('baseline', tree.last_revision(), []),
+                 ('tail', first_rev, [])],
                 tree.branch.get_loom_state().get_threads())
             self.assertEqual([], tree.branch.loom_parents())
         finally:
@@ -268,9 +271,10 @@
 
     def test_sprout_empty_loom(self):
         source_tree = self.get_tree_with_loom('source')
-        target_tree = source_tree.controldir.sprout('target').open_workingtree()
+        target_dir = source_tree.controldir.sprout('target')
+        target_tree = target_dir.open_workingtree()
         self.assertLoomSproutedOk(source_tree, target_tree)
-        
+
     def test_clone_nonempty_loom_top(self):
         """Cloning a nonempty loom at the top should preserve the loom."""
         source_tree = self.get_tree_with_one_commit('source')
@@ -297,7 +301,8 @@
         # now clone from the 'default url' - transport_server rather than
         # vfs_server.
         source_branch = Branch.open(self.get_url('source'))
-        target_tree = source_branch.controldir.sprout('target').open_workingtree()
+        target_dir = source_branch.controldir.sprout('target')
+        target_tree = target_dir.open_workingtree()
         self.assertLoomSproutedOk(source_tree, target_tree)
 
     def test_sprout_remote_loom(self):
@@ -315,12 +320,13 @@
         source_tree.branch.record_loom('commit to loom')
         LoomTreeDecorator(source_tree).down_thread()
         # now sprout
-        target_tree = source_tree.controldir.sprout('target').open_workingtree()
+        target_dir = source_tree.controldir.sprout('target')
+        target_tree = target_dir.open_workingtree()
         self.assertLoomSproutedOk(source_tree, target_tree)
 
     def assertLoomSproutedOk(self, source_tree, target_tree):
         """A sprout resets the loom to the top to ensure up-thread works.
-        
+
         Due to the calls made, this will ensure the loom content has been
         pulled, and that the tree state is correct.
         """
@@ -391,7 +397,7 @@
         for rev_id in loom_rev_ids:
             self.assertTrue(target.repository.has_revision(rev_id))
         self.assertEqual(source.branch.loom_parents(), target.loom_parents())
-        
+
     def test_pull_into_empty_loom(self):
         """Doing a pull into a loom with no loom revisions works."""
         self.pull_into_empty_loom()
@@ -522,7 +528,7 @@
         # the threads list should be restored
         self.assertEqual([], tree.branch.get_loom_state().get_threads())
         self.assertEqual(last_rev, tree.branch.last_revision())
-        
+
     def test_revert_loom_changes_current_thread_history(self):
         tree = self.get_tree_with_loom()
         # new threads
@@ -599,8 +605,7 @@
         tree.branch.revert_thread('bar')
         self.assertEqual(
             [('foo', EMPTY_REVISION, [EMPTY_REVISION]),
-             ('bar', EMPTY_REVISION, [EMPTY_REVISION]),
-            ],
+             ('bar', EMPTY_REVISION, [EMPTY_REVISION])],
             tree.branch.get_loom_state().get_threads())
         self.assertTrue(NULL_REVISION, tree.branch.last_revision())
 
@@ -675,7 +680,6 @@
     def test_export_loom_as_branch(self):
         tree = self.get_multi_threaded()
         tree.branch.controldir.root_transport.mkdir('root')
-        root_path = tree.branch.controldir.root_transport.local_abspath('root')
         repo = self.make_repository('root', shared=True)
         repo.set_make_working_trees(False)
         root_transport = get_transport('root')

=== modified file 'tests/test_loom_io.py'
--- tests/test_loom_io.py	2019-08-22 19:36:40 +0000
+++ tests/test_loom_io.py	2022-08-19 17:04:03 +0000
@@ -1,19 +1,19 @@
 # Loom, a plugin for bzr to assist in developing focused patches.
 # Copyright (C) 2006 Canonical Limited.
-# 
+#
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 2 as published
 # by the Free Software Foundation.
-# 
+#
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
-# 
+#
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
-# 
+#
 
 
 """Tests of the Loom parse and serialise routines."""
@@ -22,12 +22,10 @@
 from io import BytesIO
 
 import breezy
-import breezy.errors as errors
 import breezy.osutils
 from breezy.plugins.loom.branch import EMPTY_REVISION
 import breezy.plugins.loom.loom_io as loom_io
 import breezy.plugins.loom.loom_state as loom_state
-from breezy.plugins.loom.tree import LoomTreeDecorator
 import breezy.revision
 from breezy.tests import TestCase
 
@@ -35,9 +33,9 @@
 class TestLoomIO(TestCase):
 
     def test_writer_constructors(self):
-        writer = loom_io.LoomWriter()
+        loom_io.LoomWriter()
         state = loom_state.LoomState()
-        writer = loom_io.LoomStateWriter(state)
+        loom_io.LoomStateWriter(state)
 
     def assertWritesThreadsCorrectly(self, expected_stream, threads):
         """Write threads through a LoomWriter and check the output and sha1."""
@@ -109,7 +107,7 @@
             b' : baserev base \n'
             b' : \xc3\xa9toprev \xc3\xadtop\n',
             state)
-        
+
     def test_write_state_with_threads_and_parents(self):
         state = loom_state.LoomState()
         state.set_threads(
@@ -139,7 +137,7 @@
             loom_io._CURRENT_LOOM_FORMAT_STRING + b'\n'
             b'\n'
             b' : baserev base \n'
-            b' : \xc3\xa9toprev \xc3\xadtop\n') # yes this is utf8
+            b' : \xc3\xa9toprev \xc3\xadtop\n')  # yes this is utf8
         self.assertReadState(
             [],
             [('base ', b'baserev', []),
@@ -147,7 +145,7 @@
              (u'\xedtop', b'\xc3\xa9toprev', []),
              ],
             state_stream)
-        
+
     def test_read_state_parents(self):
         state_stream = BytesIO(
             loom_io._CURRENT_LOOM_FORMAT_STRING + b'\n'
@@ -162,7 +160,7 @@
             loom_io._CURRENT_LOOM_FORMAT_STRING + b'\n'
             b'1 2\xc3\xab\n'
             b'   : baserev base \n'
-            b'   : \xc3\xa9toprev \xc3\xadtop\n') # yes this is utf8
+            b'   : \xc3\xa9toprev \xc3\xadtop\n')  # yes this is utf8
         self.assertReadState(
             [b'1', b'2\xc3\xab'],
             [('base ', b'baserev', [None, None]),

=== modified file 'tests/test_loom_state.py'
--- tests/test_loom_state.py	2019-08-22 19:36:40 +0000
+++ tests/test_loom_state.py	2022-08-19 17:04:03 +0000
@@ -1,19 +1,19 @@
 # Loom, a plugin for bzr to assist in developing focused patches.
 # Copyright (C) 2006 - 2008 Canonical Limited.
-# 
+#
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 2 as published
 # by the Free Software Foundation.
-# 
+#
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
-# 
+#
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
-# 
+#
 
 
 """Tests of the Loom current-state object."""
@@ -21,12 +21,8 @@
 
 from io import BytesIO
 
-import breezy
-import breezy.errors as errors
-import breezy.osutils
 import breezy.plugins.loom.loom_io as loom_io
 import breezy.plugins.loom.loom_state as loom_state
-from breezy.plugins.loom.tree import LoomTreeDecorator
 from breezy.revision import NULL_REVISION
 from breezy.tests import TestCase
 
@@ -44,7 +40,9 @@
     def test_reader_constructor(self):
         # make a state
         state = loom_state.LoomState()
-        state.set_threads([('name', b'rev', [None, None]), ('dangerous name', b'rev2', [None, None])])
+        state.set_threads(
+            [('name', b'rev', [None, None]),
+             ('dangerous name', b'rev2', [None, None])])
         state.set_parents([b'bar', b'am'])
         stream = BytesIO()
         writer = loom_io.LoomStateWriter(state)

=== modified file 'tests/test_revspec.py'
--- tests/test_revspec.py	2018-05-20 13:59:05 +0000
+++ tests/test_revspec.py	2022-08-19 17:04:03 +0000
@@ -1,19 +1,19 @@
 # Loom, a plugin for bzr to assist in developing focused patches.
 # Copyright (C) 2006 Canonical Limited.
-# 
+#
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 2 as published
 # by the Free Software Foundation.
-# 
+#
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
-# 
+#
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
-# 
+#
 
 
 """Tests of the loom revision-specifiers."""
@@ -42,7 +42,7 @@
 
 class TestThreadRevSpec(TestRevSpec):
     """Tests of the ThreadRevisionSpecifier."""
-    
+
     def test_thread_colon_at_bottom_errors(self):
         tree, loom_tree, rev_id, _ = self.get_two_thread_loom()
         loom_tree.down_thread()
@@ -76,8 +76,8 @@
     def test_thread_on_non_loom_gives_BzrError(self):
         tree = self.make_branch_and_tree('.')
         spec = RevisionSpec.from_string('thread:')
-        err = self.assertRaises(breezy.errors.BzrError, spec.as_revision_id,
-            tree.branch)
+        err = self.assertRaises(
+            breezy.errors.BzrError, spec.as_revision_id, tree.branch)
         self.assertFalse(err.internal_error)
 
 
@@ -96,8 +96,8 @@
         tree, loom_tree, _, rev_id = self.get_two_thread_loom()
         loom_tree.down_thread()
         spec = RevisionSpec.from_string('below:')
-        err = self.assertRaises(breezy.errors.BzrError, spec.as_revision_id,
-            tree.branch)
+        err = self.assertRaises(
+            breezy.errors.BzrError, spec.as_revision_id, tree.branch)
         self.assertFalse(err.internal_error)
 
     def test_below_named_thread(self):
@@ -110,6 +110,6 @@
     def test_below_on_non_loom_gives_BzrError(self):
         tree = self.make_branch_and_tree('.')
         spec = RevisionSpec.from_string('below:')
-        err = self.assertRaises(breezy.errors.BzrError, spec.as_revision_id,
-            tree.branch)
+        err = self.assertRaises(
+            breezy.errors.BzrError, spec.as_revision_id, tree.branch)
         self.assertFalse(err.internal_error)

=== modified file 'tests/test_tree.py'
--- tests/test_tree.py	2019-08-22 19:36:40 +0000
+++ tests/test_tree.py	2022-08-19 17:04:03 +0000
@@ -1,19 +1,19 @@
 # Loom, a plugin for bzr to assist in developing focused patches.
 # Copyright (C) 2006 Canonical Limited.
-# 
+#
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 2 as published
 # by the Free Software Foundation.
-# 
+#
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
-# 
+#
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
-# 
+#
 
 
 """Tests of the loom Tree related routines."""
@@ -33,7 +33,7 @@
 
 class TestTreeDecorator(TestCaseWithLoom):
     """Tests of the LoomTreeDecorator class."""
-    
+
     def get_loom_with_two_threads(self):
         tree = self.get_tree_with_loom('source')
         tree.branch.new_thread('bottom')
@@ -100,7 +100,8 @@
         tree.lock_read()
         try:
             graph = tree.branch.repository.get_graph()
-            self.assertEqual([top_rev1, bottom_rev1, NULL_REVISION],
+            self.assertEqual(
+                [top_rev1, bottom_rev1, NULL_REVISION],
                 [r for (r, ps) in graph.iter_ancestry([top_rev1])])
             self.assertEqual([bottom_rev1], tree.get_parent_ids())
         finally:
@@ -124,7 +125,8 @@
         tree.lock_read()
         try:
             graph = tree.branch.repository.get_graph()
-            self.assertEqual([top_rev1, bottom_rev1, NULL_REVISION],
+            self.assertEqual(
+                [top_rev1, bottom_rev1, NULL_REVISION],
                 [r for (r, ps) in graph.iter_ancestry([top_rev1])])
             self.assertEqual([bottom_rev1], tree.get_parent_ids())
         finally:
@@ -139,7 +141,7 @@
         self.build_tree_contents([('source/a', 'a')])
         loom_tree.tree.commit('add a')
         loom_tree.up_thread()
-        e = self.assertRaises(errors.BzrCommandError, loom_tree.up_thread)
+        e = self.assertRaises(errors.CommandError, loom_tree.up_thread)
         self.assertEqual('Cannot move up from the highest thread.', str(e))
 
     def test_up_thread_merge_type(self):
@@ -211,9 +213,8 @@
 
     def test_up_many_target_thread_lower(self):
         loom_tree = self.get_loom_with_three_threads()
-        tree = loom_tree.tree
         loom_tree.up_many(target_thread='top')
-        e = self.assertRaises(errors.BzrCommandError,
+        e = self.assertRaises(errors.CommandError,
                               loom_tree.up_many, target_thread='middle')
         self.assertEqual('Cannot up-thread to lower thread.', str(e))
 
@@ -228,7 +229,7 @@
         loom_tree.revert_loom()
         # the tree should be reverted
         self.assertEqual(NULL_REVISION, tree.last_revision())
-        # the current loom should be reverted 
+        # the current loom should be reverted
         # (we assume this means branch.revert_loom was called())
         self.assertEqual([], tree.branch.get_loom_state().get_threads())
 
@@ -243,12 +244,12 @@
         loom_tree.revert_loom(thread='bar')
         # the tree should be reverted
         self.assertEqual(NULL_REVISION, tree.last_revision())
-        # the current loom should be reverted 
+        # the current loom should be reverted
         # (we assume this means branch.revert_loom was called())
         self.assertEqual(
             [('foo', EMPTY_REVISION, [])],
             tree.branch.get_loom_state().get_threads())
-        
+
     def test_revert_thread_different_thread(self):
         tree = self.get_tree_with_loom(',')
         # ensure we have some stuff to revert
@@ -261,7 +262,8 @@
         # the tree should not be reverted
         self.assertNotEqual(NULL_REVISION, tree.last_revision())
         # the bottom thread should be reverted
-        # (we assume this means branch.revert_thread was 
+        # (we assume this means branch.revert_thread was
         # called())
-        self.assertEqual([('bar', tree.last_revision(), [])],
+        self.assertEqual(
+            [('bar', tree.last_revision(), [])],
             tree.branch.get_loom_state().get_threads())

=== modified file 'tree.py'
--- tree.py	2018-05-20 13:59:05 +0000
+++ tree.py	2022-08-19 17:04:03 +0000
@@ -1,19 +1,19 @@
 # Loom, a plugin for bzr to assist in developing focused patches.
 # Copyright (C) 2006, 2008 Canonical Limited.
-# 
+#
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 2 as published
 # by the Free Software Foundation.
-# 
+#
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
-# 
+#
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
-# 
+#
 
 """The Loom Tree support routines.
 
@@ -53,15 +53,15 @@
 
     def _check_switch(self):
         if self.tree.last_revision() != self.tree.branch.last_revision():
-            raise breezy.errors.BzrCommandError('Cannot switch threads with an'
-            ' out-of-date tree. Please run bzr update.')
+            raise breezy.errors.CommandError(
+                'Cannot switch threads with an'
+                ' out-of-date tree. Please run bzr update.')
 
     def up_thread(self, merge_type=None):
         """Move one thread up in the loom."""
         with self.lock_write():
             self._check_switch()
             # set it up:
-            current_revision = self.tree.last_revision()
             threadname = self.tree.branch.nick
             threads = self.tree.branch.get_loom_state().get_threads()
             old_thread_rev = None
@@ -76,7 +76,7 @@
                 new_thread_name = thread
                 new_thread_rev = rev
             if new_thread_rev is None:
-                raise breezy.errors.BzrCommandError(
+                raise breezy.errors.CommandError(
                     'Cannot move up from the highest thread.')
             graph = self.tree.branch.repository.get_graph()
             # special case no-change condition.
@@ -94,7 +94,8 @@
                 merge_controller = breezy.merge.Merger.from_revision_ids(
                     self.tree, new_thread_rev, revision_graph=graph)
             except breezy.errors.UnrelatedBranches:
-                raise breezy.errors.BzrCommandError('corrupt loom: thread %s'
+                raise breezy.errors.CommandError(
+                    'corrupt loom: thread %s'
                     ' has no common ancestor with thread %s'
                     % (new_thread_name, threadname))
             merge_controller.merge_type = merge_type
@@ -102,12 +103,13 @@
             # change the tree to the revision of the new thread.
             parent_trees = []
             if new_thread_rev != breezy.revision.NULL_REVISION:
-                parent_trees.append((new_thread_rev, merge_controller.other_tree))
+                parent_trees.append(
+                    (new_thread_rev, merge_controller.other_tree))
             # record the merge if:
             # the old thread != new thread (we have something to record)
             # and the new thread is not a descendant of old thread
-            if (old_thread_rev != new_thread_rev and not
-                graph.is_ancestor(old_thread_rev, new_thread_rev)):
+            if (old_thread_rev != new_thread_rev
+                    and not graph.is_ancestor(old_thread_rev, new_thread_rev)):
                 basis_tree = self.tree.basis_tree()
                 basis_tree.lock_read()
                 parent_trees.append((old_thread_rev, basis_tree))
@@ -127,9 +129,9 @@
             # update the branch nick.
             self.tree.branch._set_nick(new_thread_name)
             trace.note("Moved to thread '%s'." % new_thread_name)
-            if (basis_tree is not None and
-                not result and not
-                self.tree.changes_from(basis_tree).has_changed()):
+            if (basis_tree is not None
+                    and not result
+                    and not self.tree.changes_from(basis_tree).has_changed()):
                 trace.note("This thread is now empty, you may wish to "
                            'run "bzr combine-thread" to remove it.')
             if result != 0:
@@ -143,13 +145,13 @@
         if target_thread is None:
             target_thread = threads[-1][0]
             if self.branch.nick == target_thread:
-                raise breezy.errors.BzrCommandError(
+                raise breezy.errors.CommandError(
                     'Cannot move up from the highest thread.')
         else:
             upper_thread_i = loom_state.thread_index(target_thread)
             lower_thread_i = loom_state.thread_index(self.branch.nick)
             if lower_thread_i > upper_thread_i:
-                raise breezy.errors.BzrCommandError(
+                raise breezy.errors.CommandError(
                     "Cannot up-thread to lower thread.")
         while self.branch.nick != target_thread:
             old_nick = self.branch.nick
@@ -175,9 +177,10 @@
             old_thread_rev = threads[old_thread_index][1]
             if name is None:
                 if old_thread_index == 0:
-                    raise breezy.errors.BzrCommandError(
+                    raise breezy.errors.CommandError(
                         'Cannot move down from the lowest thread.')
-                new_thread_name, new_thread_rev, _ = threads[old_thread_index - 1]
+                new_thread_name, new_thread_rev, _ = (
+                    threads[old_thread_index - 1])
             else:
                 new_thread_name = name
                 index = state.thread_index(name)
@@ -198,14 +201,16 @@
             except breezy.errors.NoSuchRevisionInTree:
                 basis_tree = repository.revision_tree(old_thread_rev)
             to_tree = repository.revision_tree(new_thread_rev)
-            result = breezy.merge.merge_inner(self.tree.branch,
+            result = breezy.merge.merge_inner(
+                self.tree.branch,
                 to_tree,
                 basis_tree,
                 this_tree=self.tree)
-            branch_revno, branch_revision = self.tree.branch.last_revision_info()
+            branch_revno, branch_revision = (
+                self.tree.branch.last_revision_info())
             graph = repository.get_graph()
-            new_thread_revno = graph.find_distance_to_null(new_thread_rev,
-                [(branch_revision, branch_revno)])
+            new_thread_revno = graph.find_distance_to_null(
+                new_thread_rev, [(branch_revision, branch_revno)])
             self.tree.branch.set_last_revision_info(new_thread_revno,
                                                     new_thread_rev)
             if new_thread_rev == breezy.revision.NULL_REVISION:
@@ -232,14 +237,12 @@
             current_thread = self.branch.nick
             last_rev = self.tree.last_revision()
             state = self.branch.get_loom_state()
-            old_threads = state.get_threads()
             current_thread_rev = self.branch.last_revision()
             if thread is None:
                 self.branch.revert_loom()
             else:
                 self.branch.revert_thread(thread)
             state = self.branch.get_loom_state()
-            threads = state.get_threads()
             threads_dict = state.get_threads_dict()
             # TODO find the next up thread if needed
             if not threads_dict:
@@ -258,9 +261,11 @@
             if to_rev == EMPTY_REVISION:
                 to_rev = breezy.revision.NULL_REVISION
             # the thread changed, do a merge to match.
-            basis_tree = self.tree.branch.repository.revision_tree(current_thread_rev)
+            basis_tree = self.tree.branch.repository.revision_tree(
+                current_thread_rev)
             to_tree = self.tree.branch.repository.revision_tree(to_rev)
-            result = breezy.merge.merge_inner(self.tree.branch,
+            breezy.merge.merge_inner(
+                self.tree.branch,
                 to_tree,
                 basis_tree,
                 this_tree=self.tree)

=== modified file 'version.py'
--- version.py	2019-08-22 19:39:25 +0000
+++ version.py	2022-08-19 17:04:03 +0000
@@ -1,15 +1,15 @@
 # Loom, a plugin for bzr to assist in developing focused patches.
 # Copyright (C) 2010 Canonical Limited.
-# 
+#
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 2 as published
 # by the Free Software Foundation.
-# 
+#
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
-# 
+#
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA