Merge lp:~jelmer/brz/reforma into lp:brz

[Jelmer Vernooij]

Format-check rust files

Format-check rust files

[Jelmer Vernooij (jelmer)]

review: Approve

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

There are additional revisions which have not been approved in review. Please seek review and approval of these new revisions.

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

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

Collecting setuptools-gettext
  Downloading setuptools_gettext-0.1.3-py3-none-any.whl (10 kB)
Requirement already satisfied: setuptools>=46.1 in ./lib/python3.11/site-packages (from setuptools-gettext) (66.1.1)
Installing collected packages: setuptools-gettext
Successfully installed setuptools-gettext-0.1.3
Obtaining file:///tmp/tarmac/branch._sff7o00
  Installing build dependencies: started
  Installing build dependencies: finished with status 'done'
  Checking if build backend supports build_editable: started
  Checking if build backend supports build_editable: finished with status 'done'
  Getting requirements to build editable: started
  Getting requirements to build editable: finished with status 'done'
  Installing backend dependencies: started
  Installing backend dependencies: finished with status 'done'
  Preparing editable metadata (pyproject.toml): started
  Preparing editable metadata (pyproject.toml): finished with status 'done'
Requirement already satisfied: configobj in /usr/lib/python3/dist-packages (from breezy==3.3.3.dev0) (5.0.8)
Requirement already satisfied: fastbencode in /usr/lib/python3/dist-packages (from breezy==3.3.3.dev0) (0.2)
Requirement already satisfied: patiencediff in /usr/lib/python3/dist-packages (from breezy==3.3.3.dev0) (0.2.13)
Requirement already satisfied: merge3 in /usr/lib/python3/dist-packages (from breezy==3.3.3.dev0) (0.0.8)
Collecting dulwich>=0.21.3
  Downloading dulwich-0.21.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (508 kB)
     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 508.2/508.2 kB 7.3 MB/s eta 0:00:00
Requirement already satisfied: urllib3>=1.24.1 in /usr/lib/python3/dist-packages (from breezy==3.3.3.dev0) (1.26.12)
Requirement already satisfied: pyyaml in /usr/lib/python3/dist-packages (from breezy==3.3.3.dev0) (6.0)
Collecting testtools
  Downloading testtools-2.6.0-py3-none-any.whl (182 kB)
     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 182.2/182.2 kB 6.4 MB/s eta 0:00:00
Collecting testscenarios
  Downloading testscenarios-0.5.0-py2.py3-none-any.whl (21 kB)
Collecting python-subunit
  Downloading python_subunit-1.4.2-py3-none-any.whl (106 kB)
     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 106.8/106.8 kB 5.1 MB/s eta 0:00:00
Requirement already satisfied: flake8 in /usr/lib/python3/dist-packages (from breezy==3.3.3.dev0) (5.0.4)
Collecting cython>=0.29
  Using cached Cython-0.29.34-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl (1.9 MB)
Collecting docutils
  Downloading docutils-0.19-py3-none-any.whl (570 kB)
     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 570.5/570.5 kB 9.1 MB/s eta 0:00:00
Requirement already satisfied: setuptools in ./lib/python3.11/site-packages (from breezy==3.3.3.dev0) (66.1.1)
Collecting sphinx
  Downloading sphinx-6.1.3-py3-none-any.whl (3.0 MB)
     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 3.0/3.0 MB 10.3 MB/s eta 0:00:00
Collecting sphinx-epytext
  Downloading sphinx-epytext-0.0.4.tar.gz (3.6 kB)
  Preparing metadata (setup.py): started
  Preparing metadata (setup.py): finished with statu...

[lp:~jelmer/brz/reforma]

7729. By Jelmer Vernooij on 2023-04-17

Port MergeSorter to rust

by jelmer review by jelmer

7730. By Jelmer Vernooij on 2023-04-17

Format-check rust files

by jelmer review by jelmer

=== modified file '.bzrignore'
--- .bzrignore	2023-04-14 10:23:02 +0000
+++ .bzrignore	2023-04-17 11:56:43 +0000
@@ -80,3 +80,4 @@
 ./target
 ./brz
 *.so
+.pytest_cache

=== modified file 'Makefile'
--- Makefile	2023-02-06 23:24:27 +0000
+++ Makefile	2023-04-17 11:56:43 +0000
@@ -74,6 +74,11 @@
 flake8:
 	flake8 breezy
 
+fmt-check:
+	find . -name '*.rs' | xargs rustfmt --check
+	flake8 breezy
+	isort --check-only
+
 mypy:
 	mypy breezy
 
@@ -317,3 +322,4 @@
 
 reformat:
 	isort .
+	find . -name '*.rs' | xargs rustfmt

=== modified file 'breezy/bzr/chk_map.py'
--- breezy/bzr/chk_map.py	2023-04-05 18:13:47 +0000
+++ breezy/bzr/chk_map.py	2023-04-17 11:56:43 +0000
@@ -1710,15 +1710,14 @@
     return iterator.process()
 
 
-from ._chk_map_rs import _search_key_16, _search_key_255, _bytes_to_text_key
+from ._chk_map_rs import _bytes_to_text_key, _search_key_16, _search_key_255
 
 try:
     from ._chk_map_pyx import (_deserialise_internal_node,
                                _deserialise_leaf_node)
 except ImportError as e:
     osutils.failed_to_load_extension(e)
-    from ._chk_map_py import (_deserialise_internal_node,
-                              _deserialise_leaf_node)
+    from ._chk_map_py import _deserialise_internal_node, _deserialise_leaf_node
 search_key_registry.register(b'hash-16-way', _search_key_16)
 search_key_registry.register(b'hash-255-way', _search_key_255)
 

=== modified file 'breezy/bzr/dirstate.py'
--- breezy/bzr/dirstate.py	2023-04-11 06:38:51 +0000
+++ breezy/bzr/dirstate.py	2023-04-17 11:56:43 +0000
@@ -4316,14 +4316,9 @@
         return dir_info
 
 
-from ._dirstate_rs import (
-    lt_by_dirs,
-    bisect_path_left,
-    bisect_path_right,
-    bisect_dirblock,
-    DefaultSHA1Provider,
-    pack_stat,
-    )
+from ._dirstate_rs import (DefaultSHA1Provider, bisect_dirblock,
+                           bisect_path_left, bisect_path_right, lt_by_dirs,
+                           pack_stat)
 
 # Try to load the compiled form if possible
 try:

=== modified file 'breezy/bzr/groupcompress.py'
--- breezy/bzr/groupcompress.py	2023-04-07 21:31:19 +0000
+++ breezy/bzr/groupcompress.py	2023-04-17 11:56:43 +0000
@@ -2234,9 +2234,10 @@
 GroupCompressor: Type[_CommonGroupCompressor]
 
 
-from ._groupcompress_rs import decode_base128_int, encode_base128_int, decode_copy_instruction, apply_delta, apply_delta_to_source
-
 from ._groupcompress_py import LinesDeltaIndex
+from ._groupcompress_rs import (apply_delta, apply_delta_to_source,
+                                decode_base128_int, decode_copy_instruction,
+                                encode_base128_int)
 
 try:
     from ._groupcompress_pyx import DeltaIndex

=== modified file 'breezy/bzr/smart/repository.py'
--- breezy/bzr/smart/repository.py	2023-04-13 22:19:43 +0000
+++ breezy/bzr/smart/repository.py	2023-04-17 11:56:43 +0000
@@ -27,9 +27,9 @@
 
 import fastbencode as bencode
 
-from ... import errors, zlib_util, osutils
+from ... import errors, osutils
 from ... import revision as _mod_revision
-from ... import trace, ui
+from ... import trace, ui, zlib_util
 from ...repository import _strip_NULL_ghosts, network_format_registry
 from .. import inventory as _mod_inventory
 from .. import inventory_delta, pack, vf_search

=== modified file 'breezy/bzr/tests/test_chk_map.py'
--- breezy/bzr/tests/test_chk_map.py	2023-04-05 18:13:47 +0000
+++ breezy/bzr/tests/test_chk_map.py	2023-04-17 11:56:43 +0000
@@ -18,7 +18,8 @@
 
 from ... import errors, osutils, tests
 from .. import chk_map, groupcompress
-from ..chk_map import CHKMap, InternalNode, LeafNode, Node, _search_key_16, _search_key_255, _bytes_to_text_key
+from ..chk_map import (CHKMap, InternalNode, LeafNode, Node,
+                       _bytes_to_text_key, _search_key_16, _search_key_255)
 from ..static_tuple import StaticTuple
 
 stuple = StaticTuple

=== modified file 'breezy/bzr/tests/test_rio.py'
--- breezy/bzr/tests/test_rio.py	2023-04-14 13:31:48 +0000
+++ breezy/bzr/tests/test_rio.py	2023-04-17 11:56:43 +0000
@@ -27,10 +27,11 @@
 
 from breezy.tests import TestCase
 
+from ...osutils import IterableFile
 from .. import rio
-from ...osutils import IterableFile
-from ..rio import RioReader, Stanza, read_stanza, read_stanzas, rio_iter  # type: ignore
-from ..rio_patch import to_patch_lines, read_patch_stanza
+from ..rio import (RioReader, Stanza, read_stanza,  # type: ignore
+                   read_stanzas, rio_iter)
+from ..rio_patch import read_patch_stanza, to_patch_lines
 
 
 def rio_file(stanzas):

=== modified file 'breezy/bzr/weave.py'
--- breezy/bzr/weave.py	2023-04-08 18:48:50 +0000
+++ breezy/bzr/weave.py	2023-04-17 11:56:43 +0000
@@ -64,11 +64,11 @@
 
 # FIXME: the conflict markers should be *7* characters
 
+import hashlib
 import os
 from copy import copy
 from io import BytesIO
 
-import hashlib
 import patiencediff
 
 from ..lazy_import import lazy_import

=== modified file 'breezy/git/interrepo.py'
--- breezy/git/interrepo.py	2023-03-31 22:01:18 +0000
+++ breezy/git/interrepo.py	2023-04-17 11:56:43 +0000
@@ -17,25 +17,27 @@
 """InterRepository operations."""
 
 import itertools
-from typing import Callable, Dict, Tuple, Optional
+from typing import Callable, Dict, Optional, Tuple
 
 from dulwich.errors import NotCommitError
+from dulwich.object_store import ObjectStoreGraphWalker
 from dulwich.objects import ObjectID
-from dulwich.object_store import ObjectStoreGraphWalker
 from dulwich.pack import PACK_SPOOL_FILE_MAX_SIZE
 from dulwich.protocol import CAPABILITY_THIN_PACK, ZERO_SHA
 from dulwich.refs import SYMREF
+
 try:
     from dulwich.refs import PEELED_TAG_SUFFIX
 except ImportError:  # dulwich < 0.21.3
     from dulwich.refs import ANNOTATED_TAG_SUFFIX as PEELED_TAG_SUFFIX
+
 from dulwich.walk import Walker
 
 from .. import config, trace, ui
 from ..errors import (DivergedBranches, FetchLimitUnsupported,
                       InvalidRevisionId, LossyPushToSameVCS,
                       NoRoundtrippingSupport, NoSuchRevision)
-from ..repository import FetchResult, InterRepository, AbstractSearchResult
+from ..repository import AbstractSearchResult, FetchResult, InterRepository
 from ..revision import NULL_REVISION, RevisionID
 from .errors import NoPushSupport
 from .fetch import DetermineWantsRecorder, import_git_objects
@@ -47,7 +49,6 @@
 from .repository import GitRepository, GitRepositoryFormat, LocalGitRepository
 from .unpeel_map import UnpeelMap
 
-
 EitherId = Tuple[Optional[RevisionID], Optional[ObjectID]]
 EitherRefDict = Dict[bytes, EitherId]
 RevidMap = Dict[RevisionID, Tuple[ObjectID, RevisionID]]

=== modified file 'breezy/git/refs.py'
--- breezy/git/refs.py	2023-04-07 22:04:39 +0000
+++ breezy/git/refs.py	2023-04-17 11:56:43 +0000
@@ -17,11 +17,13 @@
 """Conversion between refs and Bazaar revision pointers."""
 
 from dulwich.objects import Tag, object_class
-from dulwich.refs import (LOCAL_BRANCH_PREFIX, LOCAL_TAG_PREFIX)
+from dulwich.refs import LOCAL_BRANCH_PREFIX, LOCAL_TAG_PREFIX
+
 try:
     from dulwich.refs import PEELED_TAG_SUFFIX
 except ImportError:
     from dulwich.refs import ANNOTATED_TAG_SUFFIX as PEELED_TAG_SUFFIX
+
 from dulwich.repo import RefsContainer
 
 from .. import controldir, errors, osutils

=== modified file 'breezy/graph.py'
--- breezy/graph.py	2023-04-16 03:18:03 +0000
+++ breezy/graph.py	2023-04-17 11:56:43 +0000
@@ -1582,7 +1582,7 @@
             return revs, ghosts
 
 
-from ._graph_rs import invert_parent_map, collapse_linear_regions
+from ._graph_rs import collapse_linear_regions, invert_parent_map
 
 
 class GraphThunkIdsToKeys:

=== modified file 'breezy/log.py'
--- breezy/log.py	2023-04-13 21:30:33 +0000
+++ breezy/log.py	2023-04-17 11:56:43 +0000
@@ -73,11 +73,10 @@
 from . import revision as _mod_revision
 from . import revisionspec, trace
 from . import transport as _mod_transport
-from .osutils import (format_date,
+from .osutils import (UnsupportedTimezoneFormat, format_date,
                       format_date_with_offset_in_original_timezone,
                       get_diff_header_encoding, get_terminal_encoding,
-                      is_inside, terminal_width,
-                      UnsupportedTimezoneFormat)
+                      is_inside, terminal_width)
 from .tree import InterTree
 
 

=== modified file 'breezy/main.rs'
--- breezy/main.rs	2023-04-15 03:34:42 +0000
+++ breezy/main.rs	2023-04-17 11:56:43 +0000
@@ -2,7 +2,6 @@
 use pyo3::types::*;
 use std::path::*;
 
-
 fn check_version(py: Python<'_>) -> PyResult<()> {
     let major: u32 = env!("CARGO_PKG_VERSION_MAJOR").parse::<u32>().unwrap();
     let minor: u32 = env!("CARGO_PKG_VERSION_MINOR").parse::<u32>().unwrap();
@@ -66,7 +65,7 @@
 fn update_path(py: Python<'_>) -> PyResult<()> {
     let mut path = std::env::current_exe()?;
 
-    path.pop();  // Drop executable name
+    path.pop(); // Drop executable name
 
     let mut package_path = path.clone();
     package_path.push("breezy");

=== modified file 'breezy/merge_directive.py'
--- breezy/merge_directive.py	2023-04-14 21:30:07 +0000
+++ breezy/merge_directive.py	2023-04-17 11:56:43 +0000
@@ -38,13 +38,9 @@
     serializer as bundle_serializer,
     )
 """)
-from . import (
-    branch as _mod_branch,
-    errors,
-    hooks,
-    registry,
-    revision as _mod_revision,
-)
+from . import branch as _mod_branch
+from . import errors, hooks, registry
+from . import revision as _mod_revision
 
 
 class IllegalMergeDirectivePayload(errors.BzrError):

=== modified file 'breezy/osutils.py'
--- breezy/osutils.py	2023-04-16 11:47:42 +0000
+++ breezy/osutils.py	2023-04-17 11:56:43 +0000
@@ -22,7 +22,7 @@
 import sys
 import time
 from functools import partial
-from typing import Dict, List, Iterable
+from typing import Dict, Iterable, List
 
 from .lazy_import import lazy_import
 
@@ -49,7 +49,7 @@
 
 import breezy
 
-from . import errors, _osutils_rs
+from . import _osutils_rs, errors
 
 # On win32, O_BINARY is used to indicate the file should
 # be opened in binary mode, rather than text mode.
@@ -73,7 +73,6 @@
 
 from ._osutils_rs import get_umask, kind_marker, quotefn
 
-
 lexists = getattr(os.path, 'lexists', None)
 if lexists is None:
     def lexists(f):
@@ -646,7 +645,10 @@
     # https://bugs.launchpad.net/bzr/+bug/430529
 
 
-from ._osutils_rs import chunks_to_lines, chunks_to_lines_iter, normalized_filename, _inaccessible_normalized_filename, _accessible_normalized_filename, normalizes_filenames, split_lines
+from ._osutils_rs import (_accessible_normalized_filename,
+                          _inaccessible_normalized_filename, chunks_to_lines,
+                          chunks_to_lines_iter, normalized_filename,
+                          normalizes_filenames, split_lines)
 
 
 def hardlinks_good():

=== modified file 'breezy/patch.py'
--- breezy/patch.py	2023-04-14 18:25:48 +0000
+++ breezy/patch.py	2023-04-17 11:56:43 +0000
@@ -17,7 +17,8 @@
 
 """Diff and patch functionality"""
 
-from ._patch_rs import patch, diff3, iter_patched_from_hunks, run_patch, PatchInvokeError, PatchFailed
+from ._patch_rs import (PatchFailed, PatchInvokeError, diff3,
+                        iter_patched_from_hunks, patch, run_patch)
 
 
 def patch_tree(tree, patches, strip=0, reverse=False, dry_run=False,

=== modified file 'breezy/patches.py'
--- breezy/patches.py	2023-04-16 01:30:53 +0000
+++ breezy/patches.py	2023-04-17 11:56:43 +0000
@@ -57,7 +57,8 @@
         self.line = line
 
 
-from ._patch_rs import get_patch_names, BinaryFiles, MalformedPatchHeader, iter_lines_handle_nl, parse_range, difference_index
+from ._patch_rs import (BinaryFiles, MalformedPatchHeader, difference_index,
+                        get_patch_names, iter_lines_handle_nl, parse_range)
 
 
 def hunk_from_header(line):

=== modified file 'breezy/plugins/launchpad/lp_directory.py'
--- breezy/plugins/launchpad/lp_directory.py	2023-03-31 15:00:34 +0000
+++ breezy/plugins/launchpad/lp_directory.py	2023-04-17 11:56:43 +0000
@@ -20,7 +20,7 @@
 
 from ... import debug, errors, trace, transport
 from ...i18n import gettext
-from ...urlutils import InvalidURL, split, join
+from ...urlutils import InvalidURL, join, split
 from .account import get_lp_login
 from .uris import DEFAULT_INSTANCE, LAUNCHPAD_DOMAINS, LPNET_SERVICE_ROOT
 

=== modified file 'breezy/repository.py'
--- breezy/repository.py	2023-03-09 13:47:07 +0000
+++ breezy/repository.py	2023-04-17 11:56:43 +0000
@@ -16,7 +16,7 @@
 
 __docformat__ = "google"
 
-from typing import List, Type, TYPE_CHECKING, Optional, Iterable
+from typing import TYPE_CHECKING, Iterable, List, Optional, Type
 
 from .lazy_import import lazy_import
 
@@ -30,7 +30,9 @@
 from breezy.i18n import gettext
 """)
 
-from . import controldir, debug, errors, graph, registry, revision as _mod_revision, ui
+from . import controldir, debug, errors, graph, registry
+from . import revision as _mod_revision
+from . import ui
 from .decorators import only_raises
 from .inter import InterObject
 from .lock import LogicalLockResult, _RelockDebugMixin

=== modified file 'breezy/revisiontree.py'
--- breezy/revisiontree.py	2023-04-13 16:25:22 +0000
+++ breezy/revisiontree.py	2023-04-17 11:56:43 +0000
@@ -16,7 +16,7 @@
 
 """RevisionTree - a Tree implementation backed by repository data for a revision."""
 
-from . import lock, revision, tree, osutils
+from . import lock, osutils, revision, tree
 
 
 class RevisionTree(tree.Tree):

=== modified file 'breezy/tests/test_patches.py'
--- breezy/tests/test_patches.py	2023-04-15 03:34:42 +0000
+++ breezy/tests/test_patches.py	2023-04-17 11:56:43 +0000
@@ -22,9 +22,9 @@
                             ContextLine, InsertLine, MalformedHunkHeader,
                             MalformedLine, MalformedPatchHeader, Patch,
                             RemoveLine, difference_index, get_patch_names,
-                            hunk_from_header, iter_patched,
-                            iter_patched_from_hunks, parse_line, parse_patch,
-                            parse_patches, iter_lines_handle_nl)
+                            hunk_from_header, iter_lines_handle_nl,
+                            iter_patched, iter_patched_from_hunks, parse_line,
+                            parse_patch, parse_patches)
 from breezy.tests import TestCase, TestCaseWithTransport
 
 

=== modified file 'breezy/tests/test_timestamp.py'
--- breezy/tests/test_timestamp.py	2023-04-13 22:28:22 +0000
+++ breezy/tests/test_timestamp.py	2023-04-17 11:56:43 +0000
@@ -18,7 +18,7 @@
 import time
 
 from breezy import tests, timestamp
-from breezy.osutils import local_time_offset, format_date
+from breezy.osutils import format_date, local_time_offset
 
 
 class TestPatchHeader(tests.TestCase):

=== modified file 'breezy/textfile.py'
--- breezy/textfile.py	2023-04-13 17:46:12 +0000
+++ breezy/textfile.py	2023-04-17 11:56:43 +0000
@@ -18,9 +18,9 @@
 
 from itertools import chain
 
+from . import _osutils_rs
 from .errors import BinaryFile
-from .osutils import file_iterator, IterableFile
-from . import _osutils_rs
+from .osutils import IterableFile, file_iterator
 
 
 def text_file(input):

=== modified file 'breezy/transport/http/urllib.py'
--- breezy/transport/http/urllib.py	2023-04-08 18:48:50 +0000
+++ breezy/transport/http/urllib.py	2023-04-17 11:56:43 +0000
@@ -24,8 +24,8 @@
 import base64
 import cgi
 import errno
+import hashlib
 import http.client
-import hashlib
 import os
 import re
 import socket

=== modified file 'breezy/tsort.py'
--- breezy/tsort.py	2023-04-17 00:37:30 +0000
+++ breezy/tsort.py	2023-04-17 11:56:43 +0000
@@ -23,7 +23,7 @@
 
 __all__ = ["topo_sort", "TopoSorter", "merge_sort", "MergeSorter"]
 
-from ._graph_rs import TopoSorter, MergeSorter, merge_sort
+from ._graph_rs import MergeSorter, TopoSorter, merge_sort
 
 
 def topo_sort(graph):

=== modified file 'breezy/version_info_formats/__init__.py'
--- breezy/version_info_formats/__init__.py	2023-04-14 10:04:16 +0000
+++ breezy/version_info_formats/__init__.py	2023-04-17 11:56:43 +0000
@@ -16,8 +16,8 @@
 
 """Routines for extracting all version information from a bzr branch."""
 
+import time
 from contextlib import ExitStack
-import time
 from typing import Type
 
 from breezy import registry

=== modified file 'crates/bazaar/src/filters.rs'
--- crates/bazaar/src/filters.rs	2023-04-10 22:48:06 +0000
+++ crates/bazaar/src/filters.rs	2023-04-17 11:56:43 +0000
@@ -1,8 +1,8 @@
-use std::path::Path;
+use breezy_osutils::sha::sha_chunks;
 use std::fs::File;
+use std::io::Error;
 use std::io::Read;
-use std::io::Error;
-use breezy_osutils::sha::sha_chunks;
+use std::path::Path;
 
 pub type ContentFilterProvider = dyn Fn(&Path, u64) -> Box<dyn ContentFilter> + Send;
 
@@ -20,7 +20,7 @@
     fn sha1_file(&self, path: &Path) -> Result<String, std::io::Error> {
         let mut file = File::open(path)?;
         let chunk_iter = std::iter::from_fn(move || {
-            let mut buf= vec![0; 128 << 10];
+            let mut buf = vec![0; 128 << 10];
             let bytes_read = file.read(&mut buf);
             if let Err(e) = bytes_read {
                 return Some(Err(e));
@@ -55,7 +55,7 @@
     filters: Vec<Box<dyn ContentFilter>>,
 }
 
-impl From <Vec<Box<dyn ContentFilter>>> for ContentFilterStack {
+impl From<Vec<Box<dyn ContentFilter>>> for ContentFilterStack {
     fn from(filters: Vec<Box<dyn ContentFilter>>) -> Self {
         Self { filters }
     }
@@ -63,7 +63,9 @@
 
 impl ContentFilterStack {
     pub fn new() -> Self {
-        Self { filters: Vec::new() }
+        Self {
+            filters: Vec::new(),
+        }
     }
 
     pub fn add_filter(&mut self, filter: Box<dyn ContentFilter>) {
@@ -75,17 +77,18 @@
     fn reader(
         &self,
         input: Box<dyn Iterator<Item = Result<Vec<u8>, Error>> + Send>,
-    ) -> Box<dyn Iterator<Item = Result<Vec<u8>, Error>> + Send>
-    {
-        self.filters.iter().fold(input, |input, filter| filter.reader(input))
+    ) -> Box<dyn Iterator<Item = Result<Vec<u8>, Error>> + Send> {
+        self.filters
+            .iter()
+            .fold(input, |input, filter| filter.reader(input))
     }
 
     fn writer(
         &self,
         input: Box<dyn Iterator<Item = Result<Vec<u8>, Error>> + Send>,
-    ) -> Box<dyn Iterator<Item = Result<Vec<u8>, Error>> + Send>
-    {
-        self.filters.iter().fold(input, |input, filter| filter.writer(input))
+    ) -> Box<dyn Iterator<Item = Result<Vec<u8>, Error>> + Send> {
+        self.filters
+            .iter()
+            .fold(input, |input, filter| filter.writer(input))
     }
-
 }

=== modified file 'crates/chk-map-py/src/lib.rs'
--- crates/chk-map-py/src/lib.rs	2023-04-05 19:09:07 +0000
+++ crates/chk-map-py/src/lib.rs	2023-04-17 11:56:43 +0000
@@ -1,11 +1,11 @@
 use pyo3::prelude::*;
+use pyo3::types::PyBytes;
 use pyo3::wrap_pyfunction;
-use pyo3::types::PyBytes;
 
 use bazaar_chk_map;
 
 #[pyfunction]
-fn _search_key_16(py: Python, key: Vec<Vec<u8>>) -> Py<PyBytes>{
+fn _search_key_16(py: Python, key: Vec<Vec<u8>>) -> Py<PyBytes> {
     let key = key.iter().map(|v| v.as_slice()).collect::<Vec<&[u8]>>();
     let ret = bazaar_chk_map::search_key_16(key.as_slice());
     PyBytes::new(py, &ret).into_py(py)
@@ -22,7 +22,9 @@
 fn _bytes_to_text_key(py: Python, key: Vec<u8>) -> PyResult<(&PyBytes, &PyBytes)> {
     let ret = bazaar_chk_map::bytes_to_text_key(key.as_slice());
     if ret.is_err() {
-        return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>("Invalid key"));
+        return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(
+            "Invalid key",
+        ));
     }
     let ret = ret.unwrap();
     Ok((PyBytes::new(py, &ret.0), PyBytes::new(py, &ret.1)))

=== modified file 'crates/chk-map/src/lib.rs'
--- crates/chk-map/src/lib.rs	2023-04-06 18:50:17 +0000
+++ crates/chk-map/src/lib.rs	2023-04-17 11:56:43 +0000
@@ -25,15 +25,16 @@
         result.push(0x00);
     }
     result.pop();
-    result.iter().map(|b| if *b == 0x0A { b'_'} else { *b }).collect()
+    result
+        .iter()
+        .map(|b| if *b == 0x0A { b'_' } else { *b })
+        .collect()
 }
 
 pub fn bytes_to_text_key(data: &[u8]) -> Result<(&[u8], &[u8]), String> {
     let sections: Vec<&[u8]> = data.split(|&byte| byte == b'\n').collect();
 
-    let delimiter_position = sections[0]
-        .windows(2)
-        .position(|window| window == b": ");
+    let delimiter_position = sections[0].windows(2).position(|window| window == b": ");
 
     if delimiter_position.is_none() {
         return Err("Invalid key file".to_string());

=== modified file 'crates/dirstate-py/src/lib.rs'
--- crates/dirstate-py/src/lib.rs	2023-04-13 18:17:29 +0000
+++ crates/dirstate-py/src/lib.rs	2023-04-17 11:56:43 +0000
@@ -1,13 +1,13 @@
 #![allow(non_snake_case)]
 
+use pyo3::exceptions::PyTypeError;
 use pyo3::prelude::*;
+use pyo3::types::{PyBytes, PyDict, PyList, PyString, PyTuple};
 use pyo3::wrap_pyfunction;
-use std::path::{Path,PathBuf};
-use pyo3::types::{PyBytes, PyDict, PyList, PyTuple, PyString};
-use pyo3::exceptions::PyTypeError;
-use std::os::unix::fs::{PermissionsExt, MetadataExt};
 use std::ffi::OsString;
 use std::os::unix::ffi::OsStringExt;
+use std::os::unix::fs::{MetadataExt, PermissionsExt};
+use std::path::{Path, PathBuf};
 
 use bazaar_dirstate;
 
@@ -79,10 +79,18 @@
 #[pyfunction]
 fn bisect_path_left(paths: Vec<&PyAny>, path: &PyAny) -> PyResult<usize> {
     let path = extract_path(path)?;
-    let paths = paths.iter().map(|x| extract_path(x).unwrap()).collect::<Vec<PathBuf>>();
+    let paths = paths
+        .iter()
+        .map(|x| extract_path(x).unwrap())
+        .collect::<Vec<PathBuf>>();
     let offset = bazaar_dirstate::bisect_path_left(
-        paths.iter().map(|x| x.as_path()).collect::<Vec<&Path>>().as_slice(),
-        &path);
+        paths
+            .iter()
+            .map(|x| x.as_path())
+            .collect::<Vec<&Path>>()
+            .as_slice(),
+        &path,
+    );
     Ok(offset)
 }
 
@@ -107,10 +115,18 @@
 #[pyfunction]
 fn bisect_path_right(paths: Vec<&PyAny>, path: &PyAny) -> PyResult<usize> {
     let path = extract_path(path)?;
-    let paths = paths.iter().map(|x| extract_path(x).unwrap()).collect::<Vec<PathBuf>>();
+    let paths = paths
+        .iter()
+        .map(|x| extract_path(x).unwrap())
+        .collect::<Vec<PathBuf>>();
     let offset = bazaar_dirstate::bisect_path_right(
-        paths.iter().map(|x| x.as_path()).collect::<Vec<&Path>>().as_slice(),
-        &path);
+        paths
+            .iter()
+            .map(|x| x.as_path())
+            .collect::<Vec<&Path>>()
+            .as_slice(),
+        &path,
+    );
     Ok(offset)
 }
 
@@ -201,15 +217,25 @@
 
     #[getter]
     fn st_mtime(&self) -> PyResult<u64> {
-        let modified = self.metadata.modified().map_err(|e| PyErr::new::<pyo3::exceptions::PyOSError, _>(e))?;
-        let since_epoch = modified.duration_since(std::time::UNIX_EPOCH).map_err(|e| PyErr::new::<pyo3::exceptions::PyOSError, _>(e.to_string()))?;
+        let modified = self
+            .metadata
+            .modified()
+            .map_err(|e| PyErr::new::<pyo3::exceptions::PyOSError, _>(e))?;
+        let since_epoch = modified
+            .duration_since(std::time::UNIX_EPOCH)
+            .map_err(|e| PyErr::new::<pyo3::exceptions::PyOSError, _>(e.to_string()))?;
         Ok(since_epoch.as_secs())
     }
 
     #[getter]
     fn st_ctime(&self) -> PyResult<u64> {
-        let created = self.metadata.created().map_err(|e| PyErr::new::<pyo3::exceptions::PyOSError, _>(e))?;
-        let since_epoch = created.duration_since(std::time::UNIX_EPOCH).map_err(|e| PyErr::new::<pyo3::exceptions::PyOSError, _>(e.to_string()))?;
+        let created = self
+            .metadata
+            .created()
+            .map_err(|e| PyErr::new::<pyo3::exceptions::PyOSError, _>(e))?;
+        let since_epoch = created
+            .duration_since(std::time::UNIX_EPOCH)
+            .map_err(|e| PyErr::new::<pyo3::exceptions::PyOSError, _>(e.to_string()))?;
         Ok(since_epoch.as_secs())
     }
 
@@ -240,7 +266,10 @@
 impl SHA1Provider {
     fn sha1(&mut self, py: Python, path: &PyAny) -> PyResult<PyObject> {
         let path = extract_path(path)?;
-        let sha1 = self.provider.sha1(&path).map_err(|e| PyErr::new::<pyo3::exceptions::PyOSError, _>(e))?;
+        let sha1 = self
+            .provider
+            .sha1(&path)
+            .map_err(|e| PyErr::new::<pyo3::exceptions::PyOSError, _>(e))?;
         Ok(PyBytes::new(py, sha1.as_bytes()).to_object(py))
     }
 
@@ -248,7 +277,10 @@
         let path = extract_path(path)?;
         let (md, sha1) = self.provider.stat_and_sha1(&path)?;
         let pmd = StatResult { metadata: md };
-        Ok((pmd.into_py(py), PyBytes::new(py, sha1.as_bytes()).to_object(py)))
+        Ok((
+            pmd.into_py(py),
+            PyBytes::new(py, sha1.as_bytes()).to_object(py),
+        ))
     }
 }
 

=== modified file 'crates/dirstate/src/lib.rs'
--- crates/dirstate/src/lib.rs	2023-04-17 09:12:14 +0000
+++ crates/dirstate/src/lib.rs	2023-04-17 11:56:43 +0000
@@ -1,12 +1,12 @@
 use base64;
+use breezy_osutils::sha::{sha_file, sha_file_by_name};
 use std::cmp::Ordering;
-use std::path::Path;
-use breezy_osutils::sha::{sha_file_by_name,sha_file};
 use std::fs::File;
 use std::fs::Metadata;
 use std::os::unix::fs::MetadataExt;
+use std::path::Path;
 
-pub trait SHA1Provider : Send + Sync {
+pub trait SHA1Provider: Send + Sync {
     fn sha1(&self, path: &Path) -> std::io::Result<String>;
 
     fn stat_and_sha1(&self, path: &Path) -> std::io::Result<(Metadata, String)>;
@@ -47,13 +47,11 @@
             (None, None) => return false,
             (None, Some(_)) => return true,
             (Some(_), None) => return false,
-            (Some(part1), Some(part2)) => {
-                match part1.cmp(&part2) {
-                    Ordering::Equal => continue,
-                    Ordering::Less => return true,
-                    Ordering::Greater => return false,
-                }
-            }
+            (Some(part1), Some(part2)) => match part1.cmp(&part2) {
+                Ordering::Equal => continue,
+                Ordering::Less => return true,
+                Ordering::Greater => return false,
+            },
         }
     }
 }
@@ -100,11 +98,21 @@
 pub fn pack_stat_metadata(metadata: &Metadata) -> String {
     pack_stat(
         metadata.len(),
-        metadata.modified().unwrap().duration_since(std::time::UNIX_EPOCH).unwrap().as_secs(),
-        metadata.created().unwrap().duration_since(std::time::UNIX_EPOCH).unwrap().as_secs(),
+        metadata
+            .modified()
+            .unwrap()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_secs(),
+        metadata
+            .created()
+            .unwrap()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_secs(),
         metadata.dev(),
         metadata.ino(),
-        metadata.mode()
+        metadata.mode(),
     )
 }
 

=== modified file 'crates/graph-py/src/lib.rs'
--- crates/graph-py/src/lib.rs	2023-04-17 09:32:41 +0000
+++ crates/graph-py/src/lib.rs	2023-04-17 11:56:43 +0000
@@ -1,12 +1,12 @@
 #![allow(non_snake_case)]
 
+use breezy_graph::RevnoVec;
 use pyo3::import_exception;
 use pyo3::prelude::*;
-use pyo3::types::{PyDict, PyList, PyTuple};
+use pyo3::types::{PyDict, PyIterator, PyList, PyTuple};
 use pyo3::wrap_pyfunction;
 use std::collections::{HashMap, HashSet};
 use std::hash::Hash;
-use breezy_graph::RevnoVec;
 
 import_exception!(breezy.errors, GraphCycleError);
 
@@ -342,20 +342,20 @@
     fn __next__(&mut self, py: Python) -> PyResult<Option<PyObject>> {
         match self.sorter.next() {
             None => Ok(None),
-            Some(Ok((sequence_number, node, merge_depth, None, end_of_merge))) => Ok(Some((
-                sequence_number,
-                node.into_py(py),
-                merge_depth,
-                end_of_merge,
-            ).into_py(py))),
+            Some(Ok((sequence_number, node, merge_depth, None, end_of_merge))) => Ok(Some(
+                (sequence_number, node.into_py(py), merge_depth, end_of_merge).into_py(py),
+            )),
 
-            Some(Ok((sequence_number, node, merge_depth, Some(revno), end_of_merge))) => Ok(Some((
-                sequence_number,
-                node.into_py(py),
-                merge_depth,
-                revno_vec_to_py(py, revno),
-                end_of_merge,
-            ).into_py(py))),
+            Some(Ok((sequence_number, node, merge_depth, Some(revno), end_of_merge))) => Ok(Some(
+                (
+                    sequence_number,
+                    node.into_py(py),
+                    merge_depth,
+                    revno_vec_to_py(py, revno),
+                    end_of_merge,
+                )
+                    .into_py(py),
+            )),
             Some(Err(breezy_graph::tsort::Error::Cycle(e))) => Err(GraphCycleError::new_err(e)),
         }
     }

=== modified file 'crates/graph/src/tsort.rs'
--- crates/graph/src/tsort.rs	2023-04-17 10:49:20 +0000
+++ crates/graph/src/tsort.rs	2023-04-17 11:56:43 +0000
@@ -57,7 +57,9 @@
     ///
     /// After finishing iteration the sorter is empty and you cannot continue
     /// iteration.
-    pub fn iter_topo_order(&mut self) -> impl Iterator<Item = std::result::Result<K, Error<K>>> + '_ {
+    pub fn iter_topo_order(
+        &mut self,
+    ) -> impl Iterator<Item = std::result::Result<K, Error<K>>> + '_ {
         self
     }
 }
@@ -371,7 +373,9 @@
     /// Sort the graph and return as a list.
     ///
     /// After calling this the sorter is empty and you must create a new one.
-    pub fn sorted(&mut self) -> std::result::Result<Vec<(usize, K, usize, Option<RevnoVec>, bool)>, Error<K>> {
+    pub fn sorted(
+        &mut self,
+    ) -> std::result::Result<Vec<(usize, K, usize, Option<RevnoVec>, bool)>, Error<K>> {
         self.iter_topo_order().collect()
     }
 
@@ -380,7 +384,8 @@
     /// iteration.
     pub fn iter_topo_order(
         &mut self,
-    ) -> impl Iterator<Item = std::result::Result<(usize, K, usize, Option<RevnoVec>, bool), Error<K>>> + '_ {
+    ) -> impl Iterator<Item = std::result::Result<(usize, K, usize, Option<RevnoVec>, bool), Error<K>>>
+           + '_ {
         self
     }
 
@@ -484,7 +489,12 @@
                         *self.left_subtree_pushed_stack.last_mut().unwrap() = true;
                         // recurse depth first into the primary parent
                     } else {
-                        next_node_name = self.pending_parents_stack.last_mut().unwrap().pop().unwrap();
+                        next_node_name = self
+                            .pending_parents_stack
+                            .last_mut()
+                            .unwrap()
+                            .pop()
+                            .unwrap();
                         is_left_subtree = false;
                         // place any merges in right-to-left order for scheduling
                         // which gives us left-to-right order after we reverse
@@ -537,7 +547,9 @@
 
 impl<K: Eq + Hash + std::fmt::Debug + Clone> Iterator for MergeSorter<K> {
     type Item = std::result::Result<(usize, K, usize, Option<RevnoVec>, bool), Error<K>>;
-    fn next(&mut self) -> Option<std::result::Result<(usize, K, usize, Option<RevnoVec>, bool), Error<K>>> {
+    fn next(
+        &mut self,
+    ) -> Option<std::result::Result<(usize, K, usize, Option<RevnoVec>, bool), Error<K>>> {
         if let Err(err) = self.build() {
             return Some(Err(err));
         }

=== modified file 'crates/groupcompress-py/src/lib.rs'
--- crates/groupcompress-py/src/lib.rs	2023-04-05 19:55:41 +0000
+++ crates/groupcompress-py/src/lib.rs	2023-04-17 11:56:43 +0000
@@ -1,6 +1,6 @@
 use pyo3::prelude::*;
+use pyo3::types::PyBytes;
 use pyo3::wrap_pyfunction;
-use pyo3::types::PyBytes;
 
 use bazaar_groupcompress;
 
@@ -19,7 +19,9 @@
 fn apply_delta(py: Python, basis: Vec<u8>, delta: Vec<u8>) -> PyResult<&PyBytes> {
     let ret = bazaar_groupcompress::apply_delta(&basis, &delta);
     if ret.is_err() {
-        return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>("Invalid delta"));
+        return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(
+            "Invalid delta",
+        ));
     }
     Ok(PyBytes::new(py, &ret.unwrap()))
 }
@@ -28,7 +30,9 @@
 fn decode_copy_instruction(data: Vec<u8>, cmd: u8, pos: usize) -> PyResult<(usize, usize, usize)> {
     let ret = bazaar_groupcompress::decode_copy_instruction(&data, cmd, pos);
     if ret.is_err() {
-        return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>("Invalid copy instruction"));
+        return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(
+            "Invalid copy instruction",
+        ));
     }
     let ret = ret.unwrap();
 
@@ -36,10 +40,17 @@
 }
 
 #[pyfunction]
-fn apply_delta_to_source(py: Python, source: &[u8], delta_start: usize, delta_end: usize) -> PyResult<PyObject> {
+fn apply_delta_to_source(
+    py: Python,
+    source: &[u8],
+    delta_start: usize,
+    delta_end: usize,
+) -> PyResult<PyObject> {
     let ret = bazaar_groupcompress::apply_delta_to_source(source, delta_start, delta_end);
     if ret.is_err() {
-        return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>("Invalid delta"));
+        return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(
+            "Invalid delta",
+        ));
     }
     let ret = ret.unwrap();
     Ok(PyBytes::new(py, &ret).to_object(py))

=== modified file 'crates/groupcompress/src/lib.rs'
--- crates/groupcompress/src/lib.rs	2023-04-05 19:55:41 +0000
+++ crates/groupcompress/src/lib.rs	2023-04-17 11:56:43 +0000
@@ -26,7 +26,11 @@
 
 pub type CopyInstruction = (usize, usize, usize);
 
-pub fn decode_copy_instruction(data: &[u8], cmd: u8, pos: usize) -> Result<CopyInstruction, String> {
+pub fn decode_copy_instruction(
+    data: &[u8],
+    cmd: u8,
+    pos: usize,
+) -> Result<CopyInstruction, String> {
     if cmd & 0x80 != 0x80 {
         return Err("copy instructions must have bit 0x80 set".to_string());
     }
@@ -106,7 +110,11 @@
     Ok(lines)
 }
 
-pub fn apply_delta_to_source(source: &[u8], delta_start: usize, delta_end: usize) -> Result<Vec<u8>, String> {
+pub fn apply_delta_to_source(
+    source: &[u8],
+    delta_start: usize,
+    delta_end: usize,
+) -> Result<Vec<u8>, String> {
     let source_size = source.len();
     if delta_start >= source_size {
         return Err("delta starts after source".to_string());

=== modified file 'crates/hashcache-py/src/lib.rs'
--- crates/hashcache-py/src/lib.rs	2023-04-13 17:29:19 +0000
+++ crates/hashcache-py/src/lib.rs	2023-04-17 11:56:43 +0000
@@ -1,10 +1,10 @@
+use bazaar::filters::ContentFilter;
 use pyo3::prelude::*;
+use pyo3::types::PyBytes;
 use std::fs::Permissions;
+use std::io::Error;
 use std::os::unix::fs::PermissionsExt;
-use std::io::Error;
 use std::path::Path;
-use pyo3::types::PyBytes;
-use bazaar::filters::ContentFilter;
 
 #[pyclass]
 struct HashCache {
@@ -43,7 +43,7 @@
     fn _impl(
         &self,
         input: Box<dyn Iterator<Item = Result<Vec<u8>, Error>> + Send>,
-        worker: &str
+        worker: &str,
     ) -> Box<dyn Iterator<Item = Result<Vec<u8>, Error>> + Send> {
         Python::with_gil(|py| {
             let worker = self.content_filter.getattr(py, worker);
@@ -73,7 +73,6 @@
     }
 }
 
-
 impl ContentFilter for PyContentFilter {
     fn reader(
         &self,
@@ -90,11 +89,18 @@
     }
 }
 
-fn content_filter_to_fn(content_filter_provider: PyObject) -> Box<dyn Fn(&Path, u64) -> Box<dyn ContentFilter> + Send> {
+fn content_filter_to_fn(
+    content_filter_provider: PyObject,
+) -> Box<dyn Fn(&Path, u64) -> Box<dyn ContentFilter> + Send> {
     Box::new(move |path, ctime| {
         Python::with_gil(|py| {
             let content_filter_provider = content_filter_provider.to_object(py);
-            Box::new(PyContentFilter { content_filter: content_filter_provider.call1(py, (path, ctime)).unwrap().to_object(py) })
+            Box::new(PyContentFilter {
+                content_filter: content_filter_provider
+                    .call1(py, (path, ctime))
+                    .unwrap()
+                    .to_object(py),
+            })
         })
     })
 }
@@ -105,16 +111,28 @@
     } else if let Ok(val) = obj.extract::<f64>() {
         Ok(val as i64)
     } else {
-        Err(PyErr::new::<pyo3::exceptions::PyTypeError, _>("Expected int or float"))
+        Err(PyErr::new::<pyo3::exceptions::PyTypeError, _>(
+            "Expected int or float",
+        ))
     }
 }
 
 #[pymethods]
 impl HashCache {
     #[new]
-    fn new(root: &str, cache_file_name: &str, mode: Option<u32>, content_filter_provider: Option<PyObject>) -> Self {
+    fn new(
+        root: &str,
+        cache_file_name: &str,
+        mode: Option<u32>,
+        content_filter_provider: Option<PyObject>,
+    ) -> Self {
         Self {
-            hashcache: Box::new(bazaar_hashcache::HashCache::new(Path::new(root), Path::new(cache_file_name), mode.map(Permissions::from_mode), content_filter_provider.map(content_filter_to_fn)))
+            hashcache: Box::new(bazaar_hashcache::HashCache::new(
+                Path::new(root),
+                Path::new(cache_file_name),
+                mode.map(Permissions::from_mode),
+                content_filter_provider.map(content_filter_to_fn),
+            )),
         }
     }
 
@@ -130,7 +148,12 @@
         self.hashcache.scan();
     }
 
-    fn get_sha1(&mut self, py: Python, path: &str, stat_value: Option<&PyAny>) -> PyResult<PyObject> {
+    fn get_sha1(
+        &mut self,
+        py: Python,
+        path: &str,
+        stat_value: Option<&PyAny>,
+    ) -> PyResult<PyObject> {
         let sha1;
         if let Some(stat_value) = stat_value {
             let fp = bazaar_hashcache::Fingerprint {
@@ -141,7 +164,9 @@
                 dev: stat_value.getattr("st_dev")?.extract()?,
                 mode: stat_value.getattr("st_mode")?.extract()?,
             };
-            sha1 = self.hashcache.get_sha1_by_fingerprint(Path::new(path), &fp)?;
+            sha1 = self
+                .hashcache
+                .get_sha1_by_fingerprint(Path::new(path), &fp)?;
         } else {
             let ret = self.hashcache.get_sha1(Path::new(path), None)?;
             if let Some(s) = ret {

=== modified file 'crates/hashcache/src/lib.rs'
--- crates/hashcache/src/lib.rs	2023-04-12 23:51:31 +0000
+++ crates/hashcache/src/lib.rs	2023-04-17 11:56:43 +0000
@@ -1,15 +1,15 @@
+use bazaar::filters::{ContentFilter, ContentFilterProvider, ContentFilterStack};
+use breezy_osutils::sha::sha_string;
+use log::{debug, info};
+use std::collections::HashMap;
+use std::fs;
+use std::fs::{File, Metadata, Permissions};
+use std::io;
 use std::io::prelude::*;
+use std::io::BufReader;
 use std::os::unix::fs::MetadataExt;
-use std::path::{Path,PathBuf};
+use std::path::{Path, PathBuf};
 use std::time::{SystemTime, UNIX_EPOCH};
-use std::io;
-use std::io::{BufReader};
-use std::fs;
-use std::fs::{File,Metadata,Permissions};
-use std::collections::HashMap;
-use log::{debug, info};
-use breezy_osutils::sha::sha_string;
-use bazaar::filters::{ContentFilterStack, ContentFilter, ContentFilterProvider};
 use tempfile::NamedTempFile;
 
 /// TODO: Up-front, stat all files in order and remove those which are deleted or
@@ -56,7 +56,7 @@
 /// miss_count
 ///     number of misses (times files have been completely re-read)
 
-#[derive(Debug,PartialEq,Default,Clone)]
+#[derive(Debug, PartialEq, Default, Clone)]
 pub struct Fingerprint {
     pub size: u64,
     pub mtime: i64,
@@ -66,15 +66,15 @@
     pub mode: u32,
 }
 
-impl From <Metadata> for Fingerprint {
-    fn from (meta: Metadata) -> Fingerprint {
+impl From<Metadata> for Fingerprint {
+    fn from(meta: Metadata) -> Fingerprint {
         Fingerprint {
             size: meta.size(),
             mtime: meta.mtime(),
             ctime: meta.ctime(),
             ino: meta.ino(),
             dev: meta.dev(),
-            mode: meta.mode()
+            mode: meta.mode(),
         }
     }
 }
@@ -109,8 +109,7 @@
         root: &Path,
         cache_file_name: &Path,
         permissions: Option<Permissions>,
-        content_filter_provider: Option<Box<ContentFilterProvider>,
-        >,
+        content_filter_provider: Option<Box<ContentFilterProvider>>,
     ) -> Self {
         HashCache {
             root: root.to_path_buf(),
@@ -161,7 +160,11 @@
     /// since the entry was inserted.
     pub fn scan(&mut self) {
         let mut keys_to_remove = Vec::new();
-        let mut by_inode = self.cache.iter().map(|(k, v)| (v.1.ino, k, v)).collect::<Vec<_>>();
+        let mut by_inode = self
+            .cache
+            .iter()
+            .map(|(k, v)| (v.1.ino, k, v))
+            .collect::<Vec<_>>();
         by_inode.sort_by_key(|x| x.0);
         for (_inode, path, cache_val) in by_inode {
             let abspath = self.root.join(path);
@@ -183,10 +186,15 @@
     pub fn get_sha1_by_fingerprint(
         &mut self,
         path: &Path,
-        file_fp: &Fingerprint) -> io::Result<String> {
+        file_fp: &Fingerprint,
+    ) -> io::Result<String> {
         let abspath = self.root.join(path);
 
-        let (cache_sha1, cache_fp) = self.cache.get(path).cloned().unwrap_or((Default::default(), Default::default()));
+        let (cache_sha1, cache_fp) = self
+            .cache
+            .get(path)
+            .cloned()
+            .unwrap_or((Default::default(), Default::default()));
 
         if cache_fp == *file_fp {
             self.hit_count += 1;
@@ -196,11 +204,12 @@
 
             match file_fp.mode & libc::S_IFMT {
                 libc::S_IFREG => {
-                    let filters: Box<dyn ContentFilter> = if let Some(filter_provider) = self.filter_provider.as_ref() {
-                        filter_provider(path, file_fp.ctime as u64)
-                    } else {
-                        Box::new(ContentFilterStack::new())
-                    };
+                    let filters: Box<dyn ContentFilter> =
+                        if let Some(filter_provider) = self.filter_provider.as_ref() {
+                            filter_provider(path, file_fp.ctime as u64)
+                        } else {
+                            Box::new(ContentFilterStack::new())
+                        };
                     let digest = filters.sha1_file(&abspath)?;
 
                     // window of 3 seconds to allow for 2s resolution on windows,
@@ -226,7 +235,8 @@
                     } else {
                         self.update_count += 1;
                         self.needs_write = true;
-                        self.cache.insert(path.to_owned(), (digest.clone(), file_fp.clone()));
+                        self.cache
+                            .insert(path.to_owned(), (digest.clone(), file_fp.clone()));
                     }
 
                     Ok(digest)
@@ -234,17 +244,16 @@
                 libc::S_IFLNK => {
                     let target = fs::read_link(&abspath)?;
                     let digest = sha_string(target.to_string_lossy().as_bytes());
-                    self.cache.insert(path.to_owned(), (digest.clone(), file_fp.clone()));
+                    self.cache
+                        .insert(path.to_owned(), (digest.clone(), file_fp.clone()));
                     self.update_count += 1;
                     self.needs_write = true;
                     Ok(digest)
                 }
-                _ => {
-                    Err(io::Error::new(
-                        io::ErrorKind::InvalidData,
-                        format!("unknown file stat mode: {:o}", file_fp.mode),
-                    ))
-                }
+                _ => Err(io::Error::new(
+                    io::ErrorKind::InvalidData,
+                    format!("unknown file stat mode: {:o}", file_fp.mode),
+                )),
             }
         }
     }
@@ -296,9 +305,15 @@
         }
         outf.persist(self.cache_file_name())?;
         self.needs_write = false;
-        debug!("write hash cache: {} hits={} misses={} stat={} recent={} updates={}",
-               self.cache_file_name().display(), self.hit_count, self.miss_count,
-               self.stat_count, self.danger_count, self.update_count);
+        debug!(
+            "write hash cache: {} hits={} misses={} stat={} recent={} updates={}",
+            self.cache_file_name().display(),
+            self.hit_count,
+            self.miss_count,
+            self.stat_count,
+            self.danger_count,
+            self.update_count
+        );
         Ok(())
     }
 
@@ -312,7 +327,11 @@
         self.cache = HashMap::new();
         let file = File::open(self.cache_file_name());
         if file.is_err() {
-            debug!("failed to open {}: {}", self.cache_file_name().display(), file.err().unwrap());
+            debug!(
+                "failed to open {}: {}",
+                self.cache_file_name().display(),
+                file.err().unwrap()
+            );
             self.needs_write = true;
             return Ok(());
         }
@@ -324,14 +343,18 @@
                 self.needs_write = true;
                 return Err(std::io::Error::new(
                     std::io::ErrorKind::InvalidData,
-                    format!("cache header marker not found at top of {}; discarding cache", self.cache_file_name().display()),
+                    format!(
+                        "cache header marker not found at top of {}; discarding cache",
+                        self.cache_file_name().display()
+                    ),
                 ));
             }
         } else {
             self.needs_write = true;
             return Err(std::io::Error::new(
                 std::io::ErrorKind::InvalidData,
-                format!("error reading cache file header", )));
+                format!("error reading cache file header",),
+            ));
         }
         for line in lines {
             let line = line?;

=== modified file 'crates/osutils-py/src/lib.rs'
--- crates/osutils-py/src/lib.rs	2023-04-16 11:47:42 +0000
+++ crates/osutils-py/src/lib.rs	2023-04-17 11:56:43 +0000
@@ -1,21 +1,25 @@
 #![allow(non_snake_case)]
+use memchr;
+use pyo3::create_exception;
+use pyo3::exceptions::{PyIOError, PyTypeError, PyValueError};
 use pyo3::prelude::*;
+use pyo3::types::{PyBytes, PyIterator, PyList};
 use pyo3::wrap_pyfunction;
-use std::path::{Path,PathBuf};
+use pyo3::PyErr;
 use pyo3_file::PyFileLikeObject;
-use pyo3::types::{PyBytes, PyIterator, PyList};
-use pyo3::exceptions::{PyTypeError,PyValueError,PyIOError};
 use std::collections::HashSet;
+use std::ffi::OsString;
+use std::fs::Permissions;
+use std::io::{BufRead, Read};
 use std::iter::Iterator;
-use std::ffi::OsString;
-use std::io::{Read, BufRead};
 use std::os::unix::ffi::OsStringExt;
-use memchr;
-use pyo3::PyErr;
-use pyo3::create_exception;
-use std::fs::Permissions;
+use std::path::{Path, PathBuf};
 
-create_exception!(breezy_osutils, UnsupportedTimezoneFormat, pyo3::exceptions::PyException);
+create_exception!(
+    breezy_osutils,
+    UnsupportedTimezoneFormat,
+    pyo3::exceptions::PyException
+);
 
 #[pyclass]
 struct PyChunksToLinesIterator {
@@ -27,7 +31,10 @@
 impl PyChunksToLinesIterator {
     #[new]
     fn new(chunk_iter: PyObject) -> PyResult<Self> {
-        Ok(PyChunksToLinesIterator { chunk_iter, tail: None })
+        Ok(PyChunksToLinesIterator {
+            chunk_iter,
+            tail: None,
+        })
     }
 
     fn __iter__(slf: PyRef<Self>) -> Py<Self> {
@@ -35,56 +42,53 @@
     }
 
     fn __next__(&mut self) -> PyResult<Option<Py<PyAny>>> {
-        Python::with_gil(move |py| {
-
-            loop {
-                if let Some(mut chunk) = self.tail.take() {
-                    if let Some(newline) = memchr::memchr(b'\n', &chunk) {
-                        if newline == chunk.len() - 1 {
-                            assert!(!chunk.is_empty());
-                            return Ok(Some(PyBytes::new(py, chunk.as_slice()).to_object(py)));
-                        } else {
-                            assert!(!chunk.is_empty());
-                            self.tail = Some(chunk[newline + 1..].to_vec());
-                            let bytes = PyBytes::new(py, &chunk[..=newline]);
-                            return Ok(Some(bytes.to_object(py)));
-                        }
+        Python::with_gil(move |py| loop {
+            if let Some(mut chunk) = self.tail.take() {
+                if let Some(newline) = memchr::memchr(b'\n', &chunk) {
+                    if newline == chunk.len() - 1 {
+                        assert!(!chunk.is_empty());
+                        return Ok(Some(PyBytes::new(py, chunk.as_slice()).to_object(py)));
                     } else {
-                        if let Some(next_chunk) = self.chunk_iter.downcast::<PyIterator>(py)?.next() {
-                            if let Err(e) = next_chunk {
-                                return Err(e);
-                            }
-                            let next_chunk = next_chunk.unwrap();
-                            let next_chunk = next_chunk.extract::<&[u8]>()?;
-                            chunk.extend_from_slice(next_chunk);
-                        } else {
-                            assert!(!chunk.is_empty());
-                            return Ok(Some(PyBytes::new(py, &chunk).to_object(py)));
-                        }
-                        if !chunk.is_empty() {
-                            self.tail = Some(chunk);
-                        }
+                        assert!(!chunk.is_empty());
+                        self.tail = Some(chunk[newline + 1..].to_vec());
+                        let bytes = PyBytes::new(py, &chunk[..=newline]);
+                        return Ok(Some(bytes.to_object(py)));
                     }
                 } else {
                     if let Some(next_chunk) = self.chunk_iter.downcast::<PyIterator>(py)?.next() {
                         if let Err(e) = next_chunk {
                             return Err(e);
                         }
-                        let next_chunk_py = next_chunk.unwrap();
-                        let next_chunk = next_chunk_py.extract::<&[u8]>()?;
-                        if let Some(newline) = memchr::memchr(b'\n', &next_chunk) {
-                            if newline == next_chunk.len() - 1 {
-                                let line = next_chunk_py.downcast::<PyBytes>()?;
-                                return Ok(Some(line.to_object(py)));
-                            }
-                        }
-
-                        if !next_chunk.is_empty() {
-                            self.tail = Some(next_chunk.to_vec());
-                        }
+                        let next_chunk = next_chunk.unwrap();
+                        let next_chunk = next_chunk.extract::<&[u8]>()?;
+                        chunk.extend_from_slice(next_chunk);
                     } else {
-                        return Ok(None);
-                    }
+                        assert!(!chunk.is_empty());
+                        return Ok(Some(PyBytes::new(py, &chunk).to_object(py)));
+                    }
+                    if !chunk.is_empty() {
+                        self.tail = Some(chunk);
+                    }
+                }
+            } else {
+                if let Some(next_chunk) = self.chunk_iter.downcast::<PyIterator>(py)?.next() {
+                    if let Err(e) = next_chunk {
+                        return Err(e);
+                    }
+                    let next_chunk_py = next_chunk.unwrap();
+                    let next_chunk = next_chunk_py.extract::<&[u8]>()?;
+                    if let Some(newline) = memchr::memchr(b'\n', &next_chunk) {
+                        if newline == next_chunk.len() - 1 {
+                            let line = next_chunk_py.downcast::<PyBytes>()?;
+                            return Ok(Some(line.to_object(py)));
+                        }
+                    }
+
+                    if !next_chunk.is_empty() {
+                        self.tail = Some(next_chunk.to_vec());
+                    }
+                } else {
+                    return Ok(None);
                 }
             }
         })
@@ -155,7 +159,8 @@
 #[pyfunction]
 fn sha_strings(py: Python, strings: &PyAny) -> PyResult<PyObject> {
     let iter = strings.iter()?;
-    let digest = breezy_osutils::sha::sha_chunks(iter.map(|x| x.unwrap().extract::<Vec<u8>>().unwrap()));
+    let digest =
+        breezy_osutils::sha::sha_chunks(iter.map(|x| x.unwrap().extract::<Vec<u8>>().unwrap()));
     Ok(PyBytes::new(py, digest.as_bytes()).into_py(py))
 }
 
@@ -192,7 +197,9 @@
 #[pyfunction]
 fn _inaccessible_normalized_filename(filename: &PyAny) -> PyResult<(PathBuf, bool)> {
     let filename = extract_path(&filename)?;
-    if let Some(filename) = breezy_osutils::path::inaccessible_normalized_filename(filename.as_path()) {
+    if let Some(filename) =
+        breezy_osutils::path::inaccessible_normalized_filename(filename.as_path())
+    {
         Ok(filename)
     } else {
         Ok((filename, true))
@@ -201,8 +208,9 @@
 
 #[pyfunction]
 fn _accessible_normalized_filename(filename: &PyAny) -> PyResult<(PathBuf, bool)> {
-    let filename= extract_path(&filename)?;
-    if let Some(filename) = breezy_osutils::path::accessible_normalized_filename(filename.as_path()) {
+    let filename = extract_path(&filename)?;
+    if let Some(filename) = breezy_osutils::path::accessible_normalized_filename(filename.as_path())
+    {
         Ok(filename)
     } else {
         Ok((filename, false))
@@ -218,7 +226,10 @@
 fn is_inside(path: &PyAny, parent: &PyAny) -> PyResult<bool> {
     let path = extract_path(path)?;
     let parent = extract_path(parent)?;
-    Ok(breezy_osutils::path::is_inside(path.as_path(), parent.as_path()))
+    Ok(breezy_osutils::path::is_inside(
+        path.as_path(),
+        parent.as_path(),
+    ))
 }
 
 #[pyfunction]
@@ -228,7 +239,13 @@
     for dir in dir_list.iter()? {
         c_dir_list.push(extract_path(dir?)?);
     }
-    Ok(breezy_osutils::path::is_inside_any(&c_dir_list.iter().map(|p| p.as_path()).collect::<Vec<&Path>>(), path.as_path()))
+    Ok(breezy_osutils::path::is_inside_any(
+        &c_dir_list
+            .iter()
+            .map(|p| p.as_path())
+            .collect::<Vec<&Path>>(),
+        path.as_path(),
+    ))
 }
 
 #[pyfunction]
@@ -238,7 +255,13 @@
     for dir in dir_list.iter()? {
         c_dir_list.push(extract_path(dir?)?);
     }
-    Ok(breezy_osutils::path::is_inside_or_parent_of_any(&c_dir_list.iter().map(|p| p.as_path()).collect::<Vec<&Path>>(), path.as_path()))
+    Ok(breezy_osutils::path::is_inside_or_parent_of_any(
+        &c_dir_list
+            .iter()
+            .map(|p| p.as_path())
+            .collect::<Vec<&Path>>(),
+        path.as_path(),
+    ))
 }
 
 #[pyfunction]
@@ -247,8 +270,16 @@
     for path in paths.iter()? {
         path_set.insert(extract_path(path?)?);
     }
-    let paths = breezy_osutils::path::minimum_path_selection(path_set.iter().map(|p| p.as_path()).collect::<HashSet<&Path>>());
-    Ok(paths.iter().map(|x| x.to_string_lossy().to_string()).collect())
+    let paths = breezy_osutils::path::minimum_path_selection(
+        path_set
+            .iter()
+            .map(|p| p.as_path())
+            .collect::<HashSet<&Path>>(),
+    );
+    Ok(paths
+        .iter()
+        .map(|x| x.to_string_lossy().to_string())
+        .collect())
 }
 
 #[pyfunction]
@@ -282,7 +313,7 @@
 fn available_backup_name(py: Python, path: &PyAny, exists: PyObject) -> PyResult<PathBuf> {
     let path = extract_path(path)?;
     let exists = |p: &Path| -> PyResult<bool> {
-        let ret = exists.call1(py, (p, ))?;
+        let ret = exists.call1(py, (p,))?;
         ret.extract::<bool>(py)
     };
 
@@ -311,7 +342,14 @@
 }
 
 #[pyfunction]
-fn format_local_date(py: Python, t: PyObject, offset: Option<i32>, timezone: Option<&str>, date_format: Option<&str>, show_offset: Option<bool>) -> PyResult<String> {
+fn format_local_date(
+    py: Python,
+    t: PyObject,
+    offset: Option<i32>,
+    timezone: Option<&str>,
+    date_format: Option<&str>,
+    show_offset: Option<bool>,
+) -> PyResult<String> {
     let t = if let Ok(t) = t.extract::<f64>(py) {
         t as i64
     } else if let Ok(t) = t.extract::<i64>(py) {
@@ -324,7 +362,13 @@
         return Err(UnsupportedTimezoneFormat::new_err("Unsupported timezone"));
     }
     let timezone = timezone.unwrap();
-    Ok(breezy_osutils::time::format_local_date(t, offset, timezone, date_format, show_offset.unwrap_or(true)))
+    Ok(breezy_osutils::time::format_local_date(
+        t,
+        offset,
+        timezone,
+        date_format,
+        show_offset.unwrap_or(true),
+    ))
 }
 
 #[pyfunction]
@@ -334,18 +378,25 @@
 
 #[pyclass]
 struct PyIterableFile {
-    inner: breezy_osutils::iterablefile::IterableFile<Box<dyn Iterator<Item=std::io::Result<Vec<u8>>> + Send>>,
+    inner: breezy_osutils::iterablefile::IterableFile<
+        Box<dyn Iterator<Item = std::io::Result<Vec<u8>>> + Send>,
+    >,
     closed: bool,
 }
 
 #[pymethods]
 impl PyIterableFile {
-
     fn __enter__(slf: PyRef<Self>) -> Py<Self> {
         slf.into()
     }
 
-    fn __exit__(&mut self, _py: Python, _exc_type: &PyAny, _exc_value: &PyAny, _traceback: &PyAny) -> PyResult<bool> {
+    fn __exit__(
+        &mut self,
+        _py: Python,
+        _exc_type: &PyAny,
+        _exc_value: &PyAny,
+        _traceback: &PyAny,
+    ) -> PyResult<bool> {
         self.check_closed(_py)?;
         Ok(false)
     }
@@ -368,7 +419,9 @@
         } else {
             self.inner.read_to_end(&mut buf)
         };
-        if PyErr::occurred(py) { return Err(PyErr::fetch(py)); }
+        if PyErr::occurred(py) {
+            return Err(PyErr::fetch(py));
+        }
         buf.truncate(read?);
         Ok(PyBytes::new(py, &buf).to_object(py))
     }
@@ -399,7 +452,9 @@
         self.check_closed(py)?;
         let mut buf = Vec::new();
         let read = self.inner.read_until(b'\n', &mut buf);
-        if PyErr::occurred(py) { return Err(PyErr::fetch(py)); }
+        if PyErr::occurred(py) {
+            return Err(PyErr::fetch(py));
+        }
         let read = read?;
         if read == 0 {
             return Ok(None);
@@ -413,27 +468,43 @@
 fn IterableFile(py_iterable: PyObject) -> PyResult<PyObject> {
     Python::with_gil(|py| {
         let py_iter = py_iterable.call_method0(py, "__iter__")?;
-        let line_iter: Box<dyn Iterator<Item = std::io::Result<Vec<u8>>> + Send> = Box::new(std::iter::from_fn(move || -> Option<std::io::Result<Vec<u8>>> {
-            Python::with_gil(|py| {
-                match py_iter.downcast::<PyIterator>(py).unwrap().next() {
-                    None => None,
-                    Some(Err(err)) => {
-                        PyErr::restore(err.clone_ref(py), py);
-                        Some(Err(std::io::Error::new(std::io::ErrorKind::Other, err.to_string())))
+        let line_iter: Box<dyn Iterator<Item = std::io::Result<Vec<u8>>> + Send> = Box::new(
+            std::iter::from_fn(move || -> Option<std::io::Result<Vec<u8>>> {
+                Python::with_gil(
+                    |py| match py_iter.downcast::<PyIterator>(py).unwrap().next() {
+                        None => None,
+                        Some(Err(err)) => {
+                            PyErr::restore(err.clone_ref(py), py);
+                            Some(Err(std::io::Error::new(
+                                std::io::ErrorKind::Other,
+                                err.to_string(),
+                            )))
+                        }
+                        Some(Ok(obj)) => match obj.downcast::<PyBytes>() {
+                            Err(err) => {
+                                PyErr::restore(
+                                    PyTypeError::new_err("unable to convert to bytes"),
+                                    py,
+                                );
+                                Some(Err(std::io::Error::new(
+                                    std::io::ErrorKind::Other,
+                                    err.to_string(),
+                                )))
+                            }
+                            Ok(bytes) => Some(Ok(bytes.as_bytes().to_vec().into())),
+                        },
                     },
-                    Some(Ok(obj)) => {
-                        match obj.downcast::<PyBytes>() {
-                            Err(err) => { PyErr::restore(PyTypeError::new_err("unable to convert to bytes"), py); Some(Err(std::io::Error::new(std::io::ErrorKind::Other, err.to_string()))) },
-                            Ok(bytes) => Some(Ok(bytes.as_bytes().to_vec().into())),
-                        }
-                    }
-                }
-            })
-        }));
+                )
+            }),
+        );
 
         let f = breezy_osutils::iterablefile::IterableFile::new(line_iter);
 
-        Ok(PyIterableFile { inner: f, closed: false }.into_py(py))
+        Ok(PyIterableFile {
+            inner: f,
+            closed: false,
+        }
+        .into_py(py))
     })
 }
 
@@ -450,7 +521,10 @@
         let line = py_iter.next();
         match line {
             Some(Ok(line)) => Some(line.extract::<Vec<u8>>().unwrap()),
-            Some(Err(err)) => { PyErr::restore(err, py); None }
+            Some(Err(err)) => {
+                PyErr::restore(err, py);
+                None
+            }
             None => None,
         }
     });
@@ -475,7 +549,11 @@
 }
 
 #[pyfunction]
-fn format_date_with_offset_in_original_timezone(py: Python, date: PyObject, offset: Option<PyObject>) -> PyResult<String> {
+fn format_date_with_offset_in_original_timezone(
+    py: Python,
+    date: PyObject,
+    offset: Option<PyObject>,
+) -> PyResult<String> {
     let date = if let Ok(date) = date.extract::<f64>(py) {
         date as i64
     } else if let Ok(date) = date.extract::<i64>(py) {
@@ -498,7 +576,14 @@
 }
 
 #[pyfunction]
-fn format_date(py: Python, t: PyObject, offset: Option<PyObject>, timezone: Option<&str>, date_fmt: Option<&str>, show_offset: Option<bool>) -> PyResult<String> {
+fn format_date(
+    py: Python,
+    t: PyObject,
+    offset: Option<PyObject>,
+    timezone: Option<&str>,
+    date_fmt: Option<&str>,
+    show_offset: Option<bool>,
+) -> PyResult<String> {
     let t = if let Ok(t) = t.extract::<f64>(py) {
         t as i64
     } else if let Ok(t) = t.extract::<i64>(py) {
@@ -522,7 +607,13 @@
         None
     };
     let timezone = timezone.unwrap();
-    Ok(breezy_osutils::time::format_date(t, offset, timezone, date_fmt, show_offset.unwrap_or(true)))
+    Ok(breezy_osutils::time::format_date(
+        t,
+        offset,
+        timezone,
+        date_fmt,
+        show_offset.unwrap_or(true),
+    ))
 }
 
 #[pyfunction]
@@ -550,7 +641,8 @@
 
 #[pyfunction]
 fn unpack_highres_date(date: &str) -> PyResult<(f64, i32)> {
-    breezy_osutils::time::unpack_highres_date(date).map_err(|e| PyValueError::new_err(e.to_string()))
+    breezy_osutils::time::unpack_highres_date(date)
+        .map_err(|e| PyValueError::new_err(e.to_string()))
 }
 
 #[pyfunction]
@@ -589,7 +681,10 @@
 #[pyfunction]
 fn chmod_if_possible(path: PathBuf, mode: u32) -> PyResult<()> {
     use std::os::unix::fs::PermissionsExt;
-    Ok(breezy_osutils::file::chmod_if_possible(path, Permissions::from_mode(mode))?)
+    Ok(breezy_osutils::file::chmod_if_possible(
+        path,
+        Permissions::from_mode(mode),
+    )?)
 }
 
 #[pyfunction]
@@ -626,7 +721,9 @@
     m.add_wrapped(wrap_pyfunction!(check_text_path))?;
     m.add_wrapped(wrap_pyfunction!(check_text_lines))?;
     m.add_wrapped(wrap_pyfunction!(format_delta))?;
-    m.add_wrapped(wrap_pyfunction!(format_date_with_offset_in_original_timezone))?;
+    m.add_wrapped(wrap_pyfunction!(
+        format_date_with_offset_in_original_timezone
+    ))?;
     m.add_wrapped(wrap_pyfunction!(format_date))?;
     m.add_wrapped(wrap_pyfunction!(format_highres_date))?;
     m.add_wrapped(wrap_pyfunction!(unpack_highres_date))?;
@@ -639,6 +736,9 @@
     m.add_wrapped(wrap_pyfunction!(quotefn))?;
     #[cfg(unix)]
     m.add_wrapped(wrap_pyfunction!(get_umask))?;
-    m.add("UnsupportedTimezoneFormat", py.get_type::<UnsupportedTimezoneFormat>())?;
+    m.add(
+        "UnsupportedTimezoneFormat",
+        py.get_type::<UnsupportedTimezoneFormat>(),
+    )?;
     Ok(())
 }

=== modified file 'crates/osutils/src/file.rs'
--- crates/osutils/src/file.rs	2023-04-16 11:47:42 +0000
+++ crates/osutils/src/file.rs	2023-04-17 11:56:43 +0000
@@ -1,8 +1,8 @@
-use std::path::Path;
+use log::debug;
+use std::fs::{set_permissions, Permissions};
 use std::io::Result;
-use std::fs::{Permissions, set_permissions};
 use std::os::unix::fs::PermissionsExt;
-use log::debug;
+use std::path::Path;
 
 pub fn make_writable<P: AsRef<Path>>(path: P) -> Result<()> {
     let path = path.as_ref();
@@ -39,7 +39,7 @@
                 debug!("ignore error on chmod of {:?}: {:?}", path.as_ref(), e);
                 Ok(())
             }
-            _ => Err(e)
+            _ => Err(e),
         }
     } else {
         Ok(())

=== modified file 'crates/osutils/src/iterablefile.rs'
--- crates/osutils/src/iterablefile.rs	2023-04-13 16:25:22 +0000
+++ crates/osutils/src/iterablefile.rs	2023-04-17 11:56:43 +0000
@@ -1,4 +1,4 @@
-use std::io::{self, Read, Seek, SeekFrom, BufRead};
+use std::io::{self, BufRead, Read, Seek, SeekFrom};
 
 pub struct IterableFile<I: Iterator<Item = io::Result<Vec<u8>>> + Send> {
     iter: I,
@@ -85,7 +85,12 @@
 
     #[test]
     fn test_read_all() {
-        let content: Vec<Vec<u8>> = vec![b"This ".to_vec(), b"is ".to_vec(), b"a ".to_vec(), b"test.".to_vec()];
+        let content: Vec<Vec<u8>> = vec![
+            b"This ".to_vec(),
+            b"is ".to_vec(),
+            b"a ".to_vec(),
+            b"test.".to_vec(),
+        ];
         let mut file = IterableFile::new(content.iter().map(|x| Ok(x.to_vec())));
         let mut buf = Vec::new();
         let read = file.read_to_end(&mut buf).unwrap();
@@ -95,7 +100,12 @@
 
     #[test]
     fn test_read_n() {
-        let content: Vec<Vec<u8>> = vec![b"This ".to_vec(), b"is ".to_vec(), b"a ".to_vec(), b"test.".to_vec()];
+        let content: Vec<Vec<u8>> = vec![
+            b"This ".to_vec(),
+            b"is ".to_vec(),
+            b"a ".to_vec(),
+            b"test.".to_vec(),
+        ];
         let mut file = IterableFile::new(content.iter().map(|x| Ok(x.to_vec())));
         let mut buf = [0u8; 8];
         file.read_exact(&mut buf).unwrap();
@@ -104,7 +114,12 @@
 
     #[test]
     fn test_read_to() {
-        let content: Vec<Vec<u8>> = vec![b"This\n".to_vec(), b"is ".to_vec(), b"a ".to_vec(), b"test.\n".to_vec()];
+        let content: Vec<Vec<u8>> = vec![
+            b"This\n".to_vec(),
+            b"is ".to_vec(),
+            b"a ".to_vec(),
+            b"test.\n".to_vec(),
+        ];
         let mut file = IterableFile::new(content.iter().map(|x| Ok(x.to_vec())));
         let mut buf = Vec::new();
         file.read_until(b'\n', &mut buf).unwrap();
@@ -117,7 +132,13 @@
 
     #[test]
     fn test_readline() {
-        let content: Vec<Vec<u8>> = vec![b"".to_vec(), b"This\n".to_vec(), b"is ".to_vec(), b"a ".to_vec(), b"test.\n".to_vec()];
+        let content: Vec<Vec<u8>> = vec![
+            b"".to_vec(),
+            b"This\n".to_vec(),
+            b"is ".to_vec(),
+            b"a ".to_vec(),
+            b"test.\n".to_vec(),
+        ];
         let mut file = IterableFile::new(content.iter().map(|x| Ok(x.to_vec())));
         let mut buf = String::new();
         let read = file.read_line(&mut buf).unwrap();
@@ -127,7 +148,13 @@
 
     #[test]
     fn test_readlines() {
-        let content: Vec<Vec<u8>> = vec![b"This\n".to_vec(), b"is ".to_vec(), b"".to_vec(), b"a ".to_vec(), b"test.\n".to_vec()];
+        let content: Vec<Vec<u8>> = vec![
+            b"This\n".to_vec(),
+            b"is ".to_vec(),
+            b"".to_vec(),
+            b"a ".to_vec(),
+            b"test.\n".to_vec(),
+        ];
         let file = IterableFile::new(content.iter().map(|x| Ok(x.to_vec())));
         let lines: Vec<String> = file.lines().map(|line| line.unwrap()).collect();
         assert_eq!(lines, vec!["This", "is a test."]);
@@ -135,7 +162,13 @@
 
     #[test]
     fn test_fillbuf() {
-        let content: Vec<Vec<u8>> = vec![b"This ".to_vec(), b"".to_vec(), b"is ".to_vec(), b"a ".to_vec(), b"test.".to_vec()];
+        let content: Vec<Vec<u8>> = vec![
+            b"This ".to_vec(),
+            b"".to_vec(),
+            b"is ".to_vec(),
+            b"a ".to_vec(),
+            b"test.".to_vec(),
+        ];
         let mut file = IterableFile::new(content.iter().map(|x| Ok(x.to_vec())));
         assert_eq!(file.fill_buf().unwrap(), b"This ");
         file.consume(5);
@@ -150,7 +183,12 @@
 
     #[test]
     fn test_drain() {
-        let content: Vec<Vec<u8>> = vec![b"This ".to_vec(), b"is ".to_vec(), b"a ".to_vec(), b"test.".to_vec()];
+        let content: Vec<Vec<u8>> = vec![
+            b"This ".to_vec(),
+            b"is ".to_vec(),
+            b"a ".to_vec(),
+            b"test.".to_vec(),
+        ];
         let mut file = IterableFile::new(content.iter().map(|x| Ok(x.to_vec())));
         let buf = file.fill_buf().unwrap();
         assert_eq!(buf, b"This ");

=== modified file 'crates/osutils/src/lib.rs'
--- crates/osutils/src/lib.rs	2023-04-16 11:47:42 +0000
+++ crates/osutils/src/lib.rs	2023-04-17 11:56:43 +0000
@@ -1,11 +1,12 @@
+#[cfg(unix)]
+use libc;
 use memchr::memchr;
 use rand::Rng;
-#[cfg(unix)]
-use libc;
 
 pub fn chunks_to_lines<'a, I, E>(mut chunks: I) -> impl Iterator<Item = Result<Vec<u8>, E>>
 where
-    I: Iterator<Item = Result<&'a [u8], E>> + 'a, E: std::fmt::Debug
+    I: Iterator<Item = Result<&'a [u8], E>> + 'a,
+    E: std::fmt::Debug,
 {
     let mut tail: Option<Vec<u8>> = None;
 
@@ -58,7 +59,10 @@
     })
 }
 
-pub fn set_or_unset_env(env_variable: &str, value: Option<&str>) -> Result<Option<String>, std::env::VarError> {
+pub fn set_or_unset_env(
+    env_variable: &str,
+    value: Option<&str>,
+) -> Result<Option<String>, std::env::VarError> {
     let orig_val = std::env::var(env_variable);
     let ret: Option<String>;
     if let Err(std::env::VarError::NotPresent) = orig_val {
@@ -73,7 +77,7 @@
         ret = Some(orig_val.unwrap());
         match value {
             None => std::env::remove_var(env_variable),
-            Some(val) => std::env::set_var(env_variable, val)
+            Some(val) => std::env::set_var(env_variable, val),
         }
     }
     Ok(ret)
@@ -113,12 +117,12 @@
     }
 }
 
+pub mod file;
+pub mod iterablefile;
+pub mod path;
 pub mod sha;
-pub mod path;
+pub mod textfile;
 pub mod time;
-pub mod iterablefile;
-pub mod textfile;
-pub mod file;
 
 #[cfg(test)]
 mod tests;

=== modified file 'crates/osutils/src/path.rs'
--- crates/osutils/src/path.rs	2023-04-16 11:47:42 +0000
+++ crates/osutils/src/path.rs	2023-04-17 11:56:43 +0000
@@ -1,9 +1,9 @@
-use std::path::{Path,PathBuf};
+use lazy_static::lazy_static;
+use regex::Regex;
 use std::collections::HashSet;
 use std::os::unix::fs::PermissionsExt;
-use unicode_normalization::{UnicodeNormalization,is_nfc};
-use regex::Regex;
-use lazy_static::lazy_static;
+use std::path::{Path, PathBuf};
+use unicode_normalization::{is_nfc, UnicodeNormalization};
 
 pub fn is_inside(dir: &Path, fname: &Path) -> bool {
     fname.starts_with(&dir)
@@ -51,14 +51,33 @@
     use winreg::enums::{HKEY_LOCAL_MACHINE, KEY_QUERY_VALUE};
     use winreg::RegKey;
     let exts = env::var("PATHEXT").unwrap_or_default();
-    let exts = exts.split(';').map(|ext| ext.to_lowercase()).collect::<Vec<_>>();
+    let exts = exts
+        .split(';')
+        .map(|ext| ext.to_lowercase())
+        .collect::<Vec<_>>();
     let (name, exts) = {
         let mut path = PathBuf::from(name);
-        let ext = path.extension().and_then(|ext| ext.to_str()).unwrap_or_default().to_lowercase();
+        let ext = path
+            .extension()
+            .and_then(|ext| ext.to_str())
+            .unwrap_or_default()
+            .to_lowercase();
         if !exts.is_empty() && !exts.contains(&ext) {
-            (path.file_stem().unwrap_or_default().to_str().unwrap_or_default(), vec![ext])
+            (
+                path.file_stem()
+                    .unwrap_or_default()
+                    .to_str()
+                    .unwrap_or_default(),
+                vec![ext],
+            )
         } else {
-            (path.file_stem().unwrap_or_default().to_str().unwrap_or_default(), exts)
+            (
+                path.file_stem()
+                    .unwrap_or_default()
+                    .to_str()
+                    .unwrap_or_default(),
+                exts,
+            )
         }
     };
     let paths = env::var("PATH").unwrap_or_default();
@@ -71,7 +90,9 @@
             }
         }
     }
-    if let Ok(reg_key) = RegKey::predef(HKEY_LOCAL_MACHINE).open_subkey(r"SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths") {
+    if let Ok(reg_key) = RegKey::predef(HKEY_LOCAL_MACHINE)
+        .open_subkey(r"SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths")
+    {
         if let Ok(value) = reg_key.get_value(name) {
             if let Some(value) = value.as_string() {
                 return Some(value);
@@ -97,7 +118,10 @@
     })
 }
 
-pub fn available_backup_name<'a, E>(path: &Path, exists: &'a dyn Fn(&Path) -> Result<bool, E>) -> Result<PathBuf, E> {
+pub fn available_backup_name<'a, E>(
+    path: &Path,
+    exists: &'a dyn Fn(&Path) -> Result<bool, E>,
+) -> Result<PathBuf, E> {
     let mut counter = 0;
     let mut next = || {
         counter += 1;

=== modified file 'crates/osutils/src/sha.rs'
--- crates/osutils/src/sha.rs	2023-04-10 19:43:24 +0000
+++ crates/osutils/src/sha.rs	2023-04-17 11:56:43 +0000
@@ -1,7 +1,7 @@
+use sha1::{Digest, Sha1};
 use std::fs::File;
 use std::io::Read;
 use std::path::Path;
-use sha1::{Digest, Sha1};
 
 pub fn sha_file(f: &mut dyn Read) -> Result<String, std::io::Error> {
     let mut s = Sha1::new();

=== modified file 'crates/osutils/src/tests.rs'
--- crates/osutils/src/tests.rs	2023-04-12 22:24:34 +0000
+++ crates/osutils/src/tests.rs	2023-04-17 11:56:43 +0000
@@ -5,7 +5,10 @@
 fn assert_chunks_to_lines(input: Vec<&str>, expected: Vec<&str>) {
     let iter = input.iter().map(|l| Ok::<&[u8], String>(l.as_bytes()));
     let got = chunks_to_lines(iter);
-    let got = got.map(|l| String::from_utf8(l.unwrap())).collect::<Result<Vec<_>, _>>().unwrap();
+    let got = got
+        .map(|l| String::from_utf8(l.unwrap()))
+        .collect::<Result<Vec<_>, _>>()
+        .unwrap();
     assert_eq!(got, expected);
 }
 

=== modified file 'crates/osutils/src/textfile.rs'
--- crates/osutils/src/textfile.rs	2023-04-13 19:24:39 +0000
+++ crates/osutils/src/textfile.rs	2023-04-17 11:56:43 +0000
@@ -1,5 +1,5 @@
 use std::fs::File;
-use std::io::{Read,Error};
+use std::io::{Error, Read};
 use std::path::Path;
 
 /// Return false if the supplied lines contain NULs.

=== modified file 'crates/osutils/src/time.rs'
--- crates/osutils/src/time.rs	2023-04-16 11:47:42 +0000
+++ crates/osutils/src/time.rs	2023-04-17 11:56:43 +0000
@@ -1,5 +1,5 @@
+use chrono::{DateTime, FixedOffset, Local, NaiveDateTime, TimeZone, Utc};
 use std::time::UNIX_EPOCH;
-use chrono::{DateTime, NaiveDateTime, Local, TimeZone, Utc, FixedOffset, Datelike, Timelike};
 
 const DEFAULT_DATE_FORMAT: &str = "%a %Y-%m-%d %H:%M:%S";
 
@@ -115,18 +115,33 @@
     let offset_hours = offset / 3600;
     let offset_minutes = (offset % 3600) / 60;
 
-    let dt = DateTime::<Utc>::from(UNIX_EPOCH + std::time::Duration::from_secs(t as u64) + std::time::Duration::from_secs(offset as u64));
+    let dt = DateTime::<Utc>::from(
+        UNIX_EPOCH
+            + std::time::Duration::from_secs(t as u64)
+            + std::time::Duration::from_secs(offset as u64),
+    );
     let date_str = dt.format(DEFAULT_DATE_FORMAT).to_string();
     let offset_str = format!(" {:+03}{:02}", offset_hours, offset_minutes);
 
     date_str + &offset_str
 }
 
-pub fn format_date(t: i64, offset: Option<i64>, timezone: Timezone, date_fmt: Option<&str>, show_offset: bool) -> String {
+pub fn format_date(
+    t: i64,
+    offset: Option<i64>,
+    timezone: Timezone,
+    date_fmt: Option<&str>,
+    show_offset: bool,
+) -> String {
     let (dt, offset_str) = match timezone {
         Timezone::Utc => (
             DateTime::from_utc(NaiveDateTime::from_timestamp(t, 0), Utc),
-            if show_offset { " +0000".to_owned() } else { "".to_owned() }),
+            if show_offset {
+                " +0000".to_owned()
+            } else {
+                "".to_owned()
+            },
+        ),
         Timezone::Original => {
             let offset = offset.unwrap_or(0);
             let offset_str = if show_offset {
@@ -137,8 +152,11 @@
             } else {
                 "".to_owned()
             };
-            (DateTime::from_utc(NaiveDateTime::from_timestamp(t + offset, 0), Utc), offset_str)
-        },
+            (
+                DateTime::from_utc(NaiveDateTime::from_timestamp(t + offset, 0), Utc),
+                offset_str,
+            )
+        }
         Timezone::Local => {
             let local = Local.timestamp(t, 0);
             let offset = local.offset().local_minus_utc();
@@ -151,9 +169,11 @@
                 "".to_owned()
             };
             (local.with_timezone(&Utc), offset_str)
-        },
+        }
     };
-    dt.format(date_fmt.unwrap_or(DEFAULT_DATE_FORMAT)).to_string() + &offset_str
+    dt.format(date_fmt.unwrap_or(DEFAULT_DATE_FORMAT))
+        .to_string()
+        + &offset_str
 }
 
 pub fn format_highres_date(t: f64, offset: Option<i32>) -> String {
@@ -161,7 +181,12 @@
     let datetime = Utc.timestamp_opt(t as i64 + offset as i64, 0).unwrap();
     let highres_seconds = format!("{:.9}", t - t.floor())[1..].to_string();
     let offset_str = format!(" {:+03}{:02}", offset / 3600, (offset / 60) % 60);
-    format!("{}{}{}", datetime.format(DEFAULT_DATE_FORMAT), highres_seconds, offset_str)
+    format!(
+        "{}{}{}",
+        datetime.format(DEFAULT_DATE_FORMAT),
+        highres_seconds,
+        offset_str
+    )
 }
 
 const WEEKDAYS: [&str; 7] = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
@@ -169,15 +194,24 @@
 pub fn unpack_highres_date(date: &str) -> Result<(f64, i32), String> {
     let space_loc = date.find(' ');
     if space_loc.is_none() {
-        return Err(format!("date string does not contain a day of week: {}", date));
+        return Err(format!(
+            "date string does not contain a day of week: {}",
+            date
+        ));
     }
     let weekday = &date[..space_loc.unwrap()];
     if WEEKDAYS.iter().find(|&&d| d == weekday).is_none() {
-        return Err(format!("date string does not contain a valid day of week: {}", date));
+        return Err(format!(
+            "date string does not contain a valid day of week: {}",
+            date
+        ));
     }
     let dot_loc = date.find('.');
     if dot_loc.is_none() {
-        return Err(format!("Date string does not contain high-precision seconds: {}", date));
+        return Err(format!(
+            "Date string does not contain high-precision seconds: {}",
+            date
+        ));
     }
     let base_time_str = &date[space_loc.unwrap() + 1..dot_loc.unwrap()];
     let offset_loc = date[dot_loc.unwrap()..].find(' ');
@@ -187,13 +221,19 @@
     let fract_seconds_str = &date[dot_loc.unwrap()..dot_loc.unwrap() + offset_loc.unwrap()];
     let offset_str = &date[dot_loc.unwrap() + 1 + offset_loc.unwrap()..];
 
-    let base_time = Utc.datetime_from_str(base_time_str, "%Y-%m-%d %H:%M:%S")
+    let base_time = Utc
+        .datetime_from_str(base_time_str, "%Y-%m-%d %H:%M:%S")
         .map_err(|e| format!("Failed to parse datetime string ({}): {}", base_time_str, e))?;
 
-    let fract_seconds = fract_seconds_str.parse::<f64>()
-        .map_err(|e| format!("Failed to parse high-precision seconds({}) : {}", fract_seconds_str, e))?;
+    let fract_seconds = fract_seconds_str.parse::<f64>().map_err(|e| {
+        format!(
+            "Failed to parse high-precision seconds({}) : {}",
+            fract_seconds_str, e
+        )
+    })?;
 
-    let offset = offset_str.parse::<i32>()
+    let offset = offset_str
+        .parse::<i32>()
         .map_err(|e| format!("Failed to parse offset ({}): {}", offset_str, e))?;
 
     let offset_hours = offset / 100;

=== modified file 'crates/patch-py/src/lib.rs'
--- crates/patch-py/src/lib.rs	2023-04-16 01:30:53 +0000
+++ crates/patch-py/src/lib.rs	2023-04-17 11:56:43 +0000
@@ -1,53 +1,91 @@
+use pyo3::create_exception;
+use pyo3::exceptions::PyValueError;
+use pyo3::import_exception;
 use pyo3::prelude::*;
+use pyo3::types::{PyBytes, PyIterator, PyList};
 use pyo3::wrap_pyfunction;
-use pyo3::types::{PyBytes, PyList, PyIterator};
-use pyo3::exceptions::PyValueError;
-use pyo3::create_exception;
-use pyo3::import_exception;
 use pyo3_file::PyFileLikeObject;
-use std::path::PathBuf;
+use std::ffi::OsString;
 use std::io::Write;
-use std::ffi::OsString;
 use std::os::unix::ffi::OsStringExt;
+use std::path::PathBuf;
 
 create_exception!(_patch_rs, PatchInvokeError, pyo3::exceptions::PyException);
 create_exception!(_patch_rs, PatchFailed, pyo3::exceptions::PyException);
 create_exception!(_patch_rs, BinaryFiles, pyo3::exceptions::PyException);
 create_exception!(_patch_rs, PatchSyntax, pyo3::exceptions::PyException);
-create_exception!(_patch_rs, MalformedPatchHeader, pyo3::exceptions::PyException);
+create_exception!(
+    _patch_rs,
+    MalformedPatchHeader,
+    pyo3::exceptions::PyException
+);
 import_exception!(breezy.errors, BinaryFile);
 
 #[pyfunction]
-fn patch(patch_contents: Vec<Vec<u8>>, filename: PathBuf, output_filename: Option<PathBuf>, reverse: Option<bool>) -> PyResult<i32> {
+fn patch(
+    patch_contents: Vec<Vec<u8>>,
+    filename: PathBuf,
+    output_filename: Option<PathBuf>,
+    reverse: Option<bool>,
+) -> PyResult<i32> {
     let output_path = output_filename.as_ref().map(|x| x.as_path());
-    breezy_patch::invoke::patch(patch_contents.iter().map(|x| x.as_slice()), filename.as_path(), output_path, reverse.unwrap_or(false))
-        .map_err(invoke_err_to_py_err)
-}
-
-#[pyfunction]
-fn diff3(out_file: PathBuf, mine_path: PathBuf, older_path: PathBuf, yours_path: PathBuf) -> PyResult<i32> {
-    breezy_patch::invoke::diff3(out_file.as_path(), mine_path.as_path(), older_path.as_path(), yours_path.as_path())
-        .map_err(invoke_err_to_py_err)
-}
-
-#[pyfunction]
-fn run_patch(directory: PathBuf, patches: Vec<Vec<u8>>, strip: Option<u32>, reverse: Option<bool>, dry_run: Option<bool>, quiet: Option<bool>, target_file: Option<&str>, out: Option<PyObject>, _patch_cmd: Option<&str>) -> PyResult<()> {
+    breezy_patch::invoke::patch(
+        patch_contents.iter().map(|x| x.as_slice()),
+        filename.as_path(),
+        output_path,
+        reverse.unwrap_or(false),
+    )
+    .map_err(invoke_err_to_py_err)
+}
+
+#[pyfunction]
+fn diff3(
+    out_file: PathBuf,
+    mine_path: PathBuf,
+    older_path: PathBuf,
+    yours_path: PathBuf,
+) -> PyResult<i32> {
+    breezy_patch::invoke::diff3(
+        out_file.as_path(),
+        mine_path.as_path(),
+        older_path.as_path(),
+        yours_path.as_path(),
+    )
+    .map_err(invoke_err_to_py_err)
+}
+
+#[pyfunction]
+fn run_patch(
+    directory: PathBuf,
+    patches: Vec<Vec<u8>>,
+    strip: Option<u32>,
+    reverse: Option<bool>,
+    dry_run: Option<bool>,
+    quiet: Option<bool>,
+    target_file: Option<&str>,
+    out: Option<PyObject>,
+    _patch_cmd: Option<&str>,
+) -> PyResult<()> {
     let mut out: Box<dyn Write> = if let Some(obj) = out {
-       Box::new(PyFileLikeObject::with_requirements(obj, false, true, false)?)
+        Box::new(PyFileLikeObject::with_requirements(
+            obj, false, true, false,
+        )?)
     } else {
         Box::new(std::io::stdout())
     };
 
     breezy_patch::invoke::run_patch(
-            directory.as_path(),
-            patches.iter().map(|x| x.as_slice()),
-            strip.unwrap_or(0),
-            reverse.unwrap_or(false),
-            dry_run.unwrap_or(false),
-            quiet.unwrap_or(true),
-            target_file, &mut out,
-            _patch_cmd)
-        .map_err(invoke_err_to_py_err)
+        directory.as_path(),
+        patches.iter().map(|x| x.as_slice()),
+        strip.unwrap_or(0),
+        reverse.unwrap_or(false),
+        dry_run.unwrap_or(false),
+        quiet.unwrap_or(true),
+        target_file,
+        &mut out,
+        _patch_cmd,
+    )
+    .map_err(invoke_err_to_py_err)
 }
 
 fn invoke_err_to_py_err(err: breezy_patch::invoke::Error) -> PyErr {
@@ -56,18 +94,26 @@
         breezy_patch::invoke::Error::BinaryFile(path) => BinaryFile::new_err(path),
         breezy_patch::invoke::Error::PatchInvokeError(errstr, stderr, inner) => {
             PatchInvokeError::new_err((errstr, stderr, inner.map(|x| x.to_string())))
-        },
-        breezy_patch::invoke::Error::PatchFailed(exitcode, stderr) => PatchFailed::new_err((exitcode, stderr)),
+        }
+        breezy_patch::invoke::Error::PatchFailed(exitcode, stderr) => {
+            PatchFailed::new_err((exitcode, stderr))
+        }
     }
 }
 
 #[pyfunction]
-fn iter_patched_from_hunks(py: Python, orig_lines: PyObject, hunks: PyObject) -> PyResult<PyObject> {
+fn iter_patched_from_hunks(
+    py: Python,
+    orig_lines: PyObject,
+    hunks: PyObject,
+) -> PyResult<PyObject> {
     let orig_lines = orig_lines.extract::<Vec<Vec<u8>>>(py)?;
     let hunks = hunks.extract::<Vec<Vec<u8>>>(py)?;
     let patched_lines = breezy_patch::invoke::iter_patched_from_hunks(
         orig_lines.iter().map(|x| x.as_slice()),
-        hunks.iter().map(|x| x.as_slice())).map_err(invoke_err_to_py_err)?;
+        hunks.iter().map(|x| x.as_slice()),
+    )
+    .map_err(invoke_err_to_py_err)?;
 
     let pl = vec![PyBytes::new(py, &patched_lines)];
     Ok(PyList::new(py, &pl).into())
@@ -75,34 +121,54 @@
 
 fn parse_err_to_py_err(err: breezy_patch::parse::Error) -> PyErr {
     match err {
-        breezy_patch::parse::Error::BinaryFiles(path1, path2) => BinaryFiles::new_err((PathBuf::from(OsString::from_vec(path1)), PathBuf::from(OsString::from_vec(path2)))),
+        breezy_patch::parse::Error::BinaryFiles(path1, path2) => BinaryFiles::new_err((
+            PathBuf::from(OsString::from_vec(path1)),
+            PathBuf::from(OsString::from_vec(path2)),
+        )),
         breezy_patch::parse::Error::PatchSyntax(err, _line) => PatchSyntax::new_err(err),
-        breezy_patch::parse::Error::MalformedPatchHeader(err, line) => MalformedPatchHeader::new_err(err),
+        breezy_patch::parse::Error::MalformedPatchHeader(err, line) => {
+            MalformedPatchHeader::new_err(err)
+        }
     }
 }
 
 #[pyfunction]
-fn get_patch_names(py: Python, patch_contents: PyObject) -> PyResult<((PyObject, Option<PyObject>), (PyObject, Option<PyObject>))> {
+fn get_patch_names(
+    py: Python,
+    patch_contents: PyObject,
+) -> PyResult<((PyObject, Option<PyObject>), (PyObject, Option<PyObject>))> {
     let names = breezy_patch::parse::get_patch_names(
-        patch_contents.downcast::<PyIterator>(py)?.map(|x| x.unwrap().extract::<Vec<u8>>().unwrap())).map_err(parse_err_to_py_err)?;
+        patch_contents
+            .downcast::<PyIterator>(py)?
+            .map(|x| x.unwrap().extract::<Vec<u8>>().unwrap()),
+    )
+    .map_err(parse_err_to_py_err)?;
 
-    let py_orig = (PyBytes::new(py, &names.0.0).to_object(py), names.0.1.map(|x| PyBytes::new(py, &x).to_object(py)));
-    let py_mod = (PyBytes::new(py, &names.1.0).to_object(py), names.1.1.map(|x| PyBytes::new(py, &x).to_object(py)));
+    let py_orig = (
+        PyBytes::new(py, &names.0 .0).to_object(py),
+        names.0 .1.map(|x| PyBytes::new(py, &x).to_object(py)),
+    );
+    let py_mod = (
+        PyBytes::new(py, &names.1 .0).to_object(py),
+        names.1 .1.map(|x| PyBytes::new(py, &x).to_object(py)),
+    );
     Ok((py_orig, py_mod))
 }
 
 #[pyfunction]
 fn iter_lines_handle_nl(py: Python, iter_lines: PyObject) -> PyResult<PyObject> {
     let py_iter = iter_lines.as_ref(py).iter()?;
-    let lines = breezy_patch::parse::iter_lines_handle_nl(py_iter.map(|x| x.unwrap().extract::<Vec<u8>>().unwrap()));
+    let lines = breezy_patch::parse::iter_lines_handle_nl(
+        py_iter.map(|x| x.unwrap().extract::<Vec<u8>>().unwrap()),
+    );
     let pl = lines.map(|x| PyBytes::new(py, &x)).collect::<Vec<_>>();
     Ok(PyList::new(py, &pl).as_ref().iter()?.to_object(py))
 }
 
 #[pyfunction]
 fn parse_range(textrange: &str) -> PyResult<(i32, i32)> {
-    breezy_patch::parse::parse_range(textrange).map_err(
-        |err| PyValueError::new_err(format!("Invalid range: {}", err)))
+    breezy_patch::parse::parse_range(textrange)
+        .map_err(|err| PyValueError::new_err(format!("Invalid range: {}", err)))
 }
 
 #[pyfunction]
@@ -123,7 +189,10 @@
     m.add("PatchInvokeError", py.get_type::<PatchInvokeError>())?;
     m.add("PatchFailed", py.get_type::<PatchFailed>())?;
     m.add("PatchSyntax", py.get_type::<PatchSyntax>())?;
-    m.add("MalformedPatchHeader", py.get_type::<MalformedPatchHeader>())?;
+    m.add(
+        "MalformedPatchHeader",
+        py.get_type::<MalformedPatchHeader>(),
+    )?;
     m.add("BinaryFiles", py.get_type::<BinaryFiles>())?;
     Ok(())
 }

=== modified file 'crates/patch/src/invoke.rs'
--- crates/patch/src/invoke.rs	2023-04-15 03:34:42 +0000
+++ crates/patch/src/invoke.rs	2023-04-17 11:56:43 +0000
@@ -1,27 +1,35 @@
+use breezy_osutils::textfile::check_text_path;
 use std::ffi::OsString;
+use std::io::{BufWriter, Write};
 use std::path::Path;
-use std::io::{Write,BufWriter};
 use std::process::{Command, Stdio};
-use breezy_osutils::textfile::check_text_path;
 use tempfile::NamedTempFile;
 
 pub enum Error {
-    PatchInvokeError(String, String, Option<Box<dyn std::error::Error + Send + Sync>>),
+    PatchInvokeError(
+        String,
+        String,
+        Option<Box<dyn std::error::Error + Send + Sync>>,
+    ),
     PatchFailed(i32, String),
     BinaryFile(std::path::PathBuf),
     Io(std::io::Error),
 }
 
-impl From <std::io::Error> for Error {
+impl From<std::io::Error> for Error {
     fn from(e: std::io::Error) -> Self {
         Error::Io(e)
     }
 }
 
 /// Invoke a command with the given arguments, passing `input` to its stdin.
-fn write_to_cmd<'a, I>(command: &str, args: &[OsString], input: I) -> std::io::Result<(Vec<u8>, Vec<u8>, i32)>
+fn write_to_cmd<'a, I>(
+    command: &str,
+    args: &[OsString],
+    input: I,
+) -> std::io::Result<(Vec<u8>, Vec<u8>, i32)>
 where
-    I: IntoIterator<Item = &'a [u8]>
+    I: IntoIterator<Item = &'a [u8]>,
 {
     let mut cmd = Command::new(command);
     cmd.args(args)
@@ -29,7 +37,7 @@
         .stdout(Stdio::piped())
         .stderr(Stdio::piped());
     let mut child = cmd.spawn()?;
-    if let Some(mut stdin) = child.stdin.take()  {
+    if let Some(mut stdin) = child.stdin.take() {
         for chunk in input {
             stdin.write_all(chunk)?;
         }
@@ -42,9 +50,14 @@
 }
 
 /// Apply a patch to a file, producing another output file.
-pub fn patch<'a, I>(patch_contents: I, filename: &Path, output_filename: Option<&Path>, reverse: bool) -> Result<i32, Error>
+pub fn patch<'a, I>(
+    patch_contents: I,
+    filename: &Path,
+    output_filename: Option<&Path>,
+    reverse: bool,
+) -> Result<i32, Error>
 where
-    I: Iterator<Item = &'a [u8]>
+    I: Iterator<Item = &'a [u8]>,
 {
     let mut args: Vec<OsString> = vec![
         "-f".into(),
@@ -60,20 +73,29 @@
     }
     args.push(filename.into());
     let (stdout, stderr, status) = write_to_cmd("patch", &args, patch_contents)
-        .map_err(|e| Error::PatchInvokeError(
-            e.to_string(),
-            String::new(),
-            Some(Box::new(e)),
-        ))?;
+        .map_err(|e| Error::PatchInvokeError(e.to_string(), String::new(), Some(Box::new(e))))?;
     if status < 0 {
-        let err = if output_filename.is_some() { assert!(stderr.is_empty()); &stdout } else { &stderr };
-        return Err(Error::PatchFailed(status, String::from_utf8_lossy(err).to_string()));
+        let err = if output_filename.is_some() {
+            assert!(stderr.is_empty());
+            &stdout
+        } else {
+            &stderr
+        };
+        return Err(Error::PatchFailed(
+            status,
+            String::from_utf8_lossy(err).to_string(),
+        ));
     }
     Ok(status)
 }
 
 /// Apply a three-way merge using `diff3`.
-pub fn diff3(out_file: &Path, mine_path: &Path, older_path: &Path, yours_path: &Path) -> Result<i32, Error> {
+pub fn diff3(
+    out_file: &Path,
+    mine_path: &Path,
+    older_path: &Path,
+    yours_path: &Path,
+) -> Result<i32, Error> {
     fn add_label(args: &mut Vec<OsString>, label: &str) {
         args.extend(vec!["-L".into(), label.into()]);
     }
@@ -82,24 +104,17 @@
             return Err(Error::BinaryFile(path.to_path_buf()));
         }
     }
-    let mut args = vec![
-        "-E".into(),
-        "--merge".into(),
-    ];
+    let mut args = vec!["-E".into(), "--merge".into()];
     add_label(&mut args, "TREE");
     add_label(&mut args, "ANCESTOR");
     add_label(&mut args, "MERGE-SOURCE");
-    args.extend(vec![
-        mine_path.into(),
-        older_path.into(),
-        yours_path.into(),
-    ]);
+    args.extend(vec![mine_path.into(), older_path.into(), yours_path.into()]);
     let (output, stderr, status) = write_to_cmd("diff3", &args, std::iter::once::<&[u8]>(&[]))?;
     if status != 0 && status != 1 {
         return Err(Error::PatchInvokeError(
             format!("diff3 exited with status {}", status),
             String::from_utf8_lossy(&stderr).to_string(),
-            None
+            None,
         ));
     }
     std::fs::write(out_file, &output)?;
@@ -118,7 +133,7 @@
     patch_cmd: Option<&str>,
 ) -> Result<(), Error>
 where
-    I: Iterator<Item = &'a [u8]>
+    I: Iterator<Item = &'a [u8]>,
 {
     let mut args: Vec<OsString> = vec![
         "-d".into(),
@@ -147,15 +162,14 @@
         args.push(target_file.into());
     }
     let mut process = Command::new(patch_cmd.unwrap_or("patch"));
-    process.args(&args)
+    process
+        .args(&args)
         .stdin(Stdio::piped())
         .stdout(Stdio::piped())
         .stderr(Stdio::piped());
-    let mut child = process.spawn().map_err(|e| Error::PatchInvokeError(
-        e.to_string(),
-        String::new(),
-        Some(Box::new(e)),
-    ))?;
+    let mut child = process
+        .spawn()
+        .map_err(|e| Error::PatchInvokeError(e.to_string(), String::new(), Some(Box::new(e))))?;
     if let Some(mut stdin) = child.stdin.take() {
         for patch in patches {
             stdin.write_all(patch)?;
@@ -172,7 +186,10 @@
     let status = output.status.code().unwrap_or(-1);
     assert!(output.stderr.is_empty());
     if status != 0 {
-        return Err(Error::PatchFailed(status, String::from_utf8_lossy(&output.stdout).to_string()));
+        return Err(Error::PatchFailed(
+            status,
+            String::from_utf8_lossy(&output.stdout).to_string(),
+        ));
     }
     out.write_all(&output.stdout)?;
     Ok(())
@@ -184,7 +201,7 @@
 pub fn iter_patched_from_hunks<'a, I, H>(orig_lines: I, hunks: H) -> Result<Vec<u8>, Error>
 where
     I: IntoIterator<Item = &'a [u8]>,
-    H: Iterator<Item = &'a [u8]>
+    H: Iterator<Item = &'a [u8]>,
 {
     let temp_file = NamedTempFile::new()?;
     let mut f = BufWriter::new(temp_file);
@@ -204,12 +221,12 @@
         temp_file_path.as_os_str().into(),
     ];
     let (stdout, stderr, status) = write_to_cmd("patch", &args, hunks)
-        .map_err(|e| Error::PatchInvokeError(
-            e.to_string(),
-            String::new(),
-            Some(Box::new(e))))?;
+        .map_err(|e| Error::PatchInvokeError(e.to_string(), String::new(), Some(Box::new(e))))?;
     if status != 0 {
-        return Err(Error::PatchFailed(status, String::from_utf8_lossy(&stderr).to_string()));
+        return Err(Error::PatchFailed(
+            status,
+            String::from_utf8_lossy(&stderr).to_string(),
+        ));
     }
     assert!(stderr.is_empty());
     Ok(stdout)

=== modified file 'crates/patch/src/parse.rs'
--- crates/patch/src/parse.rs	2023-04-16 01:30:53 +0000
+++ crates/patch/src/parse.rs	2023-04-17 11:56:43 +0000
@@ -1,5 +1,5 @@
+use lazy_static::lazy_static;
 use regex::bytes::Regex;
-use lazy_static::lazy_static;
 use std::num::ParseIntError;
 
 pub enum Error {
@@ -12,10 +12,13 @@
     mut iter_lines: T,
 ) -> Result<((Vec<u8>, Option<Vec<u8>>), (Vec<u8>, Option<Vec<u8>>)), Error> {
     lazy_static! {
-        static ref BINARY_FILES_RE: Regex = Regex::new(r"^Binary files (.+) and (.+) differ").unwrap();
+        static ref BINARY_FILES_RE: Regex =
+            Regex::new(r"^Binary files (.+) and (.+) differ").unwrap();
     }
 
-    let line = iter_lines.next().ok_or_else(||Error::PatchSyntax("No input", vec![]))?;
+    let line = iter_lines
+        .next()
+        .ok_or_else(|| Error::PatchSyntax("No input", vec![]))?;
 
     let (orig_name, orig_ts) = match BINARY_FILES_RE.captures(&line) {
         Some(captures) => {
@@ -25,9 +28,12 @@
         }
         None => {
             let orig_name = line
-                .strip_prefix(b"--- ").ok_or_else(||Error::MalformedPatchHeader("No orig name", line.to_vec()))?
-                .strip_suffix(b"\n").ok_or_else(|| Error::PatchSyntax("missing newline", line.to_vec()))?;
-            let (orig_name, orig_ts) = match orig_name.split(|&c| c == b'\t').collect::<Vec<_>>()[..] {
+                .strip_prefix(b"--- ")
+                .ok_or_else(|| Error::MalformedPatchHeader("No orig name", line.to_vec()))?
+                .strip_suffix(b"\n")
+                .ok_or_else(|| Error::PatchSyntax("missing newline", line.to_vec()))?;
+            let (orig_name, orig_ts) = match orig_name.split(|&c| c == b'\t').collect::<Vec<_>>()[..]
+            {
                 [name, ts] => (name.to_vec(), Some(ts.to_vec())),
                 [name] => (name.to_vec(), None),
                 _ => return Err(Error::MalformedPatchHeader("No orig line", line.to_vec())),
@@ -36,11 +42,15 @@
         }
     };
 
-    let line = iter_lines.next().ok_or_else(||Error::PatchSyntax("No input", vec![]))?;
+    let line = iter_lines
+        .next()
+        .ok_or_else(|| Error::PatchSyntax("No input", vec![]))?;
 
     let (mod_name, mod_ts) = match line.strip_prefix(b"+++ ") {
         Some(line) => {
-            let mod_name = line.strip_suffix(b"\n").ok_or_else(|| Error::PatchSyntax("missing newline", line.to_vec()))?;
+            let mod_name = line
+                .strip_suffix(b"\n")
+                .ok_or_else(|| Error::PatchSyntax("missing newline", line.to_vec()))?;
             let (mod_name, mod_ts) = match mod_name.split(|&c| c == b'\t').collect::<Vec<_>>()[..] {
                 [name, ts] => (name.to_vec(), Some(ts.to_vec())),
                 [name] => (name.to_vec(), None),

=== modified file 'crates/rio-py/src/lib.rs'
--- crates/rio-py/src/lib.rs	2023-04-10 12:31:50 +0000
+++ crates/rio-py/src/lib.rs	2023-04-17 11:56:43 +0000
@@ -2,8 +2,8 @@
 
 use pyo3::wrap_pyfunction;
 
-use pyo3::types::{PyDict,PyType,PyBytes,PyList,PyIterator,PyString};
-use pyo3::exceptions::{PyTypeError, PyValueError, PyNotImplementedError, PyIOError};
+use pyo3::exceptions::{PyIOError, PyNotImplementedError, PyTypeError, PyValueError};
+use pyo3::types::{PyBytes, PyDict, PyIterator, PyList, PyString, PyType};
 
 use pyo3::class::basic::CompareOp;
 
@@ -50,9 +50,12 @@
                 if other_stanza.is_err() {
                     Ok(false.into_py(other.py()))
                 } else {
-                    Ok(self.stanza.eq(&other_stanza.unwrap().stanza).into_py(other.py()))
+                    Ok(self
+                        .stanza
+                        .eq(&other_stanza.unwrap().stanza)
+                        .into_py(other.py()))
                 }
-            },
+            }
             _ => Err(PyErr::new::<PyNotImplementedError, _>("Not implemented")),
         }
     }
@@ -64,8 +67,12 @@
     fn get(&self, tag: &str, py: Python) -> PyResult<Option<PyObject>> {
         if let Some(value) = self.stanza.get(tag) {
             match value {
-                bazaar_rio::rio::StanzaValue::String(v) => Ok(Some(PyString::new(py, v).into_py(py))),
-                bazaar_rio::rio::StanzaValue::Stanza(v) => Ok(Some(Stanza { stanza: *v.clone() }.into_py(py))),
+                bazaar_rio::rio::StanzaValue::String(v) => {
+                    Ok(Some(PyString::new(py, v).into_py(py)))
+                }
+                bazaar_rio::rio::StanzaValue::Stanza(v) => {
+                    Ok(Some(Stanza { stanza: *v.clone() }.into_py(py)))
+                }
             }
         } else {
             Ok(None)
@@ -107,17 +114,27 @@
         // Otherwise, if the type of value is Stanza, then extract it as a Stanza and add it to the stanza.
         // Otherwise, return an error.
         let ret = if let Ok(val) = value.extract::<String>() {
-            self.stanza.add(tag.to_string(), bazaar_rio::rio::StanzaValue::String(val))
+            self.stanza
+                .add(tag.to_string(), bazaar_rio::rio::StanzaValue::String(val))
         } else if let Ok(val) = value.extract::<Stanza>() {
-            self.stanza.add(tag.to_string(), bazaar_rio::rio::StanzaValue::Stanza(Box::new(val.stanza)))
+            self.stanza.add(
+                tag.to_string(),
+                bazaar_rio::rio::StanzaValue::Stanza(Box::new(val.stanza)),
+            )
         } else {
-            return Err(PyErr::new::<PyTypeError, _>(format!("Invalid value: {}", value.repr()?)));
+            return Err(PyErr::new::<PyTypeError, _>(format!(
+                "Invalid value: {}",
+                value.repr()?
+            )));
         };
         if let Err(e) = ret {
             if let bazaar_rio::rio::Error::Io(e) = e {
                 return Err(PyErr::new::<PyIOError, _>(format!("IO error: {}", e)));
             } else {
-                return Err(PyErr::new::<PyValueError, _>(format!("Invalid value: {}", value.repr()?)));
+                return Err(PyErr::new::<PyValueError, _>(format!(
+                    "Invalid value: {}",
+                    value.repr()?
+                )));
             }
         }
         Ok(())
@@ -138,7 +155,9 @@
         let ret = PyList::empty(py);
         for (tag, value) in self.stanza.iter_pairs() {
             match value {
-                bazaar_rio::rio::StanzaValue::String(v) => ret.append((tag.to_string(), v.to_string()))?,
+                bazaar_rio::rio::StanzaValue::String(v) => {
+                    ret.append((tag.to_string(), v.to_string()))?
+                }
                 bazaar_rio::rio::StanzaValue::Stanza(v) => {
                     let sub: Stanza = Stanza { stanza: *v.clone() };
                     ret.append((tag.to_string(), sub.into_py(py)))?;
@@ -185,7 +204,7 @@
 
 #[pyclass]
 struct RioWriter {
-    writer: bazaar_rio::rio::RioWriter<PyFileLikeObject>
+    writer: bazaar_rio::rio::RioWriter<PyFileLikeObject>,
 }
 
 #[pymethods]
@@ -209,11 +228,11 @@
 
     let mut reader = BufReader::new(reader);
 
-    let stanza = bazaar_rio::rio::read_stanza_file(&mut reader).map_err(|e| {
-        match e {
-            bazaar_rio::rio::Error::Io(e) => PyErr::new::<PyIOError, _>(format!("Error reading stanza file: {}", e)),
-            _ => PyErr::new::<PyValueError, _>(format!("Error reading stanza file", )),
+    let stanza = bazaar_rio::rio::read_stanza_file(&mut reader).map_err(|e| match e {
+        bazaar_rio::rio::Error::Io(e) => {
+            PyErr::new::<PyIOError, _>(format!("Error reading stanza file: {}", e))
         }
+        _ => PyErr::new::<PyValueError, _>(format!("Error reading stanza file",)),
     })?;
 
     if let Some(stanza) = stanza {
@@ -231,13 +250,17 @@
         let line = py_iter.next()?;
         if let Err(e) = line {
             pyerr = Some(e);
-            return Some(Err(bazaar_rio::rio::Error::Other("Python error".to_string())));
+            return Some(Err(bazaar_rio::rio::Error::Other(
+                "Python error".to_string(),
+            )));
         } else {
             let line = line.unwrap();
             let line = line.extract::<Vec<u8>>();
             if let Err(e) = line {
                 pyerr = Some(e);
-                return Some(Err(bazaar_rio::rio::Error::Other("invalid input".to_string())));
+                return Some(Err(bazaar_rio::rio::Error::Other(
+                    "invalid input".to_string(),
+                )));
             } else {
                 Some(Ok(line.unwrap()))
             }
@@ -249,8 +272,10 @@
             return e;
         }
         match e {
-            bazaar_rio::rio::Error::Io(e) => PyErr::new::<PyIOError, _>(format!("Error reading stanza: {}", e)),
-            _ => PyErr::new::<PyValueError, _>(format!("Error reading stanza", )),
+            bazaar_rio::rio::Error::Io(e) => {
+                PyErr::new::<PyIOError, _>(format!("Error reading stanza: {}", e))
+            }
+            _ => PyErr::new::<PyValueError, _>(format!("Error reading stanza",)),
         }
     })?;
 
@@ -269,11 +294,11 @@
 
         let mut reader = BufReader::new(reader);
 
-        let stanzas = bazaar_rio::rio::read_stanzas(&mut reader).map_err(|e| {
-            match e {
-                bazaar_rio::rio::Error::Io(e) => PyErr::new::<PyIOError, _>(format!("Error reading stanza file: {}", e)),
-                _ => PyErr::new::<PyValueError, _>(format!("Error reading stanza file: ", )),
+        let stanzas = bazaar_rio::rio::read_stanzas(&mut reader).map_err(|e| match e {
+            bazaar_rio::rio::Error::Io(e) => {
+                PyErr::new::<PyIOError, _>(format!("Error reading stanza file: {}", e))
             }
+            _ => PyErr::new::<PyValueError, _>(format!("Error reading stanza file: ",)),
         })?;
         for stanza in stanzas {
             ret.append((Stanza { stanza }).into_py(py))?;
@@ -302,13 +327,18 @@
         Python::with_gil(|py| {
             let ret = PyList::empty(py);
             for stanza in self.reader.iter() {
-                let stanza = stanza.map_err(|e| {
-                    match e {
-                        bazaar_rio::rio::Error::Io(e) => PyErr::new::<PyIOError, _>(format!("Error reading stanza file: {}", e)),
-                        _ => PyErr::new::<PyValueError, _>(format!("Error reading stanza file: ", )),
+                let stanza = stanza.map_err(|e| match e {
+                    bazaar_rio::rio::Error::Io(e) => {
+                        PyErr::new::<PyIOError, _>(format!("Error reading stanza file: {}", e))
                     }
+                    _ => PyErr::new::<PyValueError, _>(format!("Error reading stanza file: ",)),
                 })?;
-                ret.append((Stanza { stanza: stanza.unwrap() }).into_py(py))?;
+                ret.append(
+                    (Stanza {
+                        stanza: stanza.unwrap(),
+                    })
+                    .into_py(py),
+                )?;
             }
             Ok(PyIterator::from_object(py, ret)?.into())
         })

=== modified file 'crates/rio/src/rio.rs'
--- crates/rio/src/rio.rs	2023-04-14 08:57:25 +0000
+++ crates/rio/src/rio.rs	2023-04-17 11:56:43 +0000
@@ -1,4 +1,3 @@
-
 /// The RIO file format
 ///
 /// Copyright (C) 2023 Jelmer Vernooij <[e-mail]>
@@ -22,9 +21,9 @@
 /// stream representation of an object and vice versa, and that this relation
 /// will continue to hold for future versions of bzr.
 use regex::Regex;
-use std::io::{BufRead,Write};
+use std::collections::HashMap;
+use std::io::{BufRead, Write};
 use std::iter::Iterator;
-use std::collections::HashMap;
 use std::result::Result;
 use std::str;
 
@@ -87,9 +86,7 @@
     }
 
     pub fn iter(&mut self) -> RioReaderIter<R> {
-        RioReaderIter {
-            reader: self
-        }
+        RioReaderIter { reader: self }
     }
 }
 
@@ -175,13 +172,14 @@
     }
 
     pub fn iter_pairs(&self) -> impl Iterator<Item = (&str, &StanzaValue)> {
-        self.items
-            .iter()
-            .map(|(tag, value)| (tag.as_str(), value))
+        self.items.iter().map(|(tag, value)| (tag.as_str(), value))
     }
 
     pub fn to_bytes_lines(&self) -> Vec<Vec<u8>> {
-        self.to_lines().iter().map(|s| s.as_bytes().to_vec()).collect()
+        self.to_lines()
+            .iter()
+            .map(|s| s.as_bytes().to_vec())
+            .collect()
     }
 
     pub fn to_lines(&self) -> Vec<String> {
@@ -207,11 +205,7 @@
                     result.push(format!("\t{}\n", line));
                 }
             } else {
-                result.push(format!(
-                    "{}: {}\n",
-                    String::from_utf8_lossy(tag),
-                    value
-                ));
+                result.push(format!("{}: {}\n", String::from_utf8_lossy(tag), value));
             }
         }
         result
@@ -243,7 +237,8 @@
     }
 
     pub fn get_all(&self, tag: &str) -> Vec<&StanzaValue> {
-        self.items.iter()
+        self.items
+            .iter()
             .filter(|(t, _)| t == tag)
             .map(|(_, v)| v)
             .collect()
@@ -276,7 +271,8 @@
 
 pub fn read_stanza<I>(lines: I) -> Result<Option<Stanza>, Error>
 where
-    I: Iterator<Item = Result<Vec<u8>, Error>> {
+    I: Iterator<Item = Result<Vec<u8>, Error>>,
+{
     let mut stanza = Stanza::new();
     let mut tag: Option<String> = None;
     let mut accum_value: Option<Vec<String>> = None;
@@ -299,7 +295,7 @@
             // new tag:value line
             if let Some(tag) = tag.take() {
                 let value = accum_value.take().map_or_else(String::new, |v| v.join(""));
-                stanza.add(tag, StanzaValue::String(value));
+                stanza.add(tag, StanzaValue::String(value))?;
             }
             let colon_index = match line.windows(2).position(|window| window.eq(b": ")) {
                 Some(index) => index,

=== modified file 'crates/rio/src/tests.rs'
--- crates/rio/src/tests.rs	2023-04-10 12:01:30 +0000
+++ crates/rio/src/tests.rs	2023-04-17 11:56:43 +0000
@@ -1,5 +1,5 @@
 use crate::rio::valid_tag;
-use crate::rio::{Stanza,StanzaValue,read_stanza};
+use crate::rio::{read_stanza, Stanza, StanzaValue};
 
 #[test]
 fn test_valid_tag() {
@@ -18,8 +18,14 @@
     assert!(!s.contains("42"));
 
     // Verify that the s.get() function works
-    assert_eq!(s.get("number"), Some(&StanzaValue::String("42".to_string())));
-    assert_eq!(s.get("name"), Some(&StanzaValue::String("fred".to_string())));
+    assert_eq!(
+        s.get("number"),
+        Some(&StanzaValue::String("42".to_string()))
+    );
+    assert_eq!(
+        s.get("name"),
+        Some(&StanzaValue::String("fred".to_string()))
+    );
     assert_eq!(s.get("color"), None);
 
     // Verify that iter_pairs() works
@@ -45,7 +51,10 @@
 
 #[test]
 fn test_empty_value() {
-    let s = Stanza::from_pairs(vec![("empty".to_string(), StanzaValue::String("".to_string()))]);
+    let s = Stanza::from_pairs(vec![(
+        "empty".to_string(),
+        StanzaValue::String("".to_string()),
+    )]);
     assert_eq!(s.to_string(), "empty: \n");
 }
 
@@ -54,12 +63,26 @@
     let s = Stanza::from_pairs(vec![
         ("number".to_string(), StanzaValue::String("42".to_string())),
         ("name".to_string(), StanzaValue::String("fred".to_string())),
-        ("field-with-newlines".to_string(), StanzaValue::String("foo\nbar\nblah".to_string())),
-        ("special-characters".to_string(), StanzaValue::String(" \t\r\\\n ".to_string())),
+        (
+            "field-with-newlines".to_string(),
+            StanzaValue::String("foo\nbar\nblah".to_string()),
+        ),
+        (
+            "special-characters".to_string(),
+            StanzaValue::String(" \t\r\\\n ".to_string()),
+        ),
     ]);
     assert_eq!(
         s.to_lines(),
-        vec!["number: 42\n".to_string(), "name: fred\n".to_string(), "field-with-newlines: foo\n".to_string(), "\tbar\n".to_string(), "\tblah\n".to_string(), "special-characters:  \t\r\\\n".to_string(), "\t \n".to_string()],
+        vec![
+            "number: 42\n".to_string(),
+            "name: fred\n".to_string(),
+            "field-with-newlines: foo\n".to_string(),
+            "\tbar\n".to_string(),
+            "\tblah\n".to_string(),
+            "special-characters:  \t\r\\\n".to_string(),
+            "\t \n".to_string()
+        ],
     );
 }
 
@@ -71,11 +94,17 @@
 \tbar
 \tblah
 
-".split(|c| *c == b'\n').map(|s| s.to_vec());
-    let s = read_stanza(lines.map(|l|Ok(l))).unwrap().unwrap();
+"
+    .split(|c| *c == b'\n')
+    .map(|s| s.to_vec());
+    let s = read_stanza(lines.map(|l| Ok(l))).unwrap().unwrap();
     let expected = Stanza::from_pairs(vec![
         ("number".to_string(), StanzaValue::String("42".to_string())),
         ("name".to_string(), StanzaValue::String("fred".to_string())),
-        ("field-with-newlines".to_string(), StanzaValue::String("foo\nbar\nblah".to_string()))]);
+        (
+            "field-with-newlines".to_string(),
+            StanzaValue::String("foo\nbar\nblah".to_string()),
+        ),
+    ]);
     assert_eq!(s, expected);
 }

=== modified file 'crates/zlib-util-py/src/lib.rs'
--- crates/zlib-util-py/src/lib.rs	2023-04-14 10:24:19 +0000
+++ crates/zlib-util-py/src/lib.rs	2023-04-17 11:56:43 +0000
@@ -1,6 +1,6 @@
 #![allow(non_snake_case)]
+use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
-use pyo3::exceptions::PyValueError;
 
 #[pyclass]
 struct ZLibEstimator {
@@ -27,15 +27,15 @@
     }
 
     fn add_content(&mut self, content: &[u8]) -> PyResult<()> {
-        self.estimator.add_content(content).map_err(|e| {
-            PyValueError::new_err(format!("Failed to add content: {}", e))
-        })
+        self.estimator
+            .add_content(content)
+            .map_err(|e| PyValueError::new_err(format!("Failed to add content: {}", e)))
     }
 
     fn full(&mut self) -> PyResult<bool> {
-        self.estimator.full().map_err(|e| {
-            PyValueError::new_err(format!("Failed to check if full: {}", e))
-        })
+        self.estimator
+            .full()
+            .map_err(|e| PyValueError::new_err(format!("Failed to check if full: {}", e)))
     }
 }
 

=== modified file 'crates/zlib-util/src/estimator.rs'
--- crates/zlib-util/src/estimator.rs	2023-04-14 10:24:19 +0000
+++ crates/zlib-util/src/estimator.rs	2023-04-17 11:56:43 +0000
@@ -1,6 +1,6 @@
+use crate::python_default_deflate_encoder;
 use flate2::write::DeflateEncoder;
 use std::io::Write;
-use crate::python_default_deflate_encoder;
 
 pub struct ZLibEstimator {
     target_size: usize,
@@ -50,8 +50,8 @@
         self.unflushed_size_added = 0;
         // So far we've read X uncompressed bytes, and written Y compressed
         // bytes. We should have a decent estimate of the final compression.
-        self.estimated_compression = (self.uncompressed_size_added as f32)
-            / (self.compressed_size_added as f32);
+        self.estimated_compression =
+            (self.uncompressed_size_added as f32) / (self.compressed_size_added as f32);
     }
 
     pub fn full(&mut self) -> std::io::Result<bool> {
@@ -60,8 +60,7 @@
             let remaining_size = self.target_size - self.compressed_size_added;
             // Estimate how much compressed content the unflushed data will
             // consume
-            let est_z_size = (self.unflushed_size_added as f32)
-                / self.estimated_compression;
+            let est_z_size = (self.unflushed_size_added as f32) / self.estimated_compression;
             if est_z_size >= remaining_size as f32 {
                 // We estimate we are close to remaining
                 self.compressor.flush()?;
@@ -74,4 +73,3 @@
         Ok(self.compressed_size_added >= self.target_size)
     }
 }
-

=== modified file 'crates/zlib-util/src/lib.rs'
--- crates/zlib-util/src/lib.rs	2023-04-13 22:19:43 +0000
+++ crates/zlib-util/src/lib.rs	2023-04-17 11:56:43 +0000
@@ -1,5 +1,5 @@
+use flate2::write::DeflateEncoder;
 use flate2::Compression;
-use flate2::write::DeflateEncoder;
 use std::io::Write;
 
 pub fn python_default_deflate_encoder<I: Write>(input: I) -> DeflateEncoder<I> {

=== modified file 'tarmac.conf'
--- tarmac.conf	2023-01-29 22:40:48 +0000
+++ tarmac.conf	2023-04-17 11:56:43 +0000
@@ -1,6 +1,6 @@
 [Tarmac]
 setup_command = sudo apt -y update && sudo apt -y install cargo rustc python3-venv python3-gpg libpython3-dev make python3-setuptools-rust openssh-client patch mypy flake8
-verify_command = python3 -m venv --system-site-packages . && . bin/activate && ./bin/pip3 install setuptools-gettext && ./bin/pip3 install -e .[dev,doc,pgp,fastimport,launchpad,git,paramiko] && make extensions docs mypy flake8 PYTHON=$PWD/bin/python && BRZ_PLUGIN_PATH=-site:-user ./bin/python -m breezy selftest -v
+verify_command = python3 -m venv --system-site-packages . && . bin/activate && ./bin/pip3 install setuptools-gettext && ./bin/pip3 install -e .[dev,doc,pgp,fastimport,launchpad,git,paramiko] && make extensions docs mypy fmt-check PYTHON=$PWD/bin/python && BRZ_PLUGIN_PATH=-site:-user ./bin/python -m breezy selftest -v
 verify_command_output_timeout = 1800
 commit_message_template = <commit_message>