Merge lp:~jelmer/qbrz/context-managers into lp:qbrz

[Jelmer Vernooij]

Use more context managers.

Use more context managers.

[Jelmer Vernooij (jelmer)]

review: Approve

=== modified file 'extras/build_pot.py'
--- extras/build_pot.py	2020-07-15 09:34:25 +0000
+++ extras/build_pot.py	2022-07-06 15:37:54 +0000
@@ -63,18 +63,12 @@
             raise DistutilsOptionError("You can't use options --lang=XXX and --no-lang in the same time.")
 
     def _force_LF(self, src, dst=None):
-        f = open(src, 'rU')
-        try:
+        with open(src, 'rU') as f:
             content = f.read()
-        finally:
-            f.close()
         if dst is None:
             dst = src
-        f = open(dst, 'wb')
-        try:
+        with open(dst, 'wb') as f:
             f.write(content)
-        finally:
-            f.close()
 
     def run(self):
         """Run xgettext for project sources"""

=== modified file 'extras/import_po.py'
--- extras/import_po.py	2019-10-27 14:48:19 +0000
+++ extras/import_po.py	2022-07-06 15:37:54 +0000
@@ -80,11 +80,8 @@
         for n, fn in entries:
             log.info('  %s -> %s' % (n, fn))
             ft = t.extractfile(n)
-            fd = open(fn, 'wb')
-            try:
+            with open(fn, 'wb') as fd:
                 fd.write(ft.read())
-            finally:
-                fd.close()
         if pot_file:
             if find_executable('msginit') is None:
                 log.warn("GNU gettext msginit utility not found!")

=== modified file 'lib/annotate.py'
--- lib/annotate.py	2022-01-07 14:04:10 +0000
+++ lib/annotate.py	2022-07-06 15:37:54 +0000
@@ -410,12 +410,9 @@
                 QtCore.QCoreApplication.processEvents()
             self.encoding = get_set_encoding(self.encoding, self.branch)
             self.encoding_selector.encoding = self.encoding
-            self.branch.lock_read()
-            try:
+            with self.branch.lock_read():
                 self.set_annotate_title()
                 self.annotate(self.annotate_tree, self.fileId, self.path)
-            finally:
-                self.branch.unlock()
         finally:
             self.throbber.hide()
         QtCore.QTimer.singleShot(1, self._activate_line)
@@ -634,8 +631,7 @@
     def set_annotate_revision(self):
         self.throbber.show()
         try:
-            self.branch.lock_read()
-            try:
+            with self.branch.lock_read():
                 revid = self.log_list.currentIndex().data(logmodel.RevIdRole)
                 if revid.startswith(CURRENT_REVISION):
                     rev = cached_revisions[revid]
@@ -646,8 +642,6 @@
                 self.set_annotate_title()
                 self.processEvents()
                 self.annotate(self.annotate_tree, self.fileId, self.path)
-            finally:
-                self.branch.unlock()
         finally:
             self.throbber.hide()
 
@@ -657,11 +651,8 @@
         get_set_encoding(encoding, self.branch)
         self.throbber.show()
         try:
-            self.branch.lock_read()
-            try:
+            with self.branch.lock_read():
                 self.annotate(self.annotate_tree, self.fileId, self.path)
-            finally:
-                self.branch.unlock()
         finally:
             self.throbber.hide()
 

=== modified file 'lib/browse.py'
--- lib/browse.py	2021-01-08 13:56:34 +0000
+++ lib/browse.py	2022-07-06 15:37:54 +0000
@@ -158,49 +158,45 @@
                        self.diffbuttons,
                        self.refresh_button)
             state = self.file_tree.get_state()
-            if text=="wt:":
+            if text == "wt:":
                 self.tree = self.workingtree
-                self.tree.lock_read()
+                with self.tree.lock_read():
                 try:
                     self.file_tree.set_tree(self.workingtree, self.branch)
                     self.file_tree.restore_state(state)
-                finally:
-                    self.tree.unlock()
                 for button in buttons:
                     button.setEnabled(True)
             else:
                 branch = self.branch
-                branch.lock_read()
-                self.processEvents()
-
-                for button in buttons:
-                    button.setEnabled(False)
-                fmodel = self.file_tree.tree_filter_model
-                fmodel.setFilter(fmodel.UNCHANGED, True)
-                self.filter_menu.set_filters(fmodel.filters)
-
-                try:
-                    if revision_id is None:
-                        text = revspec.spec or ''
-                        if revspec.in_branch == revspec.in_history:
-                            args = [branch]
-                        else:
-                            args = [branch, False]
-
-                        revision_id = revspec.in_branch(*args).rev_id
-
-                    self.revision_id = revision_id
-                    self.tree = branch.repository.revision_tree(revision_id)
+                with branch.lock_read():
                     self.processEvents()
-                    self.file_tree.set_tree(self.tree, self.branch)
-                    self.file_tree.restore_state(state)
-                    if self.revno_map is None:
+
+                    for button in buttons:
+                        button.setEnabled(False)
+                    fmodel = self.file_tree.tree_filter_model
+                    fmodel.setFilter(fmodel.UNCHANGED, True)
+                    self.filter_menu.set_filters(fmodel.filters)
+
+                    try:
+                        if revision_id is None:
+                            text = revspec.spec or ''
+                            if revspec.in_branch == revspec.in_history:
+                                args = [branch]
+                            else:
+                                args = [branch, False]
+
+                            revision_id = revspec.in_branch(*args).rev_id
+
+                        self.revision_id = revision_id
+                        self.tree = branch.repository.revision_tree(revision_id)
                         self.processEvents()
-                        # XXX make this operation lazy? how?
-                        self.revno_map = self.branch.get_revision_id_to_revno_map()
-                    self.file_tree.tree_model.set_revno_map(self.revno_map)
-                finally:
-                    branch.unlock()
+                        self.file_tree.set_tree(self.tree, self.branch)
+                        self.file_tree.restore_state(state)
+                        if self.revno_map is None:
+                            self.processEvents()
+                            # XXX make this operation lazy? how?
+                            self.revno_map = self.branch.get_revision_id_to_revno_map()
+                        self.file_tree.tree_model.set_revno_map(self.revno_map)
             self.revision_edit.setText(text)
         finally:
             self.throbber.hide()

=== modified file 'lib/cat.py'
--- lib/cat.py	2021-01-08 08:16:13 +0000
+++ lib/cat.py	2022-07-06 15:37:54 +0000
@@ -142,8 +142,7 @@
                     "%r is not present in revision %s" % (
                         self.filename, self.tree.get_revision_id()))
 
-            self.tree.lock_read()
-            try:
+            with self.tree.lock_read():
                 kind = self.tree.kind(self.filename)
                 if kind == 'file':
                     text = self.tree.get_file_text(self.filename)
@@ -151,8 +150,6 @@
                     text = self.tree.get_symlink_target(self.filename)
                 else:
                     text = ''
-            finally:
-                self.tree.unlock()
             self.processEvents()
 
             self.text = text
@@ -304,11 +301,8 @@
         kind = osutils.file_kind(self.filename)
         text = ''
         if kind == 'file':
-            f = open(self.filename, 'rb')
-            try:
+            with open(self.filename, 'rb') as f:
                 text = f.read()
-            finally:
-                f.close()
         elif kind == 'symlink':
             text = os.readlink(self.filename)
         self.text = text
@@ -337,13 +331,8 @@
         os.makedirs(qdir)
     basename = os.path.basename(relpath)
     fname = os.path.join(qdir, basename)
-    f = open(fname, 'wb')
-    tree.lock_read()
-    try:
+    with open(fname, 'wb') as f, tree.lock_read():
         f.write(tree.get_file_text(relpath))
-    finally:
-        tree.unlock()
-        f.close()
     # open it
     url = QtCore.QUrl.fromLocalFile(fname)
     result = QtGui.QDesktopServices.openUrl(url)

=== removed file 'lib/cleanup.py'
--- lib/cleanup.py	2020-07-14 15:58:13 +0000
+++ lib/cleanup.py	1970-01-01 00:00:00 +0000
@@ -1,184 +0,0 @@
-# Copyright (C) 2009, 2010 Canonical Ltd
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# 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 Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-"""Helpers for managing cleanup functions and the errors they might raise.
-
-The usual way to run cleanup code in Python is::
-
-    try:
-        do_something()
-    finally:
-        cleanup_something()
-
-However if both `do_something` and `cleanup_something` raise an exception
-Python will forget the original exception and propagate the one from
-cleanup_something.  Unfortunately, this is almost always much less useful than
-the original exception.
-
-If you want to be certain that the first, and only the first, error is raised,
-then use::
-
-    operation = OperationWithCleanups(do_something)
-    operation.add_cleanup(cleanup_something)
-    operation.run_simple()
-
-This is more inconvenient (because you need to make every try block a
-function), but will ensure that the first error encountered is the one raised,
-while also ensuring all cleanups are run.  See OperationWithCleanups for more
-details.
-"""
-
-from __future__ import absolute_import
-
-from collections import deque
-# import sys
-# from . import (
-#     debug,
-#     trace,
-#     )
-
-from breezy import (
-    debug,
-    trace,
-    )
-
-
-def _log_cleanup_error(exc):
-    trace.mutter('Cleanup failed:')
-    trace.log_exception_quietly()
-    if 'cleanup' in debug.debug_flags:
-        trace.warning('brz: warning: Cleanup failed: %s', exc)
-
-
-def _run_cleanup(func, *args, **kwargs):
-    """Run func(*args, **kwargs), logging but not propagating any error it
-    raises.
-
-    :returns: True if func raised no errors, else False.
-    """
-    try:
-        func(*args, **kwargs)
-    except KeyboardInterrupt:
-        raise
-    except Exception as exc:
-        _log_cleanup_error(exc)
-        return False
-    return True
-
-
-def _run_cleanups(funcs):
-    """Run a series of cleanup functions."""
-    for func, args, kwargs in funcs:
-        _run_cleanup(func, *args, **kwargs)
-
-
-class ObjectWithCleanups(object):
-    """A mixin for objects that hold a cleanup list.
-
-    Subclass or client code can call add_cleanup and then later `cleanup_now`.
-    """
-    def __init__(self):
-        self.cleanups = deque()
-
-    def add_cleanup(self, cleanup_func, *args, **kwargs):
-        """Add a cleanup to run.
-
-        Cleanups may be added at any time.
-        Cleanups will be executed in LIFO order.
-        """
-        self.cleanups.appendleft((cleanup_func, args, kwargs))
-
-    def cleanup_now(self):
-        _run_cleanups(self.cleanups)
-        self.cleanups.clear()
-
-
-class OperationWithCleanups(ObjectWithCleanups):
-    """A way to run some code with a dynamic cleanup list.
-
-    This provides a way to add cleanups while the function-with-cleanups is
-    running.
-
-    Typical use::
-
-        operation = OperationWithCleanups(some_func)
-        operation.run(args...)
-
-    where `some_func` is::
-
-        def some_func(operation, args, ...):
-            do_something()
-            operation.add_cleanup(something)
-            # etc
-
-    Note that the first argument passed to `some_func` will be the
-    OperationWithCleanups object.  To invoke `some_func` without that, use
-    `run_simple` instead of `run`.
-    """
-
-    def __init__(self, func):
-        super(OperationWithCleanups, self).__init__()
-        self.func = func
-
-    def run(self, *args, **kwargs):
-        return _do_with_cleanups(self.cleanups, self.func, self, *args, **kwargs)
-
-    def run_simple(self, *args, **kwargs):
-        return _do_with_cleanups(self.cleanups, self.func, *args, **kwargs)
-
-
-def _do_with_cleanups(cleanup_funcs, func, *args, **kwargs):
-    """Run `func`, then call all the cleanup_funcs.
-
-    All the cleanup_funcs are guaranteed to be run.  The first exception raised
-    by func or any of the cleanup_funcs is the one that will be propagted by
-    this function (subsequent errors are caught and logged).
-
-    Conceptually similar to::
-
-        try:
-            return func(*args, **kwargs)
-        finally:
-            for cleanup, cargs, ckwargs in cleanup_funcs:
-                cleanup(*cargs, **ckwargs)
-
-    It avoids several problems with using try/finally directly:
-     * an exception from func will not be obscured by a subsequent exception
-       from a cleanup.
-     * an exception from a cleanup will not prevent other cleanups from
-       running (but the first exception encountered is still the one
-       propagated).
-
-    Unike `_run_cleanup`, `_do_with_cleanups` can propagate an exception from a
-    cleanup, but only if there is no exception from func.
-    """
-    try:
-        result = func(*args, **kwargs)
-    except:
-        # We have an exception from func already, so suppress cleanup errors.
-        _run_cleanups(cleanup_funcs)
-        raise
-    # No exception from func, so allow first cleanup error to propgate.
-    pending_cleanups = iter(cleanup_funcs)
-    try:
-        for cleanup, c_args, c_kwargs in pending_cleanups:
-            cleanup(*c_args, **c_kwargs)
-    except:
-        # Still run the remaining cleanups but suppress any further errors.
-        _run_cleanups(pending_cleanups)
-        raise
-    # No error, so we can return the result
-    return result

=== modified file 'lib/commands.py'
--- lib/commands.py	2021-08-05 11:12:43 +0000
+++ lib/commands.py	2022-07-06 15:37:54 +0000
@@ -367,11 +367,8 @@
         if message is not None and file:
             raise errors.BzrCommandError("please specify either --message or --file")
         if file:
-            f = open(file)
-            try:
+            with open(file) as f:
                 message = f.read().decode(file_encoding or osutils.get_user_encoding())
-            finally:
-                f.close()
         tree, selected_list = WorkingTree.open_containing_paths(selected_list)
         if selected_list == ['']:
             selected_list = None
@@ -403,18 +400,11 @@
         takes_options.append('change')
     aliases = ['qdi']
 
-    def get_diff_window_args(self, processEvents, add_cleanup):
-        # RJL if you get a ``AttributeError: 'function' object has no attribute 'enter_context'``
-        # error, or something similar, use something like:
-        #
-        #  exit_stack = contextlib.ExitStack()
-        #
-        # and pass that as add_cleanup
-        #
+    def get_diff_window_args(self, processEvents, es):
         args = {}
         (args["old_tree"], args["new_tree"],
             args["old_branch"], args["new_branch"],
-            args["specific_files"], _) = get_trees_and_branches_to_diff_locked(self.file_list, self.revision, self.old, self.new, add_cleanup)
+            args["specific_files"], _) = get_trees_and_branches_to_diff_locked(self.file_list, self.revision, self.old, self.new, es)
         args["ignore_whitespace"] = self.ignore_whitespace
         return args
 
@@ -716,7 +706,7 @@
             del kw['encoding']
         return breezy.builtins.cmd_merge.run(self, *args, **kw)
 
-    def get_diff_window_args(self, processEvents, add_cleanup):
+    def get_diff_window_args(self, processEvents, es):
         tree_merger = self.merger.make_merger()
         self.tt = tree_merger.make_preview_transform()
         result_tree = self.tt.get_preview_tree()

=== modified file 'lib/commit.py'
--- lib/commit.py	2022-01-07 15:10:55 +0000
+++ lib/commit.py	2022-07-06 15:37:54 +0000
@@ -465,8 +465,7 @@
             self.throbber.show()
         self.refresh_button.setDisabled(True)
         try:
-            self.tree.lock_read()
-            try:
+            with self.tree.lock_read():
                 if self.pending_merges_list:
                     self.pending_merges_list.load_tree(self.tree)
                     # Force the loading of the revisions, before we start
@@ -488,7 +487,7 @@
                         # if there are any paths from the command line that
                         # are not versioned, we want_unversioned.
                         for path in self.initial_selected_list:
-                            if not self.tree.path2id(path):
+                            if not self.tree.is_versioned(path):
                                 want_unversioned = True
                                 break
 
@@ -504,8 +503,6 @@
                 self.is_loading = False
                 self.processEvents()
                 self.update_compleater_words()
-            finally:
-                self.tree.unlock()
         finally:
             self.throbber.hide()
             self.refresh_button.setDisabled(False)

=== modified file 'lib/commit_data.py'
--- lib/commit_data.py	2019-10-27 14:48:19 +0000
+++ lib/commit_data.py	2022-07-06 15:37:54 +0000
@@ -164,14 +164,11 @@
     def save(self):
         """Save data to the branch/tree."""
         br = self._get_branch()
-        br.lock_write()
-        try:
+        with br.lock_write():
             # XXX save should wipe if self._data is empty
             self._set_new_commit_data(self._filtered_data())
             # clear old data
             self._wipe_old_data()
-        finally:
-            br.unlock()
 
     def _wipe_old_data(self):
         """Wipe saved data in old format."""
@@ -180,13 +177,10 @@
     def wipe(self):
         """Delete saved data from branch/tree config."""
         br = self._get_branch()
-        br.lock_write()
-        try:
+        with br.lock_write():
             self._set_new_commit_data({})
             # clear old data
             self._wipe_old_data()
-        finally:
-            br.unlock()
 
     def _get_branch(self):
         """Return branch object if either branch or tree was specified on init.

=== modified file 'lib/diff.py'
--- lib/diff.py	2022-01-08 11:48:59 +0000
+++ lib/diff.py	2022-07-06 15:37:54 +0000
@@ -17,8 +17,18 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 
+from contextlib import ExitStack
+import errno
+import re
+import time
+import sys
+import os
+import glob
+
 from PyQt5 import QtCore, QtGui, QtWidgets
 
+from breezy import trace, osutils, cmdline
+
 from breezy.errors import NoSuchId, ExecutableMissing
 from breezy.tree import FileTimestampUnavailable
 from breezy.plugins.qbrz.lib.diff_arg import *   # import DiffArgProvider classes
@@ -30,22 +40,9 @@
     )
 
 from breezy.lazy_import import lazy_import
-try:
-    QString = unicode
-except NameError:
-    # Python 3
-    QString = str
-
 lazy_import(globals(), '''
-import errno
-import re
-import time
-import sys
-import os
-import glob
 from patiencediff import PatienceSequenceMatcher as SequenceMatcher
 from breezy.plugins.qbrz.lib.i18n import gettext, ngettext, N_
-from breezy import trace, osutils, cmdline
 from breezy.workingtree import WorkingTree
 from breezy.trace import mutter
 ''')
@@ -78,10 +75,9 @@
             parent_window.windows.append(window)
     elif context:
         ext_diff = str(ext_diff) # convert QString to str
-        cleanup = []
-        try:
+        with ExitStack() as es:
             args = arg_provider.get_diff_window_args(
-                QtWidgets.QApplication.processEvents, cleanup.append
+                QtWidgets.QApplication.processEvents, es
             )
             old_tree = args["old_tree"]
             new_tree = args["new_tree"]
@@ -91,9 +87,6 @@
                 context.diff_paths(specific_files)
             else:
                 context.diff_tree()
-        finally:
-            while cleanup:
-                cleanup.pop()()
 
     else:
         args=["diff", "--using", ext_diff]  # NEVER USE --using=xxx, ALWAYS --using xxx
@@ -188,11 +181,10 @@
         """
         RJLRJL: updated to call .iter_changes directly
         """
-        try:
-            cleanup = []
+        with ExitStack() as es:
             if lock_trees:
                 for t in trees:
-                    cleanup.append(t.lock_read().unlock)
+                    es.enter_context(t.lock_read())
 
             # changes = trees[1].iter_changes(trees[0], specific_files=specific_files, require_versioned=True)
 
@@ -215,9 +207,6 @@
                 if not di:
                     continue
                 yield di
-        finally:
-            while cleanup:
-                cleanup.pop()()
 
     @classmethod
     def create(cls, trees, file_id, paths, changed_content, versioned,
@@ -588,17 +577,13 @@
         NOTE: Directories cannot be specified.
               Use diff_tree or diff_paths instead when specifing directory.
         """
-        cleanup = []
-        try:
+        with ExitStack() as es:
             if lock_trees:
-                cleanup.append(self._differ.new_tree.lock_read().unlock)
-                cleanup.append(self._differ.old_tree.lock_read().unlock)
+                es.enter_context(self._differ.new_tree.lock_read())
+                es.enter_context(self._differ.old_tree.lock_read())
             for file_id in file_ids:
                 self._differ.diff(file_id)
                 time.sleep(interval * 0.001)
-        finally:
-            while cleanup:
-                cleanup.pop()()
 
     def diff_paths(self, paths, interval=50, lock_trees=True):
         """
@@ -610,12 +595,11 @@
         valid_paths = []
         ids = []
         dir_included = False
-        cleanup = []
-        try:
+        with ExitStack() as es:
             # Sometimes, we must lock tree before calling tree.kind()
             if lock_trees:
-                cleanup.append(new_tree.lock_read().unlock)
-                cleanup.append(old_tree.lock_read().unlock)
+                es.enter_context(new_tree.lock_read())
+                es.enter_context(old_tree.lock_read())
             for p in paths:
                 id = new_tree.path2id(p)
                 if id:
@@ -630,9 +614,6 @@
                 self.diff_tree(valid_paths, interval, False)
             else:
                 self.diff_ids(ids, interval, False)
-        finally:
-            while cleanup:
-                cleanup.pop()()
 
     def diff_tree(self, specific_files=None, interval=50, lock_trees=True):
         """

=== modified file 'lib/diff_arg.py'
--- lib/diff_arg.py	2017-09-11 06:53:22 +0000
+++ lib/diff_arg.py	2022-07-06 15:37:54 +0000
@@ -30,7 +30,7 @@
     """Contract class to pass arguments to either builtin diff window, or
     external diffs"""
 
-    def get_diff_window_args(self, processEvents, add_cleanup):
+    def get_diff_window_args(self, processEvents, es):
         """Returns the arguments for the builtin diff window.
 
         :return: {"old_tree": old_tree,
@@ -52,7 +52,7 @@
 
 class InternalDiffArgProvider(DiffArgProvider):
     """Use for passing arguments from internal source."""
-    
+
     def __init__(self,
                  old_revid, new_revid,
                  old_branch, new_branch,
@@ -67,7 +67,7 @@
 
         self.old_tree = old_tree
         self.new_tree = new_tree
-    
+
     def need_to_load_paths(self):
         return self.specific_file_ids is not None \
            and self.specific_files is None
@@ -83,14 +83,11 @@
                     self.new_branch.repository.revision_tree(self.new_revid)
 
         if self.need_to_load_paths():
-            self.new_tree.lock_read()
-            try:
+            with self.new_tree.lock_read():
                 self.specific_files = [self.new_tree.id2path(id) \
                                        for id in self.specific_file_ids]
-            finally:
-                self.new_tree.unlock()
 
-    def get_diff_window_args(self, processEvents, add_cleanup):
+    def get_diff_window_args(self, processEvents, es):
         self.load_old_tree()
         processEvents()
         self.load_new_tree_and_paths()
@@ -107,11 +104,11 @@
             if revid.startswith(CURRENT_REVISION):
                 return ''
             return 'revid:%s' % revid
-        
+
         return "-r%s..%s" % (
             get_revspec_part(self.old_revid),
             get_revspec_part(self.new_revid))
-    
+
     def get_ext_diff_args(self, processEvents):
         from breezy import urlutils
         from breezy import errors
@@ -177,7 +174,7 @@
         else:
             InternalDiffArgProvider.load_old_tree(self)
 
-    def get_diff_window_args(self, processEvents, add_cleanup):
+    def get_diff_window_args(self, processEvents, es):
         self.load_old_tree()
         processEvents()
 

=== modified file 'lib/diffview.py'
--- lib/diffview.py	2022-01-08 10:52:49 +0000
+++ lib/diffview.py	2022-07-06 15:37:54 +0000
@@ -295,7 +295,7 @@
     def adjust_range(self):
         page_step = self.browsers[0].verticalScrollBar().pageStep()
         self.setPageStep(page_step)
-        self.setRange(0, self.total_length - page_step + 4)
+        self.setRange(0, int(self.total_length - page_step + 4))
         self.setVisible(self.total_length > page_step)
 
     def get_position_info(self, target):

=== modified file 'lib/diffwindow.py'
--- lib/diffwindow.py	2022-01-08 11:48:59 +0000
+++ lib/diffwindow.py	2022-07-06 15:37:54 +0000
@@ -20,6 +20,7 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 
+from contextlib import ExitStack
 import errno
 import re
 import time
@@ -35,8 +36,6 @@
 from breezy.workingtree import WorkingTree
 from breezy.bzr.workingtree_4 import DirStateRevisionTree
 from breezy import trace
-# from breezy import cleanup
-from breezy.plugins.qbrz.lib import cleanup
 
 from breezy.plugins.qbrz.lib.diffview import (
     SidebySideDiffView,
@@ -345,16 +344,13 @@
         throbber window, then loads the branches etc if they weren't specified
         in our constructor.
         """
-        op = cleanup.OperationWithCleanups(self._initial_load)
-        self.throbber.show()
-        op.add_cleanup(self.throbber.hide)
-        op.run()
+        with ExitStack() as es:
+            es.callback(self.throbber.hide)
+            self.throbber.show()
+            self._initial_load(es)
 
-    def _initial_load(self, op):
-        # RJL Breezy expects a context handler of some type
-        exit_stack = contextlib.ExitStack()
-        args = self.arg_provider.get_diff_window_args(self.processEvents, exit_stack)
-        # args = self.arg_provider.get_diff_window_args(self.processEvents, op.add_cleanup)
+    def _initial_load(self, es):
+        args = self.arg_provider.get_diff_window_args(self.processEvents, es)
 
         self.trees = (args["old_tree"], args["new_tree"])
         self.branches = (args.get("old_branch", None), args.get("new_branch",None))

=== modified file 'lib/extra/isignored.py'
--- lib/extra/isignored.py	2019-10-27 14:48:19 +0000
+++ lib/extra/isignored.py	2022-07-06 15:37:54 +0000
@@ -33,7 +33,7 @@
 
     def run(self, filename):
         tree, relpath = workingtree.WorkingTree.open_containing(filename)
-        if tree.is_ignored(relpath) and not tree.path2id(relpath):
+        if tree.is_ignored(relpath) and not tree.is_versioned(relpath):
             if not trace.is_quiet():
                 print('ignored', file=self.outf)
             return 1

=== modified file 'lib/extra/isversioned.py'
--- lib/extra/isversioned.py	2019-10-27 14:48:19 +0000
+++ lib/extra/isversioned.py	2022-07-06 15:37:54 +0000
@@ -33,7 +33,7 @@
 
     def run(self, filename):
         tree, relpath = workingtree.WorkingTree.open_containing(filename)
-        if tree.path2id(relpath):
+        if tree.is_versioned(relpath):
             if not trace.is_quiet():
                 print('versioned', file=self.outf)
             return 1

=== modified file 'lib/lazycachedrevloader.py'
--- lib/lazycachedrevloader.py	2021-01-05 13:03:34 +0000
+++ lib/lazycachedrevloader.py	2022-07-06 15:37:54 +0000
@@ -37,13 +37,13 @@
                    before_batch_load = None,
                    revisions_loaded = None,
                    pass_prev_loaded_rev = False):
-    
+
     start_time = time.process_time()
     showed_throbber = False
     revids = [revid for revid in revids if not revid == "root:"]
     return_revisions = {}
     throbber = current_throbber()
-    
+
     try:
         for revid in [revid for revid in revids
                       if revid in cached_revisions]:
@@ -51,7 +51,7 @@
         if pass_prev_loaded_rev:
             if revisions_loaded is not None:
                 revisions_loaded(return_revisions, False)
-        
+
         revs_loaded = {}
         revids = [revid for revid in revids if revid not in cached_revisions]
         if revids:
@@ -59,24 +59,23 @@
                 repo_revids=((repo, revids),)
             else:
                 repo_revids = repo(revids)
-            
+
             for repo, revids in repo_revids:
                 repo_is_local = isinstance(repo.controldir.transport, LocalTransport)
                 if repo_is_local:
                     batch_size = local_batch_size
                 else:
                     batch_size = remote_batch_size
-                
+
                 if revids:
-                    repo.lock_read()
-                    try:
+                    with repo.lock_read():
                         if not repo_is_local:
                             update_ui()
-                        
+
                         for offset in range(0, len(revids), batch_size):
-                            
+
                             running_time = time.process_time() - start_time
-                            
+
                             if time_before_first_ui_update < running_time:
                                 if revisions_loaded is not None:
                                     revisions_loaded(revs_loaded, False)
@@ -86,28 +85,26 @@
                                         throbber.show()
                                         showed_throbber = True
                                 update_ui()
-                            
+
                             batch_revids = revids[offset:offset+batch_size]
-                            
+
                             if before_batch_load is not None:
                                 stop = before_batch_load(repo, batch_revids)
                                 if stop:
                                     break
-                            
+
                             for rev in repo.get_revisions(batch_revids):
                                 cached_revisions[rev.revision_id] = rev
                                 return_revisions[rev.revision_id] = rev
                                 revs_loaded[rev.revision_id] = rev
                                 rev.repository = repo
-                    finally:
-                        repo.unlock()
-            
+
             if revisions_loaded is not None:
                 revisions_loaded(revs_loaded, True)
     finally:
         if showed_throbber:
             throbber.hide()
-    
+
     return return_revisions
 
 def update_ui():

=== modified file 'lib/log.py'
--- lib/log.py	2022-01-08 11:48:59 +0000
+++ lib/log.py	2022-07-06 15:37:54 +0000
@@ -612,9 +612,8 @@
                     for repo, repo_revids in repos_revids:
                         repo_revids = [revid for revid in repo_revids if revid not in self.tree_cache]
                         if repo_revids:
-                            repo.lock_read()
-                            self.processEvents()
-                            try:
+                            with repo.lock_read():
+                                self.processEvents()
                                 for revid in repo_revids:
                                     if (revid.startswith(CURRENT_REVISION) and gv_is_wtgv):
                                         tree = gv.working_trees[revid]
@@ -622,8 +621,6 @@
                                         tree = repo.revision_tree(revid)
                                     self.tree_cache[revid] = tree
                                 self.processEvents()
-                            finally:
-                                repo.unlock()
                         self.processEvents()
 
                     delta = self.tree_cache[revids[0]].changes_from(self.tree_cache[revids[1]])
@@ -830,13 +827,10 @@
         tree = branch.repository.revision_tree(top_revid)
         file_id = file_ids[0]
         path = paths[0]
-        tree.lock_read()
-        try:
+        with tree.lock_read():
             kind = tree.kind(path)
             if kind == 'file':
                 file_content_bytes = tree.get_file_text(path)
-        finally:
-            tree.unlock()
         if kind != 'file':
             QtWidgets.QMessageBox.information(self, gettext("Not a file"),
                 gettext("Operation is supported for a single file only,\n"
@@ -844,11 +838,8 @@
             return
         filename = QtWidgets.QFileDialog.getSaveFileName(self, gettext("Save file in this revision as..."))[0]
         if filename:
-            f = open(str(filename), 'wb')
-            try:
+            with open(str(filename), 'wb') as f:
                 f.write(file_content_bytes)
-            finally:
-                f.close()
 
     @ui_current_widget
     def revert_file(self):

=== modified file 'lib/loggraphviz.py'
--- lib/loggraphviz.py	2021-08-05 11:27:16 +0000
+++ lib/loggraphviz.py	2022-07-06 15:37:54 +0000
@@ -219,7 +219,6 @@
         finally:
             self.unlock_branches()
 
-
     def load_current_dir_repo(self):
         # There are no local repositories. Try open the repository
         # of the current directory, and try load revisions data from
@@ -1050,13 +1049,10 @@
         return_revisions = {}
         for repo, revids in self.get_repo_revids(revids):
             if revids:
-                repo.lock_read()
-                try:
+                with repo.lock_read():
                     self.update_ui()
                     for rev in repo.get_revisions(revids):
                         return_revisions[rev.revision_id] = rev
-                finally:
-                    repo.unlock()
         return return_revisions
 
 
@@ -1443,8 +1439,7 @@
                 if tree is None:
                     tree = bi.branch.basis_tree()
 
-                tree.lock_read()
-                try:
+                with tree.lock_read():
                     for file_id in self.file_ids:
                         if tree.kind(tree.id2path(file_id)) in ('directory',
                                                   'tree-reference'):
@@ -1452,8 +1447,6 @@
                             break
                     if self.has_dir:
                         break
-                finally:
-                    tree.unlock()
 
             if revids is None:
                 revids = [rev.revid for rev in self.graph_viz.revisions]
@@ -1485,8 +1478,7 @@
             self.filter_changed_callback(changed_revs, False)
             self.graph_viz.update_ui()
 
-        repo.lock_read()
-        try:
+        with repo.lock_read():
             if not self.uses_inventory():
                 text_keys = [(file_id, revid)
                                 for revid in revids
@@ -1508,8 +1500,6 @@
                     self.graph_viz.update_ui()
 
                 check_text_keys(text_keys)
-        finally:
-            repo.unlock()
 
     def load_filter_file_id_chunk_finished(self):
         self.filter_changed_callback([], True)
@@ -1555,8 +1545,7 @@
 
         :return: True if a change is found. False otherwise
         """
-        tree.lock_read()
-        try:
+        with tree.lock_read():
             # Copied from mutabletree, cause we need file_ids too.
             # Check pending merges
             if len(tree.get_parent_ids()) > 1:
@@ -1579,8 +1568,6 @@
             except StopIteration:
                 # No changes
                 return False
-        finally:
-            tree.unlock()
 
     def get_revision_visible(self, rev):
         if rev.revid.startswith(CURRENT_REVISION):

=== modified file 'lib/spellcheck_enchant.py'
--- lib/spellcheck_enchant.py	2019-10-27 14:48:19 +0000
+++ lib/spellcheck_enchant.py	2022-07-06 15:37:54 +0000
@@ -30,7 +30,7 @@
         text = self._text[offset:]
         if not text:
             raise StopIteration()
-        match = re.match('(\w+?)[A-Z]', text)
+        match = re.match(br'(\w+?)[A-Z]', text)
         if match is None:
             word = text
         else:
@@ -60,7 +60,7 @@
         self.checker.set_text(text)
         for err in self.checker:
             yield err.wordpos, len(err.word)
-    
+
     def suggest(self, text):
         return self.dict.suggest(text)
 

=== modified file 'lib/subprocess.py'
--- lib/subprocess.py	2022-04-14 11:45:16 +0000
+++ lib/subprocess.py	2022-07-06 15:37:54 +0000
@@ -847,12 +847,9 @@
         if not os.path.isdir(qdir):
             os.makedirs(qdir)
         fd, fname = tempfile.mkstemp(dir=qdir)
-        f = os.fdopen(fd, "wb")
-        try:
+        with os.fdopen(fd, "wb") as f:
             # f.write(text.decode('utf8'))
             f.write(text)
-        finally:
-            f.close()   # it closes fd as well
         self._args_file = fname
         return fname
 
@@ -1074,11 +1071,8 @@
     if s_cmd[0][0] == '@':
         fname = s_cmd[1:]
         # Changed this: it's written in 'b' so must be read that way too
-        f = open(fname, 'rb')
-        try:
+        with open(fname, 'rb') as f:
             s_cmd = f.read()
-        finally:
-            f.close()
         # We stored a bencoded string like b'l6:ignore18:qbrz-setup-iss.loge', so...:
         s_cmd = bencode.bdecode(s_cmd)
         # ...and again, sometimes we get a list like [b'ignore', b'qbrz-setup-iss.log'], so...

=== modified file 'lib/tests/test_extdiff.py'
--- lib/tests/test_extdiff.py	2020-07-05 15:21:39 +0000
+++ lib/tests/test_extdiff.py	2022-07-06 15:37:54 +0000
@@ -25,11 +25,11 @@
 
     def test_no_arguments(self):
         self.differ.set_command_string("test")
-        self.assertEqual(self.differ.command_template, ["test", "@old_path", "@new_path"])
+        self.assertEqual(self.differ.command_template, ["test", "{old_path}", "{new_path}"])
 
     def test_has_arguments(self):
-        self.differ.set_command_string("test --old @old_path --new @new_path")
-        self.assertEqual(self.differ.command_template, ["test", "--old", "@old_path", "--new", "@new_path"])
+        self.differ.set_command_string("test --old {old_path} --new {new_path}")
+        self.assertEqual(self.differ.command_template, ["test", "--old", "{old_path}", "--new", "{new_path}"])
 
 class TestPrefix(QTestCase):
     def setUp(self):
@@ -221,7 +221,7 @@
     def assertPopen(self, paths, old_contents):
         for args, path, old_content in zip(self.popen_mock.args, paths, old_contents):
             # tool, old_path, new_path = args[0][0]
-            tool, _, _, old_path, new_path = args[0][0]
+            tool, old_path, new_path = args[0][0]
             self.assertEqual(tool, "diff.exe")
             self.assertFileContent(old_path, old_content)
             self.assertEqual(new_path, self.tree.abspath(path))

=== modified file 'lib/tests/test_guidebar.py'
--- lib/tests/test_guidebar.py	2021-01-05 16:26:04 +0000
+++ lib/tests/test_guidebar.py	2022-07-06 15:37:54 +0000
@@ -24,7 +24,7 @@
     def __init__(self, tree):
         self.tree = tree
 
-    def get_diff_window_args(self, processEvents, add_cleanup):
+    def get_diff_window_args(self, processEvents, es):
         # This will be used by DiffWindow::_initial_load
         return dict(
             old_tree=self.tree.basis_tree(),

=== modified file 'lib/treewidget.py'
--- lib/treewidget.py	2022-01-08 11:48:59 +0000
+++ lib/treewidget.py	2022-07-06 15:37:54 +0000
@@ -485,16 +485,10 @@
 
         if isinstance(self.tree, WorkingTree):
             # print(':::-> tree.lock_read (try) about to execute')
-            tree.lock_read()
-            try:
-                # RJL Breezy release notes state that:
-                #
-                #  The ``Tree.get_root_id`` method has been removed. Use``Tree.path2id('')`` instead. (Jelmer Vernooij)
-                #
+            with tree.lock_read():
                 root_id = self.tree.path2id('')
                 basis_tree = self.tree.basis_tree()
-                basis_tree.lock_read()
-                try:
+                with basis_tree.lock_read():
                     # print(':::->>second try block')
                     for the_change in self.tree.iter_changes(basis_tree, want_unversioned=want_unversioned):
                         # iter_changes now seems to appear to return a TreeChange type See Jelmer's 7390.
@@ -641,12 +635,8 @@
                             dir_fileid = self.tree.path2id(dir_path)
                             # print('\tname setting gave ', item_data, item_data.path, dir_path, name, dir_fileid)
                             item_data.item.name = get_name(dir_fileid, dir_path, item_data.path, item_data.change)
-                finally:
-                    basis_tree.unlock()
                 # print('\n\t\t FIRST process_tree...', initial_checked_paths, load_dirs)
                 self.process_tree(self.working_tree_get_children, initial_checked_paths, load_dirs)
-            finally:
-                tree.unlock()
         else:
             # print('\n\t\t SECOND process_tree...', initial_checked_paths, load_dirs)
             self.process_tree(self.revision_tree_get_children, initial_checked_paths, load_dirs)
@@ -1579,11 +1569,8 @@
         self.change_load_filter = change_load_filter
 
         if branch:
-            branch.lock_read()
-            try:
+            with branch.lock_read():
                 last_revno = branch.last_revision_info()[0]
-            finally:
-                branch.unlock()
             self.revno_item_delegate.set_max_revno(last_revno)
         # update width uncoditionally because we may change the revno column
         self.set_header_width_settings()
@@ -1656,8 +1643,7 @@
 
     def restore_state(self, state):
         (checked, expanded, selected, v_scroll) = state
-        self.tree.lock_read()
-        try:
+        with self.tree.lock_read():
             if self.tree_model.checkable and checked is not None:
                 for (ref, state) in checked:
                     if not state == QtCore.Qt.PartiallyChecked:
@@ -1679,12 +1665,9 @@
                     QtCore.QItemSelectionModel.SelectCurrent |
                     QtCore.QItemSelectionModel.Rows)
             self.verticalScrollBar().setValue(v_scroll)
-        finally:
-            self.tree.unlock()
 
     def refresh(self):
-        self.tree.lock_read()
-        try:
+        with self.tree.lock_read():
             state = self.get_state()
             self.tree_model.set_tree(self.tree, self.branch,
                                      self.changes_mode, self.want_unversioned,
@@ -1699,8 +1682,6 @@
                 # after every time we do a layout changed. The issue is similar to
                 # http://www.qtsoftware.com/developer/task-tracker/index_html?method=entry&id=236755
                 self.set_header_width_settings()
-        finally:
-            self.tree.unlock()
 
     def mousePressEvent(self, event):
         index = self.indexAt(event.pos())
@@ -1917,11 +1898,8 @@
         item = items[0]
 
         if isinstance(self.tree, WorkingTree):
-            self.tree.lock_read()
-            try:
+            with self.tree.lock_read():
                 abspath = self.tree.abspath(item.path)
-            finally:
-                self.tree.unlock()
             url = QtCore.QUrl.fromLocalFile(abspath)
             QtGui.QDesktopServices.openUrl(url)
         else:
@@ -2020,11 +1998,8 @@
             QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No)
         if res == QtWidgets.QMessageBox.Yes:
             try:
-                self.tree.lock_write()
-                try:
+                with self.tree.lock_write():
                     self.tree.revert(paths, self.tree.basis_tree())
-                finally:
-                    self.tree.unlock()
             except Exception:
                 report_exception(type=SUB_LOAD_METHOD, window=self.window())
             # XXX - it would be good it we could just refresh the selected items

=== modified file 'lib/widgets/shelve.py'
--- lib/widgets/shelve.py	2021-01-06 09:29:35 +0000
+++ lib/widgets/shelve.py	2022-07-06 15:37:54 +0000
@@ -17,6 +17,8 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 
+from contextlib import ExitStack
+import os
 import sys, time
 from PyQt5 import QtCore, QtGui, QtWidgets
 
@@ -56,8 +58,6 @@
 from breezy.shelf import ShelfCreator
 from breezy.shelf_ui import Shelver
 from breezy.osutils import split_lines
-from cStringIO import StringIO
-import os
 ''')
 
 
@@ -453,15 +453,14 @@
         self.hunk_view.set_tab_width(pixels)
 
     def refresh(self):
-        cleanup = []
-        try:
+        with ExitStack() as es:
             old_rev = self.revision
             old_changes = self._get_change_dictionary()
             self.clear(clear_message = False)
 
             shelver, creator = self._create_shelver_and_creator()
-            cleanup.append(shelver.finalize)
-            cleanup.append(creator.finalize)
+            es.callback(shelver.finalize)
+            es.callback(creator.finalize)
 
             file_list = shelver.file_list
             if file_list:
@@ -489,10 +488,6 @@
                 item = self._create_item(change, shelver, self.trees, old_changes)
                 self.file_view.addTopLevelItem(item)
 
-        finally:
-            for func in cleanup:
-                func()
-
         if self.select_all:
             self.check_all(True)
             self.select_all = False
@@ -625,16 +620,15 @@
         self.loaded = False
 
     def use_editor(self):
-        cleanup = []
         items = self.file_view.selectedItems()
         if len(items) != 1 or items[0].change.status != 'modify text':
             return
         else:
             change = items[0].change
-        try:
+        with ExitStack() as es:
             target_tree, work_tree = self.trees
-            cleanup.append(work_tree.lock_read().unlock)
-            cleanup.append(target_tree.lock_read().unlock)
+            es.enter_context(work_tree.lock_read())
+            es.enter_context(target_tree.lock_read())
             config = work_tree.branch.get_config()
             change_editor = config.get_change_editor(target_tree, work_tree)
             if change_editor is None:
@@ -643,16 +637,13 @@
                 self.editor_button.setEnabled(False)
                 return
 
-            cleanup.append(change_editor.finish)
+            es.callback(change_editor.finish)
             lines = split_lines(change_editor.edit_file(change.file_id))
             change_count = Shelver._count_changed_regions(change.work_lines, lines)
             if change_count > 0:
                 change.edited_lines = lines
                 self.update_item(items[0])
                 self.selected_file_changed()
-        finally:
-            while cleanup:
-                cleanup.pop()()
 
     def _get_change_dictionary(self):
         change_dict = {}
@@ -683,59 +674,56 @@
             QtWidgets.QMessageBox.information(self, gettext('Shelve'), gettext('No changes selected.'), gettext('&OK'))
             return
 
-        cleanup = []
-        try:
-            shelver, creator = self._create_shelver_and_creator(destroy=destroy)
-            cleanup.append(shelver.finalize)
-            cleanup.append(creator.finalize)
-            trees = (shelver.target_tree, shelver.work_tree)
-            if len(trees[1].get_parent_ids()) > 1:
-                raise WorkingTreeHasPendingMarge
-            if self.revision != trees[0].get_revision_id():
-                raise WorkingTreeHasChanged
-
-            changes = []
-            for ch in creator.iter_shelvable():
-                change = Change(ch, shelver, trees)
-                key = (change.file_id, change.status)
-                org_change = change_dict.get(key)
-                if org_change is None:
-                    continue
-                if not change.is_same_change(org_change):
-                    raise WorkingTreeHasChanged
-                del(change_dict[key])
-                changes.append(org_change)
-
-            if change_dict:
-                raise WorkingTreeHasChanged
-
-            for change in changes:
-                if change.status == 'modify text':
-                    self.handle_modify_text(creator, change)
-                elif change.status == 'modify binary':
-                    creator.shelve_content_change(change.data[1])
+        with ExitStack() as es:
+            try:
+                shelver, creator = self._create_shelver_and_creator(destroy=destroy)
+                es.callback(shelver.finalize)
+                es.callback(creator.finalize)
+                trees = (shelver.target_tree, shelver.work_tree)
+                if len(trees[1].get_parent_ids()) > 1:
+                    raise WorkingTreeHasPendingMarge
+                if self.revision != trees[0].get_revision_id():
+                    raise WorkingTreeHasChanged
+
+                changes = []
+                for ch in creator.iter_shelvable():
+                    change = Change(ch, shelver, trees)
+                    key = (change.file_id, change.status)
+                    org_change = change_dict.get(key)
+                    if org_change is None:
+                        continue
+                    if not change.is_same_change(org_change):
+                        raise WorkingTreeHasChanged
+                    del(change_dict[key])
+                    changes.append(org_change)
+
+                if change_dict:
+                    raise WorkingTreeHasChanged
+
+                for change in changes:
+                    if change.status == 'modify text':
+                        self.handle_modify_text(creator, change)
+                    elif change.status == 'modify binary':
+                        creator.shelve_content_change(change.data[1])
+                    else:
+                        creator.shelve_change(change.data)
+                manager = shelver.work_tree.get_shelf_manager()
+                message = str(self.message.toPlainText()).strip() or gettext('<no message>')
+                if destroy:
+                    creator.transform()
+                    shelf_id = -1
                 else:
-                    creator.shelve_change(change.data)
-            manager = shelver.work_tree.get_shelf_manager()
-            message = str(self.message.toPlainText()).strip() or gettext('<no message>')
-            if destroy:
-                creator.transform()
-                shelf_id = -1
-            else:
-                shelf_id = manager.shelve_changes(creator, message)
-
-        except WorkingTreeHasPendingMarge:
-            QtWidgets.QMessageBox.warning(self, gettext('Shelve'),
-                    gettext('Operation aborted because working tree has pending merges.'), gettext('&OK'))
-            return
-        except WorkingTreeHasChanged:
-            QtWidgets.QMessageBox.warning(self, gettext('Shelve'),
-                    gettext('Operation aborted because target files has been changed.'), gettext('&OK'))
-            return
-
-        finally:
-            while cleanup:
-                cleanup.pop()()
+                    shelf_id = manager.shelve_changes(creator, message)
+
+            except WorkingTreeHasPendingMarge:
+                QtWidgets.QMessageBox.warning(self, gettext('Shelve'),
+                        gettext('Operation aborted because working tree has pending merges.'), gettext('&OK'))
+                return
+            except WorkingTreeHasChanged:
+                QtWidgets.QMessageBox.warning(self, gettext('Shelve'),
+                        gettext('Operation aborted because target files has been changed.'), gettext('&OK'))
+                return
+
         self.shelfCreated.emit(shelf_id)
         self.clear()
 
@@ -888,12 +876,12 @@
                 continue
             if bottom < y1:
                 break
-            painter.fillRect(6, y1, 13, 13, QtCore.Qt.white)
+            painter.fillRect(6, int(y1), 13, 13, QtCore.Qt.white)
 
-            painter.drawRect(6, y1, 13, 13)
+            painter.drawRect(6, int(y1), 13, 13)
             if hunk.selected:
-                painter.drawLine(9, y1 + 7, 12, y1 + 10)
-                painter.drawLine(16, y1 + 3, 12, y1 + 10)
+                painter.drawLine(9, int(y1) + 7, 12, int(y1) + 10)
+                painter.drawLine(16, int(y1) + 3, 12, int(y1) + 10)
 
         del painter
 
@@ -942,7 +930,7 @@
         self.monospacedInactiveFormat.setForeground(QtGui.QColor(128, 128, 128))
 
         titleFont = QtGui.QFont(monospacedFont)
-        titleFont.setPointSize(titleFont.pointSize() * 140 / 100)
+        titleFont.setPointSize(titleFont.pointSize() * 140 // 100)
         titleFont.setBold(True)
         titleFont.setItalic(True)
 
@@ -1062,17 +1050,17 @@
                 continue
             if not self.complete:
                 # Fill header rect.
-                painter.fillRect(left, y1, width, 20, self.header_color)
+                painter.fillRect(left, int(y1), width, 20, self.header_color)
             # Overlay focus rect.
             if i == self._focused_index:
                 if self.hasFocus():
                     color = self.focus_color
                 else:
                     color = self.focus_color_inactive
-                painter.fillRect(left, y1, width, y2 - y1, color)
+                painter.fillRect(left, int(y1), width, int(y2 - y1), color)
             # Draw border.
-            painter.drawLine(left, y1, right, y1)
-            painter.drawLine(left, y2, right, y2)
+            painter.drawLine(left, int(y1), right, int(y1))
+            painter.drawLine(left, int(y2), right, int(y2))
 
     def move_next(self):
         index = int(self._focused_index + 1)
@@ -1127,8 +1115,8 @@
             MARGIN = 24
             height = self.viewport().height()
             cur_pos = sbar.value()
-            max_pos = self.hunk_list[index][1] - MARGIN
-            min_pos = self.hunk_list[index][2] - height + MARGIN
+            max_pos = int(self.hunk_list[index][1] - MARGIN)
+            min_pos = int(self.hunk_list[index][2] - height + MARGIN)
             if max_pos <= min_pos or max_pos < cur_pos:
                 sbar.setValue(max_pos)
             elif cur_pos < min_pos:

=== modified file 'lib/widgets/shelvelist.py'
--- lib/widgets/shelvelist.py	2021-01-06 09:29:35 +0000
+++ lib/widgets/shelvelist.py	2022-07-06 15:37:54 +0000
@@ -17,6 +17,8 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 
+from contextlib import ExitStack
+
 import sys, time
 from PyQt5 import QtCore, QtGui, QtWidgets
 from PyQt5.QtGui import QKeySequence
@@ -55,7 +57,6 @@
 from breezy.plugins.qbrz.lib.widgets.texteditaccessory import setup_guidebar_for_find
 from breezy.lazy_import import lazy_import
 lazy_import(globals(), '''
-from breezy import transform
 from breezy.workingtree import WorkingTree
 from breezy.plugins.qbrz.lib.encoding_selector import EncodingMenuSelector
 from breezy.plugins.qbrz.lib.diff import DiffItem
@@ -274,8 +275,7 @@
         self.loaded = False
         self.clear()
         tree = WorkingTree.open_containing(self.directory)[0]
-        tree.lock_read()
-        try:
+        with tree.lock_read():
             manager = tree.get_shelf_manager()
             shelves = manager.active_shelves()
             for shelf_id in reversed(shelves):
@@ -298,8 +298,6 @@
             self.tabwidth_selector.setTabWidth(tabwidth)
             self._on_tabwidth_changed(tabwidth)
 
-        finally:
-            tree.unlock()
         self.update()
         self.loaded = True
 
@@ -312,18 +310,17 @@
         self.manager = None
 
     def show_changes(self, shelf_id):
-        cleanup = []
         shelf_file = self.manager.read_shelf(shelf_id)
-        cleanup.append(shelf_file.close)
-        try:
+        with ExitStack() as es:
+            es.callback(shelf_file.close)
             records = Unshelver.iter_records(shelf_file)
             revid = Unshelver.parse_metadata(records)[b'revision_id']
             try:
                 base_tree = self.tree.revision_tree(revid)
             except NoSuchRevisionInTree:
                 base_tree = self.tree.branch.repository.revision_tree(revid)
-            preview = transform.TransformPreview(base_tree)
-            cleanup.append(preview.finalize)
+            preview = base_tree.preview_transform()
+            es.callback(preview.finalize)
             preview.deserialize(records)
 
             tabwidth = get_tab_width_pixels(self.tree.branch)
@@ -332,10 +329,6 @@
 
             self.load_diff(preview.get_preview_tree(), base_tree)
 
-        finally:
-            for func in cleanup:
-                func()
-
     def load_diff(self, tree, base_tree):
         self.file_view.clear()